PokerKit

https://pokerkit.readthedocs.io/en/stable
Admin
PokerKit is an open-source Python library for simulating poker games, evaluating hands, and...
Tokens:158,714
Snippets:1,506
Trust Score:9.6
Update:4 months ago
Show doc for...
Tokens:
Raw
### Setup and Activate Virtual Environment

Source: https://pokerkit.readthedocs.io/en/stable/contributing.html

Create and activate a Python virtual environment for your development setup.

```bash
python -m venv venv
source venv/bin/activate
```

--------------------------------

### Get Hand Example

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates how to retrieve a player's hand at different stages of a poker game (pre-flop, flop, turn, river). Requires initializing a game state and dealing cards.

```python
>>> from pokerkit import NoLimitTexasHoldem
>>> state = NoLimitTexasHoldem.create_state(
...     (
...         Automation.ANTE_POSTING,
...         Automation.BET_COLLECTION,
...         Automation.BLIND_OR_STRADDLE_POSTING,
...         Automation.HOLE_CARDS_SHOWING_OR_MUCKING,
...         Automation.HAND_KILLING,
...         Automation.CHIPS_PUSHING,
...         Automation.CHIPS_PULLING,
...     ),
...     True,
...     0,
...     (1, 2),
...     2,
...     (50, 100),
...     2,
... )
>>> state.get_hand(0, 0, 0) is None
True
>>> state.get_hand(1, 0, 0) is None
True

Pre-flop.
>>> state.deal_hole('AcAd')  
HoleDealing(commentary=None, player_index=0, cards=(Ac, Ad), statuse...
>>> state.deal_hole('KsQs')  
HoleDealing(commentary=None, player_index=1, cards=(Ks, Qs), statuse...
>>> state.get_hand(0, 0, 0) is None
True
>>> state.get_hand(1, 0, 0) is None
True
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=1, amount=1)
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=0, amount=0)

Flop.
>>> state.burn_card('??')
CardBurning(commentary=None, card=??)
>>> state.deal_board('JsTs2c')
BoardDealing(commentary=None, cards=(Js, Ts, 2c))
>>> state.get_hand(0, 0, 0)
AcAdJsTs2c
>>> str(state.get_hand(0, 0, 0))
'One pair (AcAdJsTs2c)'
>>> str(state.get_hand(1, 0, 0))
'High card (KsQsJsTs2c)'
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=0, amount=0)
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=1, amount=0)

Turn.
>>> state.burn_card('??')
CardBurning(commentary=None, card=??)
>>> state.deal_board('Ah')
BoardDealing(commentary=None, cards=(Ah,))
>>> str(state.get_hand(0, 0, 0))
'Three of a kind (AcAdJsTsAh)'
>>> str(state.get_hand(1, 0, 0))
'Straight (KsQsJsTsAh)'
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=0, amount=0)
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=1, amount=0)

River.
>>> state.burn_card('??')
CardBurning(commentary=None, card=??)
>>> state.deal_board('As')
BoardDealing(commentary=None, cards=(As,))
>>> str(state.get_hand(0, 0, 0))
'Four of a kind (AcAdJsAhAs)'
>>> str(state.get_hand(1, 0, 0))
'Straight flush (KsQsJsTsAs)'
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=0, amount=0)
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=1, amount=0)
>>> state.get_hand(0, 0, 0) is None
True
>>> str(state.get_hand(1, 0, 0))
'Straight flush (KsQsJsTsAs)'
```

--------------------------------

### Initializing Game State with Different Starting Stack Formats

Source: https://pokerkit.readthedocs.io/en/stable/simulation.html

Demonstrates various ways to supply starting stacks and the number of players when initializing a game state. PokerKit is flexible in accepting starting stacks as tuples, lists, dictionaries, or a single number for uniform stacks.

```python
state = game(
    (200, 200, 200, 200),  # starting stacks
    4,  # number of players
)
```

```python
state = game(
    [200, 200, 200, 200],  # starting stacks
    4,  # number of players
)
```

```python
state = game(
    {0: 200, 1: 200, 2: 200, 3: 200},  # starting stacks
    4,  # number of players
)
```

```python
state = game(
    200,  # starting stacks
    4,  # number of players
)
```

--------------------------------

### Install Project Requirements

Source: https://pokerkit.readthedocs.io/en/stable/contributing.html

Install all necessary dependencies for PokerKit development using pip.

```bash
pip install -r requirements.txt
```

--------------------------------

### Install PokerKit using pip

Source: https://pokerkit.readthedocs.io/en/stable/index.html

Install the PokerKit library using pip. Requires Python 3.11 or above.

```bash
pip install pokerkit

```

--------------------------------

### Kuhn Poker Hand Lookup Example

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Shows how to use KuhnPokerLookup to get entries for Kuhn poker hands. Includes an example of an invalid hand and comparison of hand strengths.

```python
>>> lookup = KuhnPokerLookup()
>>> e0 = lookup.get_entry('J?')
>>> e1 = lookup.get_entry('Q?')
>>> e2 = lookup.get_entry('2?')
Traceback (most recent call last):
    ...
ValueError: The cards '2?' form an invalid hand.
>>> e0 < e1
True
>>> e0.label
<Label.HIGH_CARD: 'High card'>
>>> e1.label
<Label.HIGH_CARD: 'High card'>
```

--------------------------------

