PokerKit

https://pokerkit.readthedocs.io/en/latest/
Admin
PokerKit is an open-source Python library for simulating poker games, evaluating hands, and...
Tokens:228,196
Snippets:1,446
Trust Score:9.6
Update:1 week ago
Show doc for...
Tokens:
Raw
### Set up virtual environment and install requirements

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

Create and activate a Python virtual environment, then install project dependencies.

```bash
python -m venv venv
```

```bash
source venv/bin/activate
```

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

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

### Create game templates for FixedLimitDeuceToSevenLowballTripleDraw and NoLimitTexasHoldem

Source: https://pokerkit.readthedocs.io/en/latest/_sources/simulation.rst.txt

Creates game instances that act as state factories, allowing states to be initialized with only starting stacks and number of players. Equivalent to the previous create_state examples.

```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
)
```

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

### Card.get_suits examples

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

Shows how to use Card.get_suits to get an iterator of suits from a card string, and how to consume it with list().

```python
>>> Card.get_suits('2sKh')  
<generator object Card.get_suits at 0x...>
>>> list(Card.get_suits('2sKh'))
[<Suit.SPADE: 's'>, <Suit.HEART: 'h'>]
```

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

### Setup phase state operations

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

Shows the state transitions during setup: posting ante, collecting bets, posting blinds/straddles, and checking the street. The output of each operation is displayed.

```python
>>> state.post_ante(0)
AntePosting(commentary=None, player_index=0, amount=2)
>>> state.collect_bets()
BetCollection(commentary=None, bets=(2, 0))
>>> state.post_blind_or_straddle(0)
BlindOrStraddlePosting(commentary=None, player_index=0, amount=2)
>>> state.street is None
True
>>> state.post_blind_or_straddle(1)
BlindOrStraddlePosting(commentary=None, player_index=1, amount=1)
>>> state.street is state.streets[0]
True
>>> state.street  
Street(card_burning_status=False, hole_dealing_statuses=(False, Fals...
```

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

### Create NoLimitTexasHoldem state

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

Initializes a NoLimitTexasHoldem game state with specified automations, blinds, and player count. This is the setup for the subsequent hand example.

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

```

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

### Install PokerKit with pip

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

Install PokerKit using pip. Requires Python 3.11 or above.

```bash
pip install pokerkit

```

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

### BadugiLookup usage example

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

Shows how to use BadugiLookup to get entries for hands and compare them. Also demonstrates that invalid hands raise ValueError.

```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'>
```

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

### ShortDeckHoldemHand.from_game examples

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

Shows how to create a ShortDeckHoldemHand from hole and board cards using the from_game classmethod. The examples demonstrate that the method selects the best five-card hand from the available cards.

```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
```

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

### StandardLowHand comparison example

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

Shows how StandardLowHand instances are compared. The example creates four hands and verifies that h0 < h1 < h2 < h3 < h4.

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

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

### StandardHighHand.from_game examples

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

Shows how to create a StandardHighHand from hole and board cards using the from_game classmethod. The examples demonstrate that the method selects the best five-card high hand.

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

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

### RegularLookup usage example

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

Shows how to create a RegularLookup and use get_entry to compare hands and retrieve labels. The example demonstrates that an invalid hand raises a ValueError.

```python
>>> lookup = RegularLookup()
>>> e0 = lookup.get_entry('Ah6h7s8c9s')
>>> e1 = lookup.get_entry('AhAc6s6hTd')
>>> e2 = lookup.get_entry('3s4sQhTc')
Traceback (most recent call last):
    ...
ValueError: The cards '3s4sQhTc' form an invalid hand.
>>> e0 < e1
True
>>> e0.label
<Label.HIGH_CARD: 'High card'>
>>> e1.label
<Label.TWO_PAIR: 'Two pair'>
```

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

### GreekHoldemHand.from_game examples

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

Shows how to create a GreekHoldemHand from hole and board cards using the from_game classmethod. The examples demonstrate that the method selects the best five-card hand from the available cards.

```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
```

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

### LeducHoldemLookup usage example

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

Shows how to create a LeducHoldemLookup and use get_entry to compare hands and retrieve labels. The example demonstrates that an invalid hand raises a ValueError.

```python
>>> lookup = LeducHoldemLookup()
>>> e0 = lookup.get_entry('JsQh')
>>> e1 = lookup.get_entry('KsKh')
>>> e2 = lookup.get_entry('QhTs')
Traceback (most recent call last):
    ...
