debugged round privateIn

Author: kuco23

pokerlib/__init__.py

@@ -20,4 +20,4 @@
     'PlayerGroup',
     'Round',
     'Table'
-] + enums.__all__
+]

pokerlib/_handparser.py

@@ -5,8 +5,8 @@ class HandParser:
     __slots__ = [
         "original", "ncards", "cards",
         "handenum", "handbase", "kickers",
-        "__valnums", "__suitnums",
-        "__flushsuit", "__straightindexes"
+        "_valnums", "_suitnums",
+        "_flushsuit", "_straightindexes"
     ]
 
     def __init__(self, cards: list):
@@ -18,20 +18,20 @@ def __init__(self, cards: list):
         self.handbase = []
         self.kickers = []
 
-        self.__valnums = [0] * 13
-        self.__suitnums = [0] * 4
+        self._valnums = [0] * 13
+        self._suitnums = [0] * 4
         for value, suit in cards:
-            self.__valnums[value] += 1
-            self.__suitnums[suit] += 1
+            self._valnums[value] += 1
+            self._suitnums[suit] += 1
 
-        self.__flushsuit = None
+        self._flushsuit = None
         for suit in Suit:
-            if self.__suitnums[suit] >= 5:
-                self.__flushsuit = suit
+            if self._suitnums[suit] >= 5:
+                self._flushsuit = suit
                 break
 
-        self.__straightindexes = \
-            self.getStraightIndexes(self.__valnums)
+        self._straightindexes = \
+            self._getStraightIndexes(self._valnums)
 
     @property
     def handbasecards(self):
@@ -81,7 +81,11 @@ def __lt__(self, other):
             if s_val != o_val: return s_val < o_val
         return False
 
-    def addCards(self, cards):
+    def __iadd__(self, cards):
+        self._addCards(cards)
+        return self
+
+    def _addCards(self, cards):
         self.original.extend(cards)
         self.ncards += len(cards)
         for card in cards: insort(self.cards, card)
@@ -91,19 +95,19 @@ def addCards(self, cards):
         self.kickers.clear()
 
         for value, suit in cards:
-            self.__valnums[value] += 1
-            self.__suitnums[suit] += 1
+            self._valnums[value] += 1
+            self._suitnums[suit] += 1
 
         for suit in Suit:
-            if self.__suitnums[suit] >= 5:
-                self.__flushsuit = suit
+            if self._suitnums[suit] >= 5:
+                self._flushsuit = suit
                 break
 
-        self.__straightindexes = \
-            self.getStraightIndexes(self.__valnums)
+        self._straightindexes = \
+            self._getStraightIndexes(self._valnums)
 
     @staticmethod
-    def getStraightIndexes(valnums):
+    def _getStraightIndexes(valnums):
         straightindexes = [None] * 5
         straightlen, indexptr = 1, sum(valnums)
         for i in reversed(range(len(valnums))):
@@ -123,12 +127,12 @@ def _setStraightFlush(self):
         counter = 0
         suited_vals, permut = [0] * 13, [0] * len(self.cards)
         for i, (val, suit) in enumerate(self.cards):
-             if suit == self.__flushsuit:
+             if suit == self._flushsuit:
                  suited_vals[val] += 1
                  permut[counter] = i
                  counter += 1
 
-        suited_handbase = self.getStraightIndexes(suited_vals)
+        suited_handbase = self._getStraightIndexes(suited_vals)
         if suited_handbase is not None:
             self.handenum = Hand.STRAIGHTFLUSH
             self.handbase = [permut[i] for i in suited_handbase]
@@ -140,7 +144,7 @@ def _setFourOfAKind(self):
         self.handenum = Hand.FOUROFAKIND
 
         hindex = -1
-        for valnum in self.__valnums:
+        for valnum in self._valnums:
             hindex += valnum
             if valnum == 4: break
 
@@ -151,7 +155,7 @@ def _setFullHouse(self):
 
         threes, twos = [], []
         hindex = -1
-        for val, valnum in enumerate(self.__valnums):
+        for val, valnum in enumerate(self._valnums):
             hindex += valnum
             if valnum == 3: threes.append((val, hindex))
             elif valnum == 2: twos.append((val, hindex))
@@ -165,22 +169,22 @@ def _setFlush(self):
 
         counter = 0
         for i in reversed(range(self.ncards)):
-            if self.cards[i][1] == self.__flushsuit:
+            if self.cards[i][1] == self._flushsuit:
                 self.handbase.append(i)
                 counter += 1
             if counter == 5:
                 break
 
     def _setStraight(self):
         self.handenum = Hand.STRAIGHT
-        self.handbase = self.__straightindexes
+        self.handbase = self._straightindexes
 
     def _setThreeOfAKind(self):
         self.handenum = Hand.THREEOFAKIND
         self.handbase.clear()
 
         hindex = -1
-        for valnum in self.__valnums:
+        for valnum in self._valnums:
             hindex += valnum
             if valnum == 3: break
 