### Lookup get_entry Method Example

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Shows how to use the get_entry method of a Lookup subclass (ShortDeckHoldemLookup) to determine the index and label of a hand. Includes an example of an invalid hand.

```python
>>> lookup = ShortDeckHoldemLookup()
>>> entry = lookup.get_entry('Ah6h7s8c9s')
>>> entry.index
1128
>>> entry.label
<Label.STRAIGHT: 'Straight'>
>>> entry = lookup.get_entry('Ah6h7s8c2s')
Traceback (most recent call last):
    ...
ValueError: The cards 'Ah6h7s8c2s' form an invalid hand.
```

--------------------------------

### Get Up Cards Example

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates how to retrieve a player's visible cards (up cards) in a Seven Card Stud game. Requires initializing a game state and dealing hole cards.

```python
>>> from pokerkit import FixedLimitSevenCardStud
>>> state = FixedLimitSevenCardStud.create_state(
...     (
...         Automation.ANTE_POSTING,
...         Automation.BET_COLLECTION,
...         Automation.BLIND_OR_STRADDLE_POSTING,
...         Automation.CARD_BURNING,
...         Automation.HOLE_CARDS_SHOWING_OR_MUCKING,
...         Automation.HAND_KILLING,
...         Automation.CHIPS_PUSHING,
...         Automation.CHIPS_PULLING,
...     ),
...     True,
...     0,
...     1,
...     2,
...     4,
...     (50, 100),
...     2,
... )
>>> state.deal_hole('AcAdAh')  
HoleDealing(commentary=None, player_index=0, cards=(Ac, Ad, Ah), sta...
>>> state.deal_hole('KcKdKh')  
HoleDealing(commentary=None, player_index=1, cards=(Kc, Kd, Kh), sta...
>>> state.get_down_cards(0)  
<generator object State.get_down_cards at 0x...>
>>> tuple(state.get_up_cards(0))
(Ah,)
```

--------------------------------

### Standard Lookup Example

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Illustrates using the StandardLookup to get entries for poker hands and comparing their strengths and labels.

```python
>>> lookup = StandardLookup()
>>> e0 = lookup.get_entry('As3sQhJsJc')
>>> e1 = lookup.get_entry('2s4sKhKsKc')
>>> e0 < e1
True
>>> e0.label
<Label.ONE_PAIR: 'One pair'>
>>> e1.label
<Label.THREE_OF_A_KIND: 'Three of a kind'>
```

--------------------------------

### Entry Class Usage Example

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Illustrates the creation and comparison of Entry objects, showing how their index and label attributes are used to determine hand strength.

```python
>>> e0 = Entry(0, Label.HIGH_CARD)
>>> e1 = Entry(1, Label.HIGH_CARD)
>>> e2 = Entry(1, Label.HIGH_CARD)
>>> e0 < e1
True
>>> e1 < e2
False
>>> e0 == e1
False
>>> e1 == e2
True
>>> e0.index
0
>>> e0.label
<Label.HIGH_CARD: 'High card'>
```

--------------------------------

### Initialize Fixed Limit Badugi Game State

Source: https://pokerkit.readthedocs.io/en/stable/examples.html

Sets up the initial game state for a Fixed Limit Badugi game. Starting stacks are set to infinity as they are not specified in the example.

```python
from math import inf
from pokerkit import *
state = FixedLimitBadugi.create_state(
    (
        Automation.ANTE_POSTING,
        Automation.BET_COLLECTION,
        Automation.BLIND_OR_STRADDLE_POSTING,
        Automation.HAND_KILLING,
        Automation.CHIPS_PUSHING,
        Automation.CHIPS_PULLING,
    ),
    True,
    0,
    (1, 2),
    2,
    4,
    inf,
    4,
)
```

--------------------------------

### Starting Stacks Pattern (Detailed)

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Detailed pattern for capturing player name and starting stack from seat information lines, ensuring accurate initial stack parsing.

```python
STARTING_STACKS _ = re.compile('Seat \d+: (?P<player>.+) \\(\D?(?P<starting_stack>[0-9.,]+)\\)[^,]')
```

--------------------------------

### Create and Compare ShortDeckHoldemHand

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Illustrates creating ShortDeckHoldemHand instances, including an example that raises a ValueError for an invalid hand. It also shows printing and comparing hands.

```python
>>> h0 = ShortDeckHoldemHand('6s7s8s9sTs')
>>> h1 = ShortDeckHoldemHand('7c8c9cTcJc')
>>> h2 = ShortDeckHoldemHand('2c2d2h2s3h')  
Traceback (most recent call last):
    ...
ValueError: The cards '2c2d2h2s3h' form an invalid ShortDeckHoldemHand h...
>>> h0
6s7s8s9sTs
>>> h1
7c8c9cTcJc
>>> print(h0)
Straight flush (6s7s8s9sTs)
>>> h0 < h1
True
```

--------------------------------

### Create ShortDeckHoldemHand from cards

Source: https://pokerkit.readthedocs.io/en/stable/evaluation.html

Demonstrates creating a ShortDeckHoldemHand by providing a string of cards. An example of an invalid hand is also shown.

```python
>>> from pokerkit import *
>>> h0 = ShortDeckHoldemHand('6s7s8s9sTs')
>>> h1 = ShortDeckHoldemHand('7c8c9cTcJc')
>>> h2 = ShortDeckHoldemHand('2c2d2h2s3h')
Traceback (most recent call last):
    ...
ValueError: The cards '2c2d2h2s3h' form an invalid ShortDeckHoldemHand hand.
>>> h0
6s7s8s9sTs
>>> h1
7c8c9cTcJc
```