ValueError: The cards 'QhTs' form an invalid hand.
>>> e0 < e1
True
>>> e0.label
<Label.HIGH_CARD: 'High card'>
>>> e1.label
<Label.ONE_PAIR: 'One pair'>
```

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

### Create Fixed-Limit Badugi state

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

Initializes a Fixed-Limit Badugi game state with specified automations, antes, blinds, and starting stacks. The starting stacks are set to infinity as they are not mentioned in the source 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,
... )

```

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

### Setup: Post ante, collect bets, post blinds/straddles

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

Initializes the game state by posting an ante, collecting bets, and posting blinds/straddles. Shows the resulting total pot amount after each operation.

```python
>>> state.post_ante(0)
AntePosting(commentary=None, player_index=0, amount=2)
>>> state.total_pot_amount
2
>>> state.collect_bets()
BetCollection(commentary=None, bets=(2, 0))
>>> state.total_pot_amount
2
>>> state.post_blind_or_straddle(0)
BlindOrStraddlePosting(commentary=None, player_index=0, amount=2)
>>> state.total_pot_amount
4
>>> state.post_blind_or_straddle(1)
BlindOrStraddlePosting(commentary=None, player_index=1, amount=1)
>>> state.total_pot_amount
5
```

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

### Card.get_ranks examples

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

Shows how to use Card.get_ranks to get an iterator of ranks from a card string, and how to consume it with list().

```python
>>> Card.get_ranks('2sKh')  
<generator object Card.get_ranks at 0x...>
>>> list(Card.get_ranks('2sKh'))
[<Rank.DEUCE: '2'>, <Rank.KING: 'K'>]
```

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

### RegularLowHand ordering example

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

Shows how to create RegularLowHand instances and compare them. Flushes are ignored in low hands.

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

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

### KuhnPokerLookup usage example

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

Shows how to use KuhnPokerLookup to get entries for hands and compare them. Also demonstrates that invalid hands raise ValueError.

```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'>
```

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

### ShortDeckHoldemHand ordering example

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

Shows how to create ShortDeckHoldemHand instances and compare them. In short-deck hold'em, flushes beat full houses.

```python
>>> h0 = ShortDeckHoldemHand('6c7d8h9sJc')
>>> h1 = ShortDeckHoldemHand('7c7d7hTsQc')
>>> h2 = ShortDeckHoldemHand('As6c7h8h9h')
>>> h3 = ShortDeckHoldemHand('AsAhKcKhKd')
>>> h4 = ShortDeckHoldemHand('6s7s8sTsQs')
>>> h0 < h1 < h2 < h3 < h4
True
```

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

### StandardHighHand ordering example

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

Shows how to create StandardHighHand instances and compare them. The hand uses exactly 5 cards.

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

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

### can_kill_hand() example with NoLimitTexasHoldem

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

Demonstrates the can_kill_hand() method in a NoLimitTexasHoldem game. Shows that can_kill_hand() returns False during the turn, but True on the river for players 0 and 1, and False for player 2. The example includes the setup, pre-flop, flop, turn, and river phases.

```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,
... )
```

```python
>>> state.deal_hole('JcJd')  
HoleDealing(commentary=None, player_index=0, cards=(Jc, Jd), statuse...
>>> state.deal_hole('QcQd')  
HoleDealing(commentary=None, player_index=1, cards=(Qc, Qd), statuse...
>>> state.deal_hole('KcKd')  
HoleDealing(commentary=None, player_index=2, cards=(Kc, Kd), statuse...
>>> state.complete_bet_or_raise_to(200)  
CompletionBettingOrRaisingTo(commentary=None, player_index=2, amount...
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=0, amount=199)
>>> state.check_or_call()
CheckingOrCalling(commentary=None, player_index=1, amount=198)
```

```python
>>> state.burn_card('??')
CardBurning(commentary=None, card=??)
>>> state.deal_board('AcAdAh')
BoardDealing(commentary=None, cards=(Ac, Ad, Ah))
```

```python
>>> state.burn_card('??')
CardBurning(commentary=None, card=??)
>>> state.deal_board('2c')
BoardDealing(commentary=None, cards=(2c,))
>>> state.can_kill_hand()
False
```

