def testBoardEightLow(self): for board in [ "AC 2C 3C 4C 5C", "AC AH 3C 4C 9C", "AC 2C 8C TC KC" ]: self.assertEqual(Board.fromString(board).eightLowPossible(), True, "%s not True" % board) for board in [ "AC AH 8C 9D TH", "AC AH 2D TC JH", "8C 9H TD JC QH", "AC 2C 9C TC JD" ]: self.assertEqual(Board.fromString(board).eightLowPossible(), False, "%s not False" % board)
def testOmahaNoLow(self):
"""Test Omaha low hand ranking of hand without low with EightLowRanker."""
ranker = EightLowRanker()
hand = Omaha.Hand.fromString("QC AH TC 9C")
board = Board.fromString("2H JH 4D 6H 3H")
hand.setBoard(board)
rank = ranker.rankHand(hand)
self.assertIsNone(rank)
hand = Omaha.Hand.fromString("QC AH TC 8C")
board = Board.fromString("2H JH KD JS 3H")
hand.setBoard(board)
rank = ranker.rankHand(hand)
self.assertIsNone(rank)
def testHiLoGame(self):
"""Test OmahaHiLoGame."""
game = Omaha.HiLoGame()
game.setBoard(Board.fromString("5C 2S 4D"))
game.addHand(Omaha.Hand.fromString("AC 2C"))
game.addHand(Omaha.Hand.fromString("AH KH"))
game.simulateGames(numGames=10)
def testGame(self):
"""Test HoleEmGame."""
game = HoldEm.Game()
game.setBoard(Board.fromString("5C 2S 4D"))
game.addHand(HoldEm.Hand.fromString("AC 2C"))
game.addHand(HoldEm.Hand.fromString("AH KH"))
game.simulateGames(numGames=10)
def testBoardCombinations(self):
"""Test combinations with board."""
hand = HoldEm.Hand.fromString("AD 2D")
board = Board.fromString("3D 4D 5D")
hand.setBoard(board)
count = 0
for combs in hand.combinations(2):
count += 1
self.assertEquals(len(combs), 2)
self.assertEquals(count, 10)
count = 0
for combs in hand.combinations(5):
count += 1
self.assertEquals(len(combs), 5)
self.assertEquals(count, 1)
board.addCardFromString("6D")
count = 0
for combs in hand.combinations(5):
count += 1
self.assertEquals(len(combs), 5)
self.assertEquals(count, 6)
board.addCardFromString("7D")
count = 0
for combs in hand.combinations(5):
count += 1
self.assertEquals(len(combs), 5)
self.assertEquals(count, 21)
def testCombinations(self):
"""Testing Omaha combinations."""
hand = Omaha.Hand.fromString("AC 2C 3C 4C");
board = Board.fromString("5C 6C 7C 8C 9C");
hand.setBoard(board)
self.assert_iterator(hand.combinations(2), count=6,
assert_item_function=lambda i: len(i) == 2)
self.assert_iterator(hand.hands(), count=60,
assert_item_function=lambda i: len(i) == 5)
def testOmaha(self):
"""Test basic Omaha hand ranking."""
hand = Omaha.Hand.fromString("7S QD 2D TD")
board = Board.fromString("AS AD 4H TH 8D")
hand.setBoard(board)
rank = self.ranker.rankHand(hand)
self.assertEqual(rank.getType(), PokerRank.TWO_PAIR, "rank = %s" % rank)
self.assertEqual(rank.getPrimaryCardRank(), Rank.ACE,
"primaryCard = %s" % rank.getPrimaryCardRank())
self.assertEqual(rank.getSecondaryCardRank(), Rank.TEN,
"secondaryCard = %s" % rank.getSecondaryCardRank())
def testOmahaLow2(self):
"""Test Omaha low hand ranking."""
hand = Omaha.Hand.fromString("QC AH TC 8C")
board = Board.fromString("2H JH 4D 6H 3H")
hand.setBoard(board)
rank = self.ranker.rankHand(hand)
self.assertEqual(rank.getType(), PokerRank.HIGH_CARD,
"rank = %s" % rank)
self.assertEqual(rank.getPrimaryCardRank(), Rank.EIGHT,
"primaryCard = %s kickers = %s" % (rank.getPrimaryCardRank(),
rank.kickersAsString()))
def testOmahaLow3(self):
"""Test Omaha low hand ranking with EightLowRanker."""
ranker = EightLowRanker()
hand = Omaha.Hand.fromString("QC AH TC 5C")
board = Board.fromString("2H JH 4D 6H KH")
hand.setBoard(board)
rank = ranker.rankHand(hand)
self.assertIsNotNone(rank)
self.assertEqual(rank.getType(), PokerRank.HIGH_CARD,
"rank = %s" % rank)
self.assertEqual(rank.getPrimaryCardRank(), Rank.SIX,
"primaryCard = %s kickers = %s" % (rank.getPrimaryCardRank(),
rank.kickersAsString()))
def test_combinations_of_eight_or_lower(self):
"""Test combinations_of_eight_or_lower() method on hand with board"""
# Hand doesn't have two low cards, can't make low
hand = Omaha.Hand.fromString("AD 9D JS QS")
board = Board.fromString("3D 4D 5D")
hand.setBoard(board)
self.assert_iterator(hand.combinations_of_eight_or_lower(5),
count=0)
# Board doesn't have three low cards, can't make low
hand = Omaha.Hand.fromString("AD 9D 7D QS")
board = Board.fromString("3D KD 5D")
hand.setBoard(board)
self.assert_iterator(hand.combinations_of_eight_or_lower(5),
count=0)
# Three low cards in hand, 3 on board == 3 possible lows
hand = Omaha.Hand.fromString("AD 9D 7D 8S")
board = Board.fromString("3D 4D 5D")
hand.setBoard(board)
self.assert_iterator(hand.combinations_of_eight_or_lower(5),
count=3,
assert_item_function=lambda i: len(i)==5)
# Two low cards in hand, 3 on board == 1 possible low
hand = Omaha.Hand.fromString("AD 9D 7D QS")
board = Board.fromString("3D 4D 5D")
hand.setBoard(board)
self.assert_iterator(hand.combinations_of_eight_or_lower(5),
count=1,
assert_item_function=lambda i: len(i)==5)
# Add a low card to the board for 2 in hand, 4 on board == 4 combos
board.addCardFromString("6D")
self.assert_iterator(hand.combinations_of_eight_or_lower(5),
count=4,
assert_item_function=lambda i: len(i)==5)
# Add a high card to board, should have no change
board.addCardFromString("TD")
self.assert_iterator(hand.combinations_of_eight_or_lower(5),
count=4,
assert_item_function=lambda i: len(i)==5)
def testBoard(self):
"""Verify ranking with board."""
board = Board.fromString("5C 2S 4D")
hand = HoldEm.Hand.fromString("AC 2C")
hand.setBoard(board)
rank = self.ranker.rankHand(hand)
self.assertEqual(rank.getType(), PokerRank.PAIR,
"rankType = %d" % rank.getType())
board.addCardFromString("AD")
rank = self.ranker.rankHand(hand)
self.assertEqual(rank.getType(), PokerRank.TWO_PAIR,
"rank = %d" % rank.getType())
board.addCardFromString("3H")
rank = self.ranker.rankHand(hand)
self.assertEqual(rank.getType(), PokerRank.STRAIGHT,
"rank = %d" % rank.getType())
def testCombinations(self):
"""Testing Omaha combinations."""
hand = Omaha.Hand.fromString("AC 2C 3C 4C");
board = Board.fromString("5C 6C 7C 8C 9C");
hand.setBoard(board)
count = 0
for combs in hand.combinations(2):
count += 1
self.assertEquals(len(combs), 2,
"combs = %s (len = %d)" % (combs, len(combs)))
self.assertEquals(count, 6)
count = 0
for combs in hand.hands():
count += 1
self.assertEquals(len(combs), 5,
"combs = %s (len = %d)" % (combs, len(combs)))
self.assertEquals(count, 60)
def testBoardCombinations(self):
"""Test combinations with board."""
hand = HoldEm.Hand.fromString("AD 2D")
board = Board.fromString("3D 4D 5D")
hand.setBoard(board)
self.assert_iterator(hand.combinations(2),
count=10,
assert_item_function=lambda i: len(i) == 2)
self.assert_iterator(hand.combinations(5),
count=1,
assert_item_function=lambda i: len(i) == 5)
board.addCardFromString("6D")
self.assert_iterator(hand.combinations(5),
count=6,
assert_item_function=lambda i: len(i) == 5)
board.addCardFromString("7D")
self.assert_iterator(hand.combinations(5),
count=21,
assert_item_function=lambda i: len(i) == 5)
def test_combinations_of_eight_or_lower_with_board(self):
"""Test combinations_of_eight_or_lower() method on hand with board"""
hand = HoldEm.Hand.fromString("AD 2D")
board = Board.fromString("3D 4D 5D")
hand.setBoard(board)
self.assert_iterator(hand.combinations_of_eight_or_lower(2),
count=10,
assert_item_function=lambda i: len(i)==2)
self.assert_iterator(hand.combinations_of_eight_or_lower(5),
count=1,
assert_item_function=lambda i: len(i)==5)
board.addCardFromString("6D")
self.assert_iterator(hand.combinations_of_eight_or_lower(5),
count=6,
assert_item_function=lambda i: len(i)==5)
# Now add a card that should have no effect on results
board.addCardFromString("TD")
self.assert_iterator(hand.combinations_of_eight_or_lower(5),
count=6,
assert_item_function=lambda i: len(i)==5)
def main(argv=None):
if argv is None:
argv = sys.argv
usage = "usage: %prog [<options>]"
version = "%prog version 1.0"
parser = OptionParser(usage=usage, version=version)
parser.add_option("-n", "--numDeals", type="int", dest="numDeals",
default=1000,
help="number of deals to simulate (Default is 100)")
parser.add_option("-p", "--showProgress", action="store_true",
dest="showProgress", default=False, help="show progress")
parser.add_option("-s", "--suitedCards", type="int", dest="suitedCards",
default=2,
help="number of suited cards in hand (default is 2)")
(options, args) = parser.parse_args()
print "Testing for %d deals, %d suited cards in hand" % (options.numDeals,
options.suitedCards)
# Two-dimensional array. First dimension is number of cards of given suit
# on flop, second dimension is number of cards of given suit on full board
count = []
for index in range(4):
count.append([0] * 6)
# The suit we care about
suit = Suit(Suit.CLUBS)
# Build starting deck
startingDeck = Deck()
for index in range(options.suitedCards):
startingDeck.removeCards(Card((Rank(Rank.ranks[index]), suit)))
madeFlushes = [0] * 4
for deal in range(options.numDeals):
deck = startingDeck.copy()
deck.shuffle()
board = Board()
# Deal out and save flop
deck.deal(board, 3)
flop = board.copy()
# Deal turn and river
deck.deal(board, 2)
# Find highest number of cards of same suit
flushCount = 0
flopCount = flop.suitCount(suit)
boardCount = board.suitCount(suit)
count[flopCount][boardCount] += 1
if (options.suitedCards + boardCount) > 4:
madeFlushes[flopCount] += 1
# Update progress if so requested
if options.showProgress and (deal % 20 == 0):
sys.stdout.write(".")
sys.stdout.flush()
if options.showProgress:
print
colwidth = 6
for col in ["Flopped", "Occur", "Final", "0", "1", "2", "3", "4", "5", "Flushes"]:
print col.center(colwidth),
print
for index in range(len(count)):
array = count[index]
total = reduce(lambda a,b: a + b, array)
print str(index).rjust(colwidth),
print str(total).rjust(colwidth),
print " ".ljust(colwidth),
if total > 0:
for subindex in range(len(array)):
if ((subindex < index) or
(subindex > index + 3)):
print " ".ljust(colwidth),
else:
s = "%3.0f%%" % (100.0 * array[subindex]/total)
print s.rjust(colwidth),
s = "%3.0f%%" % (100.0 * madeFlushes[index]/total)
print s,
print
totalFlushes = reduce(lambda a,b: a + b, madeFlushes)
print "Total made flushes: %d (%3.0f%%)" % (totalFlushes,
100.0 * totalFlushes / options.numDeals)
def testBoardToString(self):
board = Board.fromString("7C 8C 9C")
self.assertEqual("%s" % board, "7C 8C 9C xx xx")
predefined_hands.append(hg)
if len(predefined_hands) == 0:
print "No hands read from %s. Quitting." % configFileName
sys.exit(0)
if options.verbose:
print "Read %d hands" % len(predefined_hands)
predefined_board = None
try:
boardStr = config.get("board", "cards")
except:
pass
else:
predefined_boardboard = Board.fromString(boardStr)
if options.verbose:
print "Setting board: %s" % board
game.setBoard(board)
if options.verbose:
callback=showHandCallback
else:
callback=None
if options.verbose:
print "Running..."
simulator = HoldEm.Simulator(predefined_hands=predefined_hands,
predefined_board=predefined_board)
def main(argv=None):
if argv is None:
argv = sys.argv
usage = "usage: %prog [<options>]"
version = "%prog version 1.0"
parser = OptionParser(usage=usage, version=version)
parser.add_option("-n", "--numDeals", type="int", dest="numDeals",
default=1000,
help="number of deals to simulate (Default is 100)")
parser.add_option("-p", "--showProgress", action="store_true",
dest="showProgress", default=False, help="show progress")
(options, args) = parser.parse_args()
print "Testing for %d deals" % options.numDeals
lowDraw = 0
lowDrawCompleted = 0
floppedLow = 0
lowPossible = 0
backdoorLow = 0
for deal in range(options.numDeals):
deck = Deck()
deck.shuffle()
board = Board()
# Deal out flop and count low cards
deck.deal(board, 3)
flopLowCount = board.countEightOrLower()
if flopLowCount == 2:
lowDraw += 1
# Finish dealing turn and river
deck.deal(board, 2)
# Analyze
lowCount = board.countEightOrLower()
if lowCount > 2:
lowPossible += 1
if flopLowCount == 3:
# Flopped a low
floppedLow += 1
elif flopLowCount == 2:
# Completed a draw
lowDrawCompleted += 1
else:
# Backdoor low
backdoorLow += 1
# Update progress if so requested
if options.showProgress and (deal % 20 == 0):
sys.stdout.write(".")
sys.stdout.flush()
if options.showProgress:
print
statStr = lambda name, value: "%-30s %5d (%5.2f%%)" % (name.capitalize() + ":", value, 100.0 * value / options.numDeals)
print statStr("eight-low possible", lowPossible)
print statStr("flopped low", floppedLow)
print statStr("flopped low draw", lowDraw)
print statStr("completed draw", lowDrawCompleted)
print statStr("backdoor low", backdoorLow)
game.addHandGenerator(hg)
handNum += 1
if handNum == 0:
print "No hands read from %s. Quitting." % configFileName
sys.exit(0)
if options.verbose:
print "Read %d hands" % handNum
try:
boardStr = config.get("board", "cards")
except:
pass
else:
board = Board.fromString(boardStr)
if options.verbose:
print "Setting board: %s" % board
game.setBoard(board)
if options.verbose:
callback=showHandCallback
else:
callback=None
if options.verbose:
print "Running..."
game.simulateGames(options.numGames, callback=callback)
print game.statsToString()
def main(argv=None):
if argv is None:
argv = sys.argv
usage = "usage: %prog [<options>]"
version = "%prog version 1.0"
parser = OptionParser(usage)
parser.add_option("-B", "--board", type="string", dest="board",
metavar="cards", help="specify the flop")
parser.add_option("-g", "--game", type="string", dest="game",
default="holdem", help="game to simulate")
parser.add_option("-H", "--hand", type="string", dest="hands",
metavar="cards", action="append", help="add a hand")
parser.add_option("-n", "--numGames", type="int", dest="numGames",
default=100, help="number of games to simulate")
parser.add_option("-N", "--numHands", type="int", dest="numHands",
default=10, help="number of hands in play")
parser.add_option("-p", "--showProgress", action="store_true",
dest="showProgress", default=False, help="show progress")
parser.add_option("-P", "--profile", type="string", dest="profile",
default=None, help="enable profiling")
parser.add_option("-q", "--quiet", action="store_true",
dest="quiet", default=False, help="run quietly")
parser.add_option("-v", "--verbose", action="store_true", dest="verbose",
default=False, help="show results of each hand")
(options, args) = parser.parse_args()
game = {
"holdem" : HoldEm.Game,
"5cardstud" : FiveCardStud.Game,
"fivecardstud" : FiveCardStud.Game,
"5cardstudhilo" : FiveCardStud.HiLoGame,
"fivecardstudhilo" : FiveCardStud.HiLoGame,
"7cardstud" : SevenCardStud.Game,
"sevencardstud" : SevenCardStud.Game,
"7cardstudhilo" : SevenCardStud.HiLoGame,
"sevencardstudhilo" : SevenCardStud.HiLoGame,
"omaha" : Omaha.Game,
"omahahilo" : Omaha.HiLoGame,
}
if game.has_key(options.game):
GameClass = game[options.game]
else:
print "Unknown game type \"%s\"" % options.game
print "Known games are:"
for name in game.keys():
print "\t%s" % name
sys.exit(1)
maxHands = GameClass.getMaxHands()
if options.numHands > maxHands:
options.numHands = maxHands
if options.verbose:
print "Reducing number of hands to %d" % maxHands
game = GameClass(numHands = options.numHands)
HandClass = GameClass.getHandClass()
if options.hands is not None:
hands = Hands()
for hand in options.hands:
hands.addHand(HandClass.fromString(hand))
game.addHands(hands)
if options.board:
game.setBoard(Board.fromString(options.board))
if options.verbose:
callback=showHandCallback
print "Simulating %d games of %s" % (options.numGames,
GameClass.gameName)
print "%d Hands" % game.getNumHands(),
if game.hands:
print ": %s" % game.hands
else:
print
if game.board:
print "Board: %s" % game.board
elif options.showProgress:
callback=showProgressCallback
else:
callback=None
cmd="game.simulateGames(options.numGames, callback=callback)"
if options.profile:
import cProfile
if options.verbose:
print "Profiling to file %s" % options.profile
# Need to supply context here as run() will just use __main__
cProfile.runctx(cmd, globals(), locals(), filename=options.profile)
else:
eval(cmd)
if options.showProgress:
print
if not options.quiet:
print game.statsToString()