--------------------------------

### Simulate a Sample No-Limit Texas Hold’em Hand

Source: https://pokerkit.readthedocs.io/en/stable/index.html

Simulates a sample No-Limit Texas Hold'em hand, similar to a televised high-stakes pot. This example sets up the initial game state with specific antes, blinds, and starting stacks for a 3-player game.

```python
from math import inf

from pokerkit import Automation, NoLimitTexasHoldem

state = NoLimitTexasHoldem.create_state(
    # Automations
    (
        Automation.ANTE_POSTING,
        Automation.BET_COLLECTION,
        Automation.BLIND_OR_STRADDLE_POSTING,
        Automation.HOLE_CARDS_SHOWING_OR_MUCKING,
        Automation.HAND_KILLING,
        Automation.CHIPS_PUSHING,
        Automation.CHIPS_PULLING,
    ),
    True,  # Uniform antes?
    500,  # Antes
    (1000, 2000),  # Blinds or straddles
    2000,  # Min-bet
    (1125600, inf, 553500),  # Starting stacks
    3,  # Number of players
)

```

--------------------------------

### Construct game state for writing hands

Source: https://pokerkit.readthedocs.io/en/stable/_sources/notation.rst.txt

This snippet shows the initial setup for constructing a game state, specifically for PotLimitOmahaHoldem, including enabling ANTE_POSTING automation. This is a precursor to writing hands.

```python
from pokerkit import *

# Game state construction
game = PotLimitOmahaHoldem(
    (
        Automation.ANTE_POSTING,

```

--------------------------------

### Complete Bet or Raise To State Example

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates checking the ability to complete a bet or raise to a specific amount, including edge cases and state changes after actions.

```python
>>> from pokerkit import (
...     NoLimitTexasHoldem,
...     FixedLimitDeuceToSevenLowballTripleDraw,
... )
>>> state = NoLimitTexasHoldem.create_state(
...     (
...         Automation.ANTE_POSTING,
...         Automation.BET_COLLECTION,
...         Automation.BLIND_OR_STRADDLE_POSTING,
...         Automation.CARD_BURNING,
...         Automation.HOLE_DEALING,
...         Automation.BOARD_DEALING,
...         Automation.HOLE_CARDS_SHOWING_OR_MUCKING,
...         Automation.HAND_KILLING,
...         Automation.CHIPS_PUSHING,
...         Automation.CHIPS_PULLING,
...     ),
...     True,
...     0,
...     (1, 2),
...     2,
...     (100, 100, 200),
...     3,
... )
>>> state.can_complete_bet_or_raise_to()
True
>>> state.can_complete_bet_or_raise_to(4)
True
>>> state.can_complete_bet_or_raise_to(200)
True
>>> state.can_complete_bet_or_raise_to(3)
False
>>> state.can_complete_bet_or_raise_to(201)
False
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=2, amount=2)
>>> state.complete_bet_or_raise_to(100)  
CompletionBettingOrRaisingTo(commentary=None, player_index=0, amount...
>>> state.fold()
Folding(commentary=None, player_index=1)
>>> state.can_complete_bet_or_raise_to(200)
False
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=2, amount=98)
>>> state.status
False
>>> state.can_complete_bet_or_raise_to()
False
```

```python
>>> state = FixedLimitDeuceToSevenLowballTripleDraw.create_state(
...     (
...         Automation.ANTE_POSTING,
...         Automation.BET_COLLECTION,
...         Automation.BLIND_OR_STRADDLE_POSTING,
...         Automation.CARD_BURNING,
...         Automation.HOLE_DEALING,
...         Automation.BOARD_DEALING,
...         Automation.HOLE_CARDS_SHOWING_OR_MUCKING,
...         Automation.HAND_KILLING,
...         Automation.CHIPS_PUSHING,
...         Automation.CHIPS_PULLING,
...     ),
...     True,
...     0,
...     (1, 2),
...     2,
...
```

--------------------------------

### Check or Call State Example

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates how to check if a player can check or call and the subsequent state changes after folding.

```python
>>> from pokerkit import NoLimitTexasHoldem
>>> state = NoLimitTexasHoldem.create_state(
...     (
...         Automation.ANTE_POSTING,
...         Automation.BET_COLLECTION,
...         Automation.BLIND_OR_STRADDLE_POSTING,
...         Automation.CARD_BURNING,
...         Automation.HOLE_DEALING,
...         Automation.BOARD_DEALING,
...         Automation.HOLE_CARDS_SHOWING_OR_MUCKING,
...         Automation.HAND_KILLING,
...         Automation.CHIPS_PUSHING,
...         Automation.CHIPS_PULLING,
...     ),
...     True,
...     0,
...     (1, 2),
...     2,
...     (100, 100, 200),
...     3,
... )
>>> state.can_check_or_call()
True
>>> state.fold()
Folding(commentary=None, player_index=2)
>>> state.can_check_or_call()
True
>>> state.fold()
Folding(commentary=None, player_index=0)
>>> state.status
False
>>> state.can_check_or_call()
False
```

--------------------------------

### IPokerNetworkParser Placeholder Starting Stack

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Defines a placeholder value for starting stacks in the IPokerNetworkParser.