```python
>>> state.burn_card('??')
CardBurning(commentary=None, card=??)
>>> state.deal_board('2d')
BoardDealing(commentary=None, cards=(2d,))
>>> state.can_kill_hand()
True
>>> state.can_kill_hand(0)
True
>>> state.can_kill_hand(1)
True
>>> state.can_kill_hand(2)
False
```

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

### Specify starting stacks in different formats

Source: https://pokerkit.readthedocs.io/en/latest/_sources/simulation.rst.txt

Shows four equivalent ways to specify starting stacks: tuple, list, dict, and a single numeric value. The single numeric value is interpreted as identical for all players, so the number of players must still be supplied.

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

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

### max_up_card_count for FixedLimitRazz

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

Shows how to get the maximum number of up cards for a FixedLimitRazz game. The example creates a game with FixedLimitRazz((), True, 1, 1, 2, 4) and prints the property, which returns 4.

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

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

### RhodeIslandHoldemHand ordering example

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

Shows how to create RhodeIslandHoldemHand instances and compare them. The hand uses exactly 3 cards.

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

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

### max_up_card_count for NoLimitTexasHoldem

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

Shows how to get the maximum number of up cards for a NoLimitTexasHoldem game. The example creates a game with NoLimitTexasHoldem((), True, 0, (1, 2), 2) and prints the property, which returns 0.

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

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

### State Initialization

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

Example of creating a State object for a custom poker variant, demonstrating the required parameters.

```APIDOC
## State Initialization

### Description
Creates a new poker game state with a custom variant definition.

### Method
Constructor

### Endpoint
`pokerkit.state.State`

### Parameters
#### Constructor Parameters
- **automations** (tuple of Automation) - Required - Automations to enable.
- **deck** (Deck) - Required - The deck used in the game.
- **hand_types** (tuple of HandType) - Required - The hand types used (e.g., high, low).
- **streets** (tuple of Street) - Required - Street definitions.
- **betting_structure** (BettingStructure) - Required - Betting limits (e.g., fixed-limit, no-limit).
- **ante_trimming_status** (bool) - Required - `True` for uniform antes, `False` for non-uniform.
- **antes** (tuple of int) - Required - Ante amounts.
- **blinds_or_straddles** (tuple of int) - Required - Blind or straddle amounts.
- **bring_in** (int) - Required - Bring-in amount.
- **starting_stacks** (tuple of int) - Required - Starting stacks for each player.
- **player_count** (int) - Required - Number of players.

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

state = 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,
    ),
    Deck.KUHN_POKER,
    (KuhnPokerHand,),
    (
        Street(
            False,
            (False,),
            0,
            False,
            Opening.POSITION,
            1,
            1,
        ),
    ),
    BettingStructure.FIXED_LIMIT,
    True,
    (1,) * 2,
    (0,) * 2,
    0,
    (2,) * 2,
    2,
)
```

### Response
#### Success Response
Returns a `State` object representing the initialized game state.