@@ -191,7 +195,7 @@ def _setTwoPair(self):
         self.handbase.clear()
 
         hindex, paircounter = self.ncards, 0
-        for valnum in reversed(self.__valnums):
+        for valnum in reversed(self._valnums):
             hindex -= valnum
             if valnum == 2:
                 self.handbase.extend([hindex+1, hindex])
@@ -202,7 +206,7 @@ def _setOnePair(self):
         self.handenum = Hand.ONEPAIR
 
         hindex = -1
-        for valnum in self.__valnums:
+        for valnum in self._valnums:
             hindex += valnum
             if valnum == 2: break
 
@@ -214,18 +218,18 @@ def _setHighCard(self):
 
     def _setHand(self):
         pairnums = [0] * 5
-        for num in self.__valnums: pairnums[num] += 1
+        for num in self._valnums: pairnums[num] += 1
 
-        if None not in [self.__straightindexes, self.__flushsuit] \
+        if None not in [self._straightindexes, self._flushsuit] \
         and self._setStraightFlush():
             pass
         elif pairnums[4]:
             self._setFourOfAKind()
         elif pairnums[3] == 2 or pairnums[3] == 1 and pairnums[2] >= 1:
             self._setFullHouse()
-        elif self.__flushsuit is not None:
+        elif self._flushsuit is not None:
             self._setFlush()
-        elif self.__straightindexes is not None:
+        elif self._straightindexes is not None:
             self._setStraight()
         elif pairnums[3]:
             self._setThreeOfAKind()

pokerlib/_round.py

@@ -13,8 +13,8 @@
 #   should be kept within one object.            #
 #   That object has a generator-like property,   #
 #   so that, when sent valid input,              #
-#   it updates properties so it's ready          #
-#   for the next valid input.                    #
+#   it updates properties which make it          #
+#   ready for the next valid input.              #
 #                                                #
 ##################################################
 
@@ -126,7 +126,7 @@ def _turnGenerator(self):
 
             for player in self.players:
                 player.played_turn = False
-                player.hand.addCards(new_cards)
+                player.hand += new_cards
                 player.hand.parse()
 
             self.table.extend(new_cards)
@@ -343,12 +343,11 @@ def close(self):
         self.finished = True
         self.publicOut(PublicOutId.ROUNDFINISHED)
 
-
-    def privateIn(self, user_id, **kwargs):
+    def privateIn(self, action, raise_by=0):
         """Processes ivalidated user input"""
         # this is a standard action validation,
         # which can be overriden
-        
+        print('private')
         player = self.current_player
         to_call = self.turn_stake - player.turn_stake[self.turn]
 

pokerlib/_table.py

@@ -1,7 +1,7 @@
 from operator import add
 from math import inf
 
-from .enums import *
+from .enums import PlayerAction
 from ._player import Player, PlayerGroup
 from ._round import Round
 
@@ -16,8 +16,8 @@ def __init__(self, _id, players, small_blind, big_blind):
         self.button = 0
         self.round = None
         self.interrupt = False
-        self.__player_removal_schedule = []
-        self.__player_addition_schedule = []
+        self._player_removal_schedule = []
+        self._player_addition_schedule = []
 
     def __bool__(self):
         return 2 <= len(self.players.getNotBrokePlayers()) <= 9
@@ -29,17 +29,17 @@ def __eq__(self, other):
         return self.id == other.id
 
     def __iadd__(self, players):
-        self.__player_addition_schedule.extend(players)
+        self._player_addition_schedule.extend(players)
         if not self.round: self._updatePlayers()
         return self
 
     def __isub__(self, players):
-        self.__player_removal_schedule.extend(players)
+        self._player_removal_schedule.extend(players)
         if not self.round: self._updatePlayers()
         else:
             for player in players:
                 if player.id == self.round.current_player.id:
-                    self.round.processAction(PlayerAction.FOLD)
+                    self.round.privateIn(PlayerAction.FOLD)
                 elif player.id in self.round:
                     player.is_folded = True
         return self
@@ -48,15 +48,15 @@ def __isub__(self, players):
     def all_players(self):
         return add(
             self.players,
-            self.__player_addition_schedule
+            self._player_addition_schedule
         )
 
     # called only when round is finished
     def _updatePlayers(self):
-        self.players.extend(self.__player_addition_schedule)
-        self.players.remove(self.__player_removal_schedule)
-        self.__player_addition_schedule.clear()
-        self.__player_removal_schedule.clear()
+        self.players.extend(self._player_addition_schedule)
+        self.players.remove(self._player_removal_schedule)
+        self._player_addition_schedule.clear()
+        self._player_removal_schedule.clear()
 
     def newRound(self, round_id):
         assert not self.round

tests/round_test.py

@@ -1,8 +1,7 @@
-from sys import path
-from pathlib import Path
+from os import chdir
 from argparse import ArgumentParser
 
-path.append(str(Path().cwd().parent))
+chdir('..')
 
 from pokerlib.enums import *
 from pokerlib import HandParser