```python
class IPokerNetworkParser(REParser):
    ...
    PLACEHOLDER_STARTING_STACK_ = 10000000
    ...
```

--------------------------------

### Kuhn Poker Hand Creation and Comparison

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates the creation of KuhnPokerHand objects and their comparison. Includes an example of an invalid hand creation that raises a ValueError.

```python
>>> h0 = KuhnPokerHand('Js')
>>> h1 = KuhnPokerHand('Qs')
>>> h2 = KuhnPokerHand('Ks')
>>> h0 < h1 < h2
True
```

```python
>>> h = KuhnPokerHand('As')
Traceback (most recent call last):
    ... 
ValueError: The cards 'As' form an invalid KuhnPokerHand hand.
```

--------------------------------

### Opening Enum Examples

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates accessing different opening types from the Opening enum. These define how the opener of a betting round is chosen.

```python
>>> Opening.POSITION
<Opening.POSITION: 'Position'>
>>> Opening.LOW_HAND
<Opening.LOW_HAND: 'Low hand'>
```

--------------------------------

### Regular Low Hand Creation and Comparison

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates the creation and comparison of RegularLowHand objects, noting that flushes are ignored. Includes an example of an invalid hand creation.

```python
>>> h0 = RegularLowHand('KhKsKcKdAc')
>>> h1 = RegularLowHand('2s2c3s3cAh')
>>> h2 = RegularLowHand('6c4d3h2sAc')
>>> h3 = RegularLowHand('Ac2c3c4c5c')
>>> h0 < h1 < h2 < h3
True
```

```python
>>> h = RegularLowHand('4c5dThJsAcKh2h')
Traceback (most recent call last):
    ... 
ValueError: The cards '4c5dThJsAcKh2h' form an invalid RegularLowHand hand.
>>> h = RegularLowHand(())
```

--------------------------------

### Collect Bets State Example

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Illustrates checking the ability to collect bets and how it changes after posting an ante.

```python
>>> from pokerkit import NoLimitTexasHoldem
>>> state = NoLimitTexasHoldem.create_state(
...     (),
...     False,
...     (0, 2),
...     (1, 2),
...     2,
...     200,
...     2,
... )
>>> state.can_collect_bets()
False
>>> state.post_ante()
AntePosting(commentary=None, player_index=0, amount=2)
>>> state.can_collect_bets()
True
```

--------------------------------

### Initialize FixedLimitBadugi State

Source: https://pokerkit.readthedocs.io/en/stable/_sources/examples.rst.txt

Sets up a new game state for Fixed Limit Badugi with infinite starting stacks and specific automation rules. Requires importing `inf` from `math` and `*` from `pokerkit`.

```pycon
>>> from math import inf
>>> from pokerkit import *
>>> state = FixedLimitBadugi.create_state(
...     (
...         Automation.ANTE_POSTING,
...         Automation.BET_COLLECTION,
...         Automation.BLIND_OR_STRADDLE_POSTING,
...         Automation.HAND_KILLING,
...         Automation.CHIPS_PUSHING,
...         Automation.CHIPS_PULLING,
...     ),
...     True,
...     0,
...     (1, 2),
...     2,
...     4,
...     inf,
...     4,
... )
```

--------------------------------

### Get Max Up Card Count for FixedLimitRazz

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Returns the maximum number of up cards a single player can have. This example shows it is 4 for FixedLimitRazz.

```python
>>> game = FixedLimitRazz((), True, 1, 1, 2, 4)
>>> game.max_up_card_count
4
```

--------------------------------

### Create and Compare RegularLowHand

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates creating two RegularLowHand instances from game settings and comparing them for equality. Both from_game and direct initialization are shown.

```python
>>> h0 = RegularLowHand.from_game('AcAd', 'AhAsKcQd')
>>> h1 = RegularLowHand('AdAhAsKcQd')
>>> h0 == h1
True
```

--------------------------------

### Player Actions: Checking, Calling, and Betting

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Illustrates common player actions such as checking, calling, and completing bets or raises. The examples show the resulting game state after each action.

```python
>>> state.check_or_call()  # Bob
CheckingOrCalling(commentary=None, player_index=0, amount=0)
>>> state.complete_bet_or_raise_to()  # Carol
CompletionBettingOrRaisingTo(commentary=None, player_index=1, amount=2)
>>> state.check_or_call()  # Alice
CheckingOrCalling(commentary=None, player_index=3, amount=2)
>>> state.check_or_call()  # Bob
CheckingOrCalling(commentary=None, player_index=0, amount=2)
```

--------------------------------

### Get Max Up Card Count for NoLimitTexasHoldem

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Returns the maximum number of up cards a single player can have. This example shows it is 0 for NoLimitTexasHoldem.

```python
>>> game = NoLimitTexasHoldem((), True, 0, (1, 2), 2)
>>> game.max_up_card_count
0
```

--------------------------------

### Get Max Down Card Count for FixedLimitRazz

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Returns the maximum number of down cards a single player can have. This example shows it is 3 for FixedLimitRazz.

```python
>>> game = FixedLimitRazz((), True, 1, 1, 2, 4)
>>> game.max_down_card_count
3
```

--------------------------------

### Badugi Hand Lookup Example

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates creating a BadugiLookup instance and retrieving entries for single cards and hands. Shows expected ValueError for invalid hands and comparison of hand strengths.