#### Response Example
```python
state = State(...)
```
```

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

### max_down_card_count for FixedLimitRazz

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

Shows how to get the maximum number of down cards for a FixedLimitRazz game. The example creates a game with FixedLimitRazz((), True, 1, 1, 2, 4) and prints the property, which returns 3.

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

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

### max_down_card_count for NoLimitTexasHoldem

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

Shows how to get the maximum number of down cards for a NoLimitTexasHoldem game. The example creates a game with NoLimitTexasHoldem((), True, 0, (1, 2), 2) and prints the property, which returns 2.

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

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

### Total pot amount example

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

Creates a NoLimitTexasHoldem state with no automations and checks that the total pot amount is initially 0.

```python
>>> from pokerkit import NoLimitTexasHoldem
>>> state = NoLimitTexasHoldem.create_state(
...     (),
...     False,
...     (0, 2),
...     (1, 2),
...     2,
...     200,
...     2,
... )
>>> state.total_pot_amount
0
```

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

### rank_orders for FixedLimitRazz

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

Shows how to get the rank orders for a FixedLimitRazz game. The example creates a game with FixedLimitRazz((), True, 1, 1, 2, 4) and prints the property, which returns a tuple of RankOrder objects.

```python
>>> game = FixedLimitRazz((), True, 1, 1, 2, 4)
>>> game.rank_orders  
(<RankOrder.REGULAR: (<Rank.ACE: 'A'>, <Rank.DEUCE: '2'>, <Rank.TREY...
```

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

### Check out main branch

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

Switch to the main branch locally.

```bash
git checkout main
```

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

### rank_orders for NoLimitTexasHoldem

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

Shows how to get the rank orders for a NoLimitTexasHoldem game. The example creates a game with NoLimitTexasHoldem((), True, 0, (1, 2), 2) and prints the property, which returns a tuple of RankOrder objects.

```python
>>> game = NoLimitTexasHoldem((), True, 0, (1, 2), 2)
>>> game.rank_orders  
(<RankOrder.STANDARD: (<Rank.DEUCE: '2'>, <Rank.TREY: '3'>, <Rank.FO...
```

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

### max_hole_card_count for FixedLimitRazz

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

Shows how to get the maximum number of hole cards for a FixedLimitRazz game. The example creates a game with FixedLimitRazz((), True, 1, 1, 2, 4) and prints the property, which returns 7.

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

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

### max_hole_card_count for NoLimitTexasHoldem

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

Shows how to get the maximum number of hole cards for a NoLimitTexasHoldem game. The example creates a game with NoLimitTexasHoldem((), True, 0, (1, 2), 2) and prints the property, which returns 2.

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

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

### Create a FixedLimitDeuceToSevenLowballTripleDraw state

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

Creates a game state for a fixed-limit deuce-to-seven lowball triple draw game with specified automations, antes, blinds, bets, and starting stacks. The example uses a tournament mode with 4 players.

```python
>>> state = FixedLimitDeuceToSevenLowballTripleDraw.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,
...     (75000, 150000),
...     150000,
...     300000,
...     (1180000, 4340000, 5910000, 10765000),
...     4,
... )
```

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

### Create and inspect a Card instance

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

Shows how to create a Card with Rank.ACE and Suit.SPADE, then display it, convert to string, and access rank and suit attributes.

```python
>>> card = Card(Rank.ACE, Suit.SPADE)
>>> card
As
>>> str(card)
'ACE OF SPADES (As)'
>>> card.rank
<Rank.ACE: 'A'>
>>> card.suit
<Suit.SPADE: 's'>
```

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

### Example: Using draw_statuses property

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

Shows how to create states for NoLimitTexasHoldem and NoLimitDeuceToSevenLowballSingleDraw and inspect their draw_statuses. The first state has no draw streets, the second has one draw street.

```python
>>> from pokerkit import (
...     NoLimitTexasHoldem,
...     NoLimitDeuceToSevenLowballSingleDraw,
... )
>>> state = NoLimitTexasHoldem.create_state(
...     (),
...     False,
...     (0, 2),
...     (1, 2),
...     2,
...     200,
...     2,
... )
>>> state.draw_statuses  
<generator object State.draw_statuses at 0x...>
>>> tuple(state.draw_statuses)
(False, False, False, False)
>>> state = NoLimitDeuceToSevenLowballSingleDraw.create_state(
...     (),
...     True,
...     1,
...     (1, 2),
...     2,
...     200,
...     3,
... )
>>> tuple(state.draw_statuses)
(False, True)
```

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

### No-Limit Texas Hold'em Multi-Runout All-In Setup

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

Creates a No-Limit Texas Hold'em state for a 6-player cash game with a 4-runout all-in situation. Uses math.inf for starting stacks of players not mentioned in the referenced hand.

```pycon
>>> from math import inf
>>> from pokerkit import Automation, Mode, 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,
...     ),
...     False,
...     {-1: 600},
...     (200, 400, 800),
...     400,
...     (inf, 116400, 86900, inf, 50000, inf),
...     6,
...     mode=Mode.CASH_GAME,
... )
```

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

### Create a fixed-limit Texas hold'em game state

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

Example hand in fixed-limit Texas hold'em. Calls FixedLimitTexasHoldem.create_state with automations, ante trimming status, raw antes, blinds, small bet, big bet, starting stacks, and player count.

```python
>>> state = FixedLimitTexasHoldem.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),
...     2,
...     4,
...     200,
...     2,
... )
```

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

### StandardLowHand.from_game examples

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

Shows how to create a StandardLowHand from hole and board cards using the from_game classmethod. The examples demonstrate that the method selects the best five-card low hand, using the ace-to-five lowball ranking.

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