```python
>>> lookup = BadugiLookup()
>>> e0 = lookup.get_entry('2s')
>>> e1 = lookup.get_entry('KhQc')
>>> e2 = lookup.get_entry('AcAdAhAs')
Traceback (most recent call last):
    ...
ValueError: The cards 'AcAdAhAs' form an invalid hand.
>>> e0 > e1
True
>>> e0.label
<Label.HIGH_CARD: 'High card'>
>>> e1.label
<Label.HIGH_CARD: 'High card'>
```

--------------------------------

### Get Max Down Card Count for NoLimitTexasHoldem

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Returns the maximum number of down cards a single player can have. This example shows it is 2 for NoLimitTexasHoldem.

```python
>>> game = NoLimitTexasHoldem((), True, 0, (1, 2), 2)
>>> game.max_down_card_count
2
```

--------------------------------

### Get Max Hole Card Count for FixedLimitRazz

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Returns the maximum number of hole cards a single player can have. This example shows it is 7 for FixedLimitRazz.

```python
>>> game = FixedLimitRazz((), True, 1, 1, 2, 4)
>>> game.max_hole_card_count
7
```

--------------------------------

### Get Max Hole Card Count for NoLimitTexasHoldem

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Returns the maximum number of hole cards a single player can have. This example shows it is 2 for NoLimitTexasHoldem.

```python
>>> game = NoLimitTexasHoldem((), True, 0, (1, 2), 2)
>>> game.max_hole_card_count
2
```

--------------------------------

### Get Max Board Card Count for FixedLimitRazz

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Returns the maximum number of board cards that can be dealt in a game. This example shows it is 0 for FixedLimitRazz.

```python
>>> game = FixedLimitRazz((), True, 1, 1, 2, 4)
>>> game.max_board_card_count
0
```

--------------------------------

### Create and Compare RhodeIslandHoldemHand

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Illustrates creating a RhodeIslandHoldemHand using from_game and direct initialization, and then comparing them for equality.

```python
>>> h0 = RhodeIslandHoldemHand.from_game('Ks', 'QdAh')
>>> h1 = RhodeIslandHoldemHand('KsQdAh')
>>> h0 == h1
True
```

--------------------------------

### Get Max Board Card Count for NoLimitTexasHoldem

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Returns the maximum number of board cards that can be dealt in a game. This example shows it is 5 for NoLimitTexasHoldem.

```python
>>> game = NoLimitTexasHoldem((), True, 0, (1, 2), 2)
>>> game.max_board_card_count
5
```

--------------------------------

### Create Game State Factory with FixedLimitDeuceToSevenLowballTripleDraw

Source: https://pokerkit.readthedocs.io/en/stable/simulation.html

Creates a game instance that acts as a state factory for FixedLimitDeuceToSevenLowballTripleDraw. This allows creating states by specifying only starting stacks and number of players, with other parameters pre-configured.

```python
from pokerkit import (
     Automation,
     FixedLimitDeuceToSevenLowballTripleDraw,
     NoLimitTexasHoldem,
)

game = FixedLimitDeuceToSevenLowballTripleDraw(
    # automations
    (
        Automation.ANTE_POSTING,
        Automation.BET_COLLECTION,
        Automation.BLIND_OR_STRADDLE_POSTING,
        Automation.CARD_BURNING,
        Automation.HOLE_CARDS_SHOWING_OR_MUCKING,
        Automation.HAND_KILLING,
        Automation.CHIPS_PUSHING,
        Automation.CHIPS_PULLING,
    ),
    True,  # False for big blind ante, True otherwise
    0,  # ante
    (75000, 150000),  # blinds or straddles
    150000,  # small bet
    300000,  # big bet
)
state = game(
    (1180000, 4340000, 5910000, 10765000),  # starting stacks
    4,  # number of players
)

game = NoLimitTexasHoldem(
    # automations
    (
        Automation.ANTE_POSTING,
        Automation.BET_COLLECTION,
        Automation.BLIND_OR_STRADDLE_POSTING,
        Automation.CARD_BURNING,
        Automation.HOLE_CARDS_SHOWING_OR_MUCKING,
        Automation.HAND_KILLING,
        Automation.CHIPS_PUSHING,
        Automation.CHIPS_PULLING,
    ),
    True,  # False for big blind ante, True otherwise
    500,  # ante
    (1000, 2000),  # blinds or straddles
    2000,  # min bet
)
state = game(
    (1125600, 2000000, 553500),  # starting stacks
    3,  # number of players
)

```

--------------------------------

### Create a Game State with Hand Killing and Chip Actions

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Initializes a game state with specific automations including hand killing and chip management. This setup is used for scenarios where these actions are relevant.

```python
from pokerkit import NoLimitTexasHoldem
state = NoLimitTexasHoldem.create_state(
    (
        Automation.ANTE_POSTING,
        Automation.BET_COLLECTION,
        Automation.BLIND_OR_STRADDLE_POSTING,
        Automation.HAND_KILLING,
        Automation.CHIPS_PUSHING,
        Automation.CHIPS_PULLING,
    ),
    True,
    0,
    (1, 2),
    2,
    (50, 100),
    2,
)
```

--------------------------------

### NoLimitTexasHoldem Class Initialization

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates the initialization of the NoLimitTexasHoldem game class. It requires various parameters related to game rules, antes, blinds, and player counts.

```python
_class _pokerkit.games.NoLimitTexasHoldem(_automations: tuple[~pokerkit.state.Automation, ...], ante_trimming_status: bool, raw_antes: ~collections.abc.Iterable[int] | ~collections.abc.Mapping[int, int] | int, raw_blinds_or_straddles: ~collections.abc.Iterable[int] | ~collections.abc.Mapping[int, int] | int, min_bet: int, *, mode: ~pokerkit.state.Mode = Mode.TOURNAMENT, starting_board_count: int = 1, divmod: ~collections.abc.Callable[[int, int], tuple[int, int]] = <function divmod>, rake: ~collections.abc.Callable[[int, ~pokerkit.state.State], tuple[int, int]] = <function rake>_)
    
Bases: `NoLimitPokerMixin`, `TexasHoldemMixin`, `UnfixedLimitHoldem`
    The class for no-limit Texas hold’em games.
```

--------------------------------

### Create and Compare KuhnPokerHand

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Shows how to create a KuhnPokerHand using both the from_game class method and direct initialization, followed by an equality check.

```python
>>> h0 = KuhnPokerHand.from_game('Ks')
>>> h1 = KuhnPokerHand('Ks')
>>> h0 == h1
True
```

--------------------------------

### Defining a Custom Kuhn Poker State

Source: https://pokerkit.readthedocs.io/en/stable/simulation.html

Provides a detailed example of defining a custom game variant, specifically Kuhn Poker, by specifying all necessary parameters for the state, including automations, deck, hand types, streets, betting structure, antes, blinds, starting stacks, and number of players.

```python
from pokerkit import (
     Automation,
     BettingStructure,
     Deck,
     KuhnPokerHand,
     Opening,
     State,
     Street,
)

state = State(
    # automations
    (
        Automation.ANTE_POSTING,
        Automation.BET_COLLECTION,
        Automation.BLIND_OR_STRADDLE_POSTING,
        Automation.CARD_BURNING,
        Automation.HOLE_DEALING,
        Automation.BOARD_DEALING,
        Automation.HOLE_CARDS_SHOWING_OR_MUCKING,
        Automation.HAND_KILLING,
        Automation.CHIPS_PUSHING,
        Automation.CHIPS_PULLING,
    ),
    Deck.KUHN_POKER,  # deck
    (KuhnPokerHand,),  # hand types (high/low-split will have two types)
    # streets
    (
        Street(
            False,  # card burning
            (False,),  # hole card dealing statuses (False for face-down)
            0,  # board dealing count
            False,  # standing pat or discarding
            Opening.POSITION,  # who opens the betting?
            1,  # min bet
            1,  # maximum number of completions/bettings/raisings
        ),
    ),
    BettingStructure.FIXED_LIMIT,  # betting structure
    True,  # ``False`` for big blind ante, otherwise ``True``
    (1,) * 2,  # ante
    (0,) * 2,  # blind or straddles
    0,  # bring-in
    (2,) * 2,  # starting stacks
    2,  # number of players
)

```

--------------------------------

### Performing Actions and Inspecting Pots

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Shows game actions like completing a bet/raise and checking/calling, followed by inspecting the resulting pot objects. Demonstrates how pot information is updated after actions.

```python
>>> state.complete_bet_or_raise_to(200)  
CompletionBettingOrRaisingTo(commentary=None, player_index=2, amount...
>>> state.complete_bet_or_raise_to(1000)  
Traceback (most recent call last):
    ...
ValueError: There is no reason to complete, bet, or raise since ever...
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=3, amount=200)
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=4, amount=200)
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=5, amount=100)
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=0, amount=49)
>>> tuple(state.pots)
()
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=1, amount=98)
>>> next(state.pots)  
Pot(raked_amount=0, unraked_amount=300, player_indices=(0, 1, 2, 3, ...
>>> pots = tuple(state.pots)
>>> len(pots)
3
>>> pots[0]  
```

--------------------------------

### Run Unit and Doctests

Source: https://pokerkit.readthedocs.io/en/stable/contributing.html

Execute unit tests and doctests to verify the correctness of your changes.

```bash
python -m unittest
python -m doctest pokerkit/*.py
```

--------------------------------

### Compare GreekHoldemHand Instances

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates the comparison of multiple GreekHoldemHand instances to illustrate their ordering. This shows how different combinations are ranked.

```python
>>> h0 = GreekHoldemHand('7c5d4h3s2c')
>>> h1 = GreekHoldemHand('7c6d4h3s2c')
>>> h2 = GreekHoldemHand('8c7d6h4s2c')
>>> h3 = GreekHoldemHand('AcAsAd2s4s')
>>> h4 = GreekHoldemHand('TsJsQsKsAs')
>>> h0 < h1 < h2 < h3 < h4
True
```

--------------------------------

### Calculate Player Equities with ProcessPoolExecutor

Source: https://pokerkit.readthedocs.io/en/stable/_sources/examples.rst.txt

Demonstrates calculating player equities using Monte-Carlo simulation with concurrent processing. Requires importing ProcessPoolExecutor and pokerkit functions.

```pycon
>>> from concurrent.futures import ProcessPoolExecutor
>>> from pokerkit import *
>>> with ProcessPoolExecutor() as executor:
...     calculate_equities(
...         (
...             parse_range('AK'),
...             parse_range('22'),
...         ),
...         (),
...         2,
...         5,
...         Deck.STANDARD,
...         (StandardHighHand,), 
...         sample_count=10000,
...         executor=executor,
...     )
... 
[0.4807, 0.5193]
```

--------------------------------

### Create a Fixed-Limit Badugi Game State

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates how to initialize a FixedLimitBadugi game state with various automations and betting parameters. This is useful for setting up a game according to specific rules.

```python
from math import inf
from pokerkit.state import Automation
from pokerkit.games import FixedLimitBadugi

state = FixedLimitBadugi.create_state(
    (
        Automation.ANTE_POSTING,
        Automation.BET_COLLECTION,
        Automation.BLIND_OR_STRADDLE_POSTING,
        Automation.HAND_KILLING,
        Automation.CHIPS_PUSHING,
        Automation.CHIPS_PULLING,
    ),
    True,
    0,
    (1, 2),
    2,
    4,
    inf,
    4,
)
```

--------------------------------

### Initialize State for Hand Killing Check

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Sets up a minimal game state to test the `can_kill_hand` functionality. This is useful for understanding when hand killing is permitted based on game automations.

```python
>>> from pokerkit import NoLimitTexasHoldem
>>> state = NoLimitTexasHoldem.create_state(
...     (
...         Automation.ANTE_POSTING,
...         Automation.BET_COLLECTION,
...         Automation.BLIND_OR_STRADDLE_POSTING,
...         Automation.HOLE_CARDS_SHOWING_OR_MUCKING,
...     ),
...     False,
...     0,
...     (1, 2),
...     2,
...     200,
...     3,
... )
```

--------------------------------

### PartyPoker Starting Stacks Pattern

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Regular expression to parse the starting stacks of players in PartyPoker hand histories. It extracts the player's name and their initial chip count.

```python
STARTING_STACKS _: ClassVar[Pattern[str]]__ = re.compile('Seat \\[0-9]+): (?P<player>.+) \\( \\[^\\]?(?P<starting_stack>[0-9.,]+) \\[^\\]+ \\)')
```

--------------------------------

### Starting Stacks and Bet Pattern

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Regular expression to capture player names, their starting chip stacks, and initial bets. Essential for understanding the game's initial state.

```python
STARTING_STACKS _ = re.compile('<player\b.*\bname="(?P<player>.+?)".*\bchips="\D?(?P<starting_stack>[0-9.,]+)".*\bbet="\D?(?P<bet>[0-9.,]+)".*/>')
```

--------------------------------

### Create Game State and Fold

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Initializes a new poker game state with specified automations and then demonstrates the folding action. Use this to set up a game and simulate a player folding.

```python
>>> from pokerkit import NoLimitTexasHoldem
>>> state = NoLimitTexasHoldem.create_state(
...     (
...         Automation.ANTE_POSTING,
...         Automation.BET_COLLECTION,
...         Automation.BLIND_OR_STRADDLE_POSTING,
...         Automation.CARD_BURNING,
...         Automation.HOLE_DEALING,
...         Automation.BOARD_DEALING,
...         Automation.HOLE_CARDS_SHOWING_OR_MUCKING,
...         Automation.HAND_KILLING,
...         Automation.CHIPS_PUSHING,
...         Automation.CHIPS_PULLING,
...     ),
...     True,
...     0,
...     (1, 2),
...     2,
...     (100, 100, 200),
...     3,
... )
>>> state.can_fold()
True
>>> state.fold()
Folding(commentary=None, player_index=2)
>>> state.can_fold()
True
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=0, amount=1)
>>> state.can_fold()
False
>>> state.complete_bet_or_raise_to(4)
CompletionBettingOrRaisingTo(commentary=None, player_index=1, amount=4)
>>> state.fold()
Folding(commentary=None, player_index=0)
>>> state.status
False
>>> state.can_fold()
False
```

--------------------------------

### Poker.starting_board_count

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

The number of board cards at the start of the hand.

```APIDOC
## Poker.starting_board_count

### Description
Specifies the number of community cards (board cards) dealt at the very beginning of the hand, if any.

### Method
Not specified (likely a property or attribute).

### Response
- **int** - The number of starting board cards.
```

--------------------------------

### starting_board_count Attribute

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

The starting_board_count attribute specifies the number of board cards dealt at the start of the game.

```APIDOC
## starting_board_count

### Description
The starting board count.

### Type
int
```

--------------------------------

### Create Greek Hold'em Hand from Game Settings

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates creating a GreekHoldemHand by combining hole and board cards using the `from_game` method. This is useful for simulating Greek Hold'em games.

```python
>>> h0 = GreekHoldemHand.from_game('Ac2d', 'QdJdTh2sKs')
>>> h1 = GreekHoldemHand('2s2dAcKsQd')
>>> h0 == h1
True
>>> h0 = GreekHoldemHand.from_game('AsKs', 'QdJdTh2s2d')
>>> h1 = GreekHoldemHand('AsKsQdJdTh')
>>> h0 == h1
True
>>> h0 = GreekHoldemHand.from_game('Ac9c', 'AhKhQhJhTh')
>>> h1 = GreekHoldemHand('AcAhKhQh9c')
>>> h0 == h1
True
```

--------------------------------

### Create and Compare Rhode Island Holdem Hands

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates creating Rhode Island Holdem hands from card strings and comparing their relative rankings. Ensure cards are provided in a valid format.

```python
>>> h0 = RhodeIslandHoldemHand('JsJc2h')
>>> h1 = RhodeIslandHoldemHand('2sQsAs')
>>> h2 = RhodeIslandHoldemHand('KcQdAh')
>>> h3 = StandardHighHand('3s3c3h')
>>> h0 < h1 < h2 < h3
True
```

--------------------------------

### Label Enum Example

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates accessing specific labels from the Label enum, such as ONE_PAIR and FULL_HOUSE.

```python
>>> Label.ONE_PAIR
<Label.ONE_PAIR: 'One pair'>
>>> Label.FULL_HOUSE
<Label.FULL_HOUSE: 'Full house'>
```

--------------------------------

### Create Standard Low Hand from Game Settings

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates creating a StandardLowHand from hole and board cards, relevant for lowball poker variants. It shows how different card combinations can result in the same low hand.

```python
>>> h0 = StandardLowHand.from_game('AcAdAhAsKc', '')
>>> h1 = StandardLowHand('AcAdAhAsKc')
>>> h0 == h1
True
>>> h0 = StandardLowHand.from_game('Ac9c', 'AhKhQhJhTh')
>>> h1 = StandardLowHand('AcQhJhTh9c')
>>> h0 == h1
True
```

--------------------------------

### Get Final Stacks

Source: https://pokerkit.readthedocs.io/en/stable/_sources/examples.rst.txt

Retrieves the final chip counts for all players at the end of a hand or round.

```pycon
>>> state.stacks
[572100, inf, 1109500]
```

```pycon
>>> state.stacks
[489000, 226000, 684000, 400000, 0, 198000]
```

--------------------------------

### Create Short Deck Hold'em Hand from Game Settings

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Illustrates creating a ShortDeckHoldemHand by combining hole and board cards, specifically for short deck poker. It shows how the best five-card hand is formed.

```python
>>> h0 = ShortDeckHoldemHand.from_game('AcKs', 'AhAsKcJsTs')
>>> h1 = ShortDeckHoldemHand('AcAhAsKcKs')
>>> h0 == h1
True
>>> h0 = ShortDeckHoldemHand.from_game('AcAd', '6s7cKcKd')
>>> h1 = ShortDeckHoldemHand('AcAdKcKd7c')
>>> h0 == h1
True
```

--------------------------------

### Get Sign of an Integer

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Returns the sign of an integer: -1 for negative, 1 for positive, and 0 for zero.

```python
>>> sign(-5)
-1
>>> sign(10)
1
>>> sign(0)
0
```

--------------------------------

### Completing Bet or Raise and Checking/Calling

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Illustrates game flow by completing a bet/raise and then performing multiple check/call actions. Shows how pot amounts are affected and potential ValueErrors.

```python
>>> state.complete_bet_or_raise_to(200)  
CompletionBettingOrRaisingTo(commentary=None, player_index=2, amount...
>>> state.complete_bet_or_raise_to(1000)  
Traceback (most recent call last):
    ...
ValueError: There is no reason to complete, bet, or raise since ever...
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=3, amount=200)
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=4, amount=200)
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=5, amount=100)
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=0, amount=49)
>>> tuple(state.pot_amounts)
()
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=1, amount=98)
>>> next(state.pot_amounts)
300
>>> pot_amounts = tuple(state.pot_amounts)
>>> len(pot_amounts)
3
>>> pot_amounts[0]
300
>>> pot_amounts[1]
250
>>> pot_amounts[2]
300
```

--------------------------------

### Get Final Stacks in PokerKit

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Retrieves the final stack sizes for all players in the current game state.

```python
>>> state.stacks
[204, 196]
```

--------------------------------

### Compare StandardHighHands

Source: https://pokerkit.readthedocs.io/en/stable/evaluation.html

Illustrates comparing StandardHighHand strengths using standard comparison operators. Demonstrates a sequence of hands from weaker to stronger.

```python
>>> from pokerkit import *
>>> h0 = StandardHighHand('7c5d4h3s2c')
>>> h1 = StandardHighHand('7c6d4h3s2c')
>>> h2 = StandardHighHand('8c7d6h4s2c')
>>> h3 = StandardHighHand('AcAsAd2s4s')
>>> h4 = StandardHighHand('TsJsQsKsAs')
>>> h0 < h1 < h2 < h3 < h4
True
```

--------------------------------

### RegularLowHand Constructor

Source: https://pokerkit.readthedocs.io/en/stable/reference.html

Demonstrates creating a RegularLowHand from game settings (hole and board cards) or directly from a string of cards. It also shows that hands created in different ways can be equal.

```APIDOC
## RegularLowHand.from_game()

### Description
Creates a RegularLowHand from a game setting, using hole cards and optional board cards.

### Method
`RegularLowHand.from_game(hole_cards, board_cards)`

### Parameters
* **hole_cards** – The hole cards.
* **board_cards** – The optional board cards.

### Returns
The strongest hand from possible card combinations.

## RegularLowHand()

### Description
Creates a RegularLowHand directly from a string of cards.

### Parameters
* **cards** – A string representing the cards in the hand.

### Returns
A RegularLowHand object.

### Example
```
>>> h0 = RegularLowHand.from_game('AcAd', 'AhAsKcQd')
>>> h1 = RegularLowHand('AdAhAsKcQd')
>>> h0 == h1
True
```
```
Tokens:
Raw