# Poker Manager
A comprehensive Python library for managing poker games, including Texas Hold'em variants with support for multi-board play, pot management, and hand evaluation.
## Features
### Game Variants
- **Texas Hold'em**: Standard no-limit Texas Hold'em with small/big blinds
- **Bomb Pot**: Variant where all players are automatically all-in pre-flop
- **Multi-board Support**: Play with multiple boards simultaneously
### Core Components
#### Table Management
- Manage players and seating
- Handle player rotations and dealer button
- Support for table limits and configurations
#### Player System
- Track player status (active, folded, all-in, sitting out)
- Manage chip stacks and bankroll
- Track hole cards and best possible hands
- Calculate hand equities
#### Board Management
- Handle community cards (flop, turn, river)
- Support for multiple concurrent boards
- Board texture analysis
#### Pot Management
- Track main and side pots
- Handle all-in situations
- Support for multi-board pot splitting
- Track winners per board
#### Hand Evaluation
- Evaluate hand strengths
- Calculate winning hands
- Support for various poker hand rankings
## Installation
### From GitHub Packages (Private Repository)
```bash
# Using Personal Access Token
pip install pokermgr --index-url https://USERNAME:TOKEN@pypi.pkg.github.com/bhadresh-dahanuwala/simple/
```
See [INSTALL.md](INSTALL.md) for detailed installation instructions.
### For Development
```bash
git clone https://github.com/bhadresh-dahanuwala/pokermgr.git
cd pokermgr
pip install -e .
```
## Quick Start
This section provides a basic overview of how to set up and run a poker game using the Poker Manager library.
### 1. Setting up Players and Table
First, you need to create players and a table for them to play on.
```python
from collections import deque
from pokermgr.player import TablePlayer, PlayerAction, PlayerStatus
from pokermgr.table import Table
# Create individual players
player1 = TablePlayer(name="Alice", initial_stack=1000)
player2 = TablePlayer(name="Bob", initial_stack=1000)
player3 = TablePlayer(name="Charlie", initial_stack=1000)
# Add players to a deque (order matters for seating and turns)
players_at_table = deque([player1, player2, player3])
# Create a table
# The table code can be any unique string identifier.
# max_players defaults to 9 if not specified.
table = Table(code="PokerNight01", players=players_at_table, max_players=6)
print(f"Table '{table.code}' created with {len(table.players)} players.")
for p in table.players:
print(f"- {p.name} (Stack: {p.stack})")
```
### 2. Initializing a Game (Texas Hold'em Regular)
Now, let's set up a standard Texas Hold'em game with blinds.
```python
from pokermgr.game import GameTexasHoldemRegular, GameStreet
# Create a Texas Hold'em game
# 'key' is a unique identifier for the game instance.
# Small blind and big blind amounts are specified here.
game_th_regular = GameTexasHoldemRegular(
key=1, # Game ID
table=table,
small_blind=5,
big_blind=10,
initial_board_count=1 # Default is 1, can be more for multi-board games
)
print(f"Game {game_th_regular.key} (Texas Hold'em Regular) initialized.")
print(f"Small Blind: {game_th_regular.small_blind}, Big Blind: {game_th_regular.big_blind}")
print(f"Current game street: {game_th_regular.game_street.name}")
print(f"Number of boards: {game_th_regular.board_count}")
```
### 3. Dealing Cards and Progressing Streets
Here's how to deal cards through the different streets of a hand. In a real game, betting rounds would occur between these steps.
```python
from cardspy.cards import SUITS, RANKS, CARDS
from cardspy.card import card_key_to_repr, cards_to_str_pretty
# --- Pre-flop: Deal Hole Cards ---
# The _core_deal_hole_cards method is called internally by deal_hole_cards.
# For Texas Hold'em, each player gets 2 hole cards.
game_th_regular.deal_hole_cards()
print(f"\n--- {game_th_regular.game_street.name} --- (Hole cards dealt)")
for player in game_th_regular.table.players:
# Hole cards are stored as bitmasks in player.hole_cards.key
# We use card_key_to_repr for a human-readable string
hole_cards_str = cards_to_str_pretty(player.hole_cards.key)
print(f"{player.name} has hole cards: {hole_cards_str}")
# --- Flop: Deal 3 Community Cards ---
# Advance the game street and deal the flop
# game_th_regular.game_street = GameStreet.FLOP # This is handled internally by deal_flop
game_th_regular.deal_flop()
print(f"\n--- {game_th_regular.game_street.name} --- (3 community cards)")
# Board cards are stored as a bitmask in game.boards[0].cards
flop_cards_str = cards_to_str_pretty(game_th_regular.boards[0].cards)
print(f"Board 0: {flop_cards_str}")
# --- Turn: Deal 1 Community Card ---
# game_th_regular.game_street = GameStreet.TURN # Handled by deal_turn
game_th_regular.deal_turn()
print(f"\n--- {game_th_regular.game_street.name} --- (1 community card)")
turn_cards_str = cards_to_str_pretty(game_th_regular.boards[0].cards)
print(f"Board 0: {turn_cards_str}")
# --- River: Deal 1 Community Card ---
# game_th_regular.game_street = GameStreet.RIVER # Handled by deal_river
game_th_regular.deal_river()
print(f"\n--- {game_th_regular.game_street.name} --- (1 community card)")
river_cards_str = cards_to_str_pretty(game_th_regular.boards[0].cards)
print(f"Board 0: {river_cards_str}")
# At this point, all cards are dealt. The next step would be showdown and pot distribution.
# Note: The `showdown()` method is not yet fully implemented in the provided snippets.
# print("\n--- Showdown ---")
# winners = game_th_regular.showdown() # Placeholder for actual showdown logic
```
## Advanced Usage
### 1. Multi-Board Games
You can play games with multiple boards simultaneously. This is common in some poker variants where the pot is split among winners on different boards.
```python
from pokermgr.game import Game # Base Game class for multi-board
# Re-use the table and players from the previous example
# Create a game with 3 boards
game_multi_board = Game(
key=2,
table=table,
initial_board_count=3
)
print(f"\nGame {game_multi_board.key} (Multi-Board) initialized with {game_multi_board.board_count} boards.")
# Deal hole cards (specific to game type, e.g., TexasHoldem would deal 2)
# For a generic Game, you might need to implement _core_deal_hole_cards
# or use a game type that defines it, like GameTexasHoldem.
# Let's assume GameTexasHoldem for dealing hole cards:
class MyTexasHoldemMulti(GameTexasHoldemRegular):
pass # Inherits _core_deal_hole_cards
game_multi_board_th = MyTexasHoldemMulti(
key=3,
table=table,
small_blind=0, # Blinds might not apply or be handled differently
big_blind=0,
initial_board_count=3
)
game_multi_board_th.deal_hole_cards()
print(f"Hole cards dealt for multi-board game.")
for player in game_multi_board_th.table.players:
print(f"{player.name}: {cards_to_str_pretty(player.hole_cards.key)}")
# Deal community cards for each board
# game_multi_board_th.game_street = GameStreet.FLOP # Handled by deal_flop
game_multi_board_th.deal_flop()
# game_multi_board_th.game_street = GameStreet.TURN # Handled by deal_turn
game_multi_board_th.deal_turn()
# game_multi_board_th.game_street = GameStreet.RIVER # Handled by deal_river
game_multi_board_th.deal_river()
print("\nCommunity cards dealt for all boards:")
for i, board_instance in enumerate(game_multi_board_th.boards):
board_cards_str = cards_to_str_pretty(board_instance.cards)
print(f"Board {i}: {board_cards_str}")
# You can also add boards dynamically during a game
# game_multi_board_th.add_board()
# print(f"\nAdded a new board. Total boards: {game_multi_board_th.board_count}")
# The new board will copy the cards from the most recent existing board.
```
### 2. Bomb Pot Games (Texas Hold'em Variant)
In a Bomb Pot, all players are typically forced all-in pre-flop for a fixed amount.
```python
from pokermgr.game import GameTexasHoldemBomb
# Re-use the table and players
# Create a Bomb Pot game where each player contributes 100 to the pot pre-flop.
game_bomb_pot = GameTexasHoldemBomb(
key=4,
table=table,
blind=100, # This is the mandatory amount each player posts
initial_board_count=1
)
print(f"\nGame {game_bomb_pot.key} (Bomb Pot) initialized.")
print(f"Mandatory blind: {game_bomb_pot.blind}")
# In a Bomb Pot, the pot is immediately built from all players' blinds.
# The first pot (self.pots[0]) is initialized with this amount.
print(f"Initial pot size: {game_bomb_pot.pots[0].stack}")
# Dealing proceeds as normal, but typically without betting rounds pre-flop.
# Hole cards are dealt
game_bomb_pot.deal_hole_cards()
print("Hole cards dealt for Bomb Pot game.")
# Community cards are dealt
# game_bomb_pot.game_street = GameStreet.FLOP # Handled by deal_flop
game_bomb_pot.deal_flop()
# game_bomb_pot.game_street = GameStreet.TURN # Handled by deal_turn
game_bomb_pot.deal_turn()
# game_bomb_pot.game_street = GameStreet.RIVER # Handled by deal_river
game_bomb_pot.deal_river()
print("Community cards for Bomb Pot game:")
bomb_pot_board_str = cards_to_str_pretty(game_bomb_pot.boards[0].cards)
print(f"Board 0: {bomb_pot_board_str}")
```
### 3. Custom Hand Evaluation
The `Hand` class (from `pokermgr.hand`) can be used to evaluate poker hands represented by bitmasks. The `cardspy` library is used for card representations.
```python
from pokermgr.hand import Hand
from cardspy.deck import cards_to_mask
from cardspy.card import extract_cards
from pokermgr.funcs import get_cards_properties
# Example: Evaluate a specific hand (e.g., a full house)
# Use string codes for cards: 'As' = Ace of Spades, 'Kd' = King of Diamonds, etc.
# The order of cards does not matter for evaluation.
card_mask = cards_to_mask(['As', 'Ad', 'Ah', 'Kc', 'Kd'])
hand = Hand(card_mask)
# Display the hand in a human-readable way
print("Hand cards:", extract_cards(card_mask))
print("Hand type:", hand.type_name)
print("Hand weight:", hand.weight)
print("Hand properties (bitmask):", get_cards_properties(hand.cards))
# Example: Straight Flush (Royal Flush in hearts)
sf_mask = cards_to_mask(['Th', 'Jh', 'Qh', 'Kh', 'Ah'])
sf_hand = Hand(sf_mask)
print("\nStraight Flush cards:", extract_cards(sf_mask))
print("Hand type:", sf_hand.type_name)
print("Hand weight:", sf_hand.weight)
# You can also check for draws if relevant
# print("Draws:", hand.draws)
## Project Structure
```
pokermgr/
├── __init__.py
├── board.py # Board and board texture management
├── evaluate.py # Hand evaluation logic
├── funcs.py # Utility functions
├── game.py # Core game logic and variants
├── hand.py # Hand representation
├── hole_cards.py # Hole cards management
├── player.py # Player classes and logic
├── pot.py # Pot management
└── table.py # Table management
tests/ # Comprehensive test suite
```
## Testing
Run the test suite with pytest:
```bash
pytest tests/
```
## License
This project is licensed under the MIT License - see the LICENSE file for details.
## Contributing
Contributions are welcome! Please feel free to submit a Pull Request.
Raw data
{
"_id": null,
"home_page": null,
"name": "pokermgr",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.10",
"maintainer_email": null,
"keywords": "poker, texas-holdem, omaha, card-games, game-evaluation",
"author": "Bhadresh Dahanuwala",
"author_email": "bhadresh.dahanuwala@gmail.com",
"download_url": "https://files.pythonhosted.org/packages/60/b7/5bd6e3ba0238c244c6447cc64adf914a2ebc203c4b36627f9e8a7b1e6335/pokermgr-3.4.0.tar.gz",
"platform": null,
"description": "# Poker Manager\n\nA comprehensive Python library for managing poker games, including Texas Hold'em variants with support for multi-board play, pot management, and hand evaluation.\n\n## Features\n\n### Game Variants\n- **Texas Hold'em**: Standard no-limit Texas Hold'em with small/big blinds\n- **Bomb Pot**: Variant where all players are automatically all-in pre-flop\n- **Multi-board Support**: Play with multiple boards simultaneously\n\n### Core Components\n\n#### Table Management\n- Manage players and seating\n- Handle player rotations and dealer button\n- Support for table limits and configurations\n\n#### Player System\n- Track player status (active, folded, all-in, sitting out)\n- Manage chip stacks and bankroll\n- Track hole cards and best possible hands\n- Calculate hand equities\n\n#### Board Management\n- Handle community cards (flop, turn, river)\n- Support for multiple concurrent boards\n- Board texture analysis\n\n#### Pot Management\n- Track main and side pots\n- Handle all-in situations\n- Support for multi-board pot splitting\n- Track winners per board\n\n#### Hand Evaluation\n- Evaluate hand strengths\n- Calculate winning hands\n- Support for various poker hand rankings\n\n## Installation\n\n### From GitHub Packages (Private Repository)\n\n```bash\n# Using Personal Access Token\npip install pokermgr --index-url https://USERNAME:TOKEN@pypi.pkg.github.com/bhadresh-dahanuwala/simple/\n```\n\nSee [INSTALL.md](INSTALL.md) for detailed installation instructions.\n\n### For Development\n\n```bash\ngit clone https://github.com/bhadresh-dahanuwala/pokermgr.git\ncd pokermgr\npip install -e .\n```\n\n## Quick Start\n\nThis section provides a basic overview of how to set up and run a poker game using the Poker Manager library.\n\n### 1. Setting up Players and Table\n\nFirst, you need to create players and a table for them to play on.\n\n```python\nfrom collections import deque\nfrom pokermgr.player import TablePlayer, PlayerAction, PlayerStatus\nfrom pokermgr.table import Table\n\n# Create individual players\nplayer1 = TablePlayer(name=\"Alice\", initial_stack=1000)\nplayer2 = TablePlayer(name=\"Bob\", initial_stack=1000)\nplayer3 = TablePlayer(name=\"Charlie\", initial_stack=1000)\n\n# Add players to a deque (order matters for seating and turns)\nplayers_at_table = deque([player1, player2, player3])\n\n# Create a table\n# The table code can be any unique string identifier.\n# max_players defaults to 9 if not specified.\ntable = Table(code=\"PokerNight01\", players=players_at_table, max_players=6)\n\nprint(f\"Table '{table.code}' created with {len(table.players)} players.\")\nfor p in table.players:\n print(f\"- {p.name} (Stack: {p.stack})\")\n```\n\n### 2. Initializing a Game (Texas Hold'em Regular)\n\nNow, let's set up a standard Texas Hold'em game with blinds.\n\n```python\nfrom pokermgr.game import GameTexasHoldemRegular, GameStreet\n\n# Create a Texas Hold'em game\n# 'key' is a unique identifier for the game instance.\n# Small blind and big blind amounts are specified here.\ngame_th_regular = GameTexasHoldemRegular(\n key=1, # Game ID\n table=table,\n small_blind=5,\n big_blind=10,\n initial_board_count=1 # Default is 1, can be more for multi-board games\n)\n\nprint(f\"Game {game_th_regular.key} (Texas Hold'em Regular) initialized.\")\nprint(f\"Small Blind: {game_th_regular.small_blind}, Big Blind: {game_th_regular.big_blind}\")\nprint(f\"Current game street: {game_th_regular.game_street.name}\")\nprint(f\"Number of boards: {game_th_regular.board_count}\")\n```\n\n### 3. Dealing Cards and Progressing Streets\n\nHere's how to deal cards through the different streets of a hand. In a real game, betting rounds would occur between these steps.\n\n```python\nfrom cardspy.cards import SUITS, RANKS, CARDS\nfrom cardspy.card import card_key_to_repr, cards_to_str_pretty\n\n# --- Pre-flop: Deal Hole Cards ---\n# The _core_deal_hole_cards method is called internally by deal_hole_cards.\n# For Texas Hold'em, each player gets 2 hole cards.\ngame_th_regular.deal_hole_cards() \nprint(f\"\\n--- {game_th_regular.game_street.name} --- (Hole cards dealt)\")\nfor player in game_th_regular.table.players:\n # Hole cards are stored as bitmasks in player.hole_cards.key\n # We use card_key_to_repr for a human-readable string\n hole_cards_str = cards_to_str_pretty(player.hole_cards.key)\n print(f\"{player.name} has hole cards: {hole_cards_str}\")\n\n# --- Flop: Deal 3 Community Cards ---\n# Advance the game street and deal the flop\n# game_th_regular.game_street = GameStreet.FLOP # This is handled internally by deal_flop\ngame_th_regular.deal_flop()\nprint(f\"\\n--- {game_th_regular.game_street.name} --- (3 community cards)\")\n# Board cards are stored as a bitmask in game.boards[0].cards\nflop_cards_str = cards_to_str_pretty(game_th_regular.boards[0].cards)\nprint(f\"Board 0: {flop_cards_str}\")\n\n# --- Turn: Deal 1 Community Card ---\n# game_th_regular.game_street = GameStreet.TURN # Handled by deal_turn\ngame_th_regular.deal_turn()\nprint(f\"\\n--- {game_th_regular.game_street.name} --- (1 community card)\")\nturn_cards_str = cards_to_str_pretty(game_th_regular.boards[0].cards)\nprint(f\"Board 0: {turn_cards_str}\")\n\n# --- River: Deal 1 Community Card ---\n# game_th_regular.game_street = GameStreet.RIVER # Handled by deal_river\ngame_th_regular.deal_river()\nprint(f\"\\n--- {game_th_regular.game_street.name} --- (1 community card)\")\nriver_cards_str = cards_to_str_pretty(game_th_regular.boards[0].cards)\nprint(f\"Board 0: {river_cards_str}\")\n\n# At this point, all cards are dealt. The next step would be showdown and pot distribution.\n# Note: The `showdown()` method is not yet fully implemented in the provided snippets.\n# print(\"\\n--- Showdown ---\")\n# winners = game_th_regular.showdown() # Placeholder for actual showdown logic\n```\n\n## Advanced Usage\n\n### 1. Multi-Board Games\n\nYou can play games with multiple boards simultaneously. This is common in some poker variants where the pot is split among winners on different boards.\n\n```python\nfrom pokermgr.game import Game # Base Game class for multi-board\n\n# Re-use the table and players from the previous example\n# Create a game with 3 boards\ngame_multi_board = Game(\n key=2, \n table=table, \n initial_board_count=3\n)\n\nprint(f\"\\nGame {game_multi_board.key} (Multi-Board) initialized with {game_multi_board.board_count} boards.\")\n\n# Deal hole cards (specific to game type, e.g., TexasHoldem would deal 2)\n# For a generic Game, you might need to implement _core_deal_hole_cards\n# or use a game type that defines it, like GameTexasHoldem.\n# Let's assume GameTexasHoldem for dealing hole cards:\nclass MyTexasHoldemMulti(GameTexasHoldemRegular):\n pass # Inherits _core_deal_hole_cards\n\ngame_multi_board_th = MyTexasHoldemMulti(\n key=3, \n table=table, \n small_blind=0, # Blinds might not apply or be handled differently\n big_blind=0,\n initial_board_count=3\n)\n\ngame_multi_board_th.deal_hole_cards()\nprint(f\"Hole cards dealt for multi-board game.\")\nfor player in game_multi_board_th.table.players:\n print(f\"{player.name}: {cards_to_str_pretty(player.hole_cards.key)}\")\n\n# Deal community cards for each board\n# game_multi_board_th.game_street = GameStreet.FLOP # Handled by deal_flop\ngame_multi_board_th.deal_flop()\n# game_multi_board_th.game_street = GameStreet.TURN # Handled by deal_turn\ngame_multi_board_th.deal_turn()\n# game_multi_board_th.game_street = GameStreet.RIVER # Handled by deal_river\ngame_multi_board_th.deal_river()\n\nprint(\"\\nCommunity cards dealt for all boards:\")\nfor i, board_instance in enumerate(game_multi_board_th.boards):\n board_cards_str = cards_to_str_pretty(board_instance.cards)\n print(f\"Board {i}: {board_cards_str}\")\n\n# You can also add boards dynamically during a game\n# game_multi_board_th.add_board()\n# print(f\"\\nAdded a new board. Total boards: {game_multi_board_th.board_count}\")\n# The new board will copy the cards from the most recent existing board.\n```\n\n### 2. Bomb Pot Games (Texas Hold'em Variant)\n\nIn a Bomb Pot, all players are typically forced all-in pre-flop for a fixed amount.\n\n```python\nfrom pokermgr.game import GameTexasHoldemBomb\n\n# Re-use the table and players\n# Create a Bomb Pot game where each player contributes 100 to the pot pre-flop.\ngame_bomb_pot = GameTexasHoldemBomb(\n key=4,\n table=table,\n blind=100, # This is the mandatory amount each player posts\n initial_board_count=1\n)\n\nprint(f\"\\nGame {game_bomb_pot.key} (Bomb Pot) initialized.\")\nprint(f\"Mandatory blind: {game_bomb_pot.blind}\")\n# In a Bomb Pot, the pot is immediately built from all players' blinds.\n# The first pot (self.pots[0]) is initialized with this amount.\nprint(f\"Initial pot size: {game_bomb_pot.pots[0].stack}\") \n\n# Dealing proceeds as normal, but typically without betting rounds pre-flop.\n# Hole cards are dealt\ngame_bomb_pot.deal_hole_cards()\nprint(\"Hole cards dealt for Bomb Pot game.\")\n\n# Community cards are dealt\n# game_bomb_pot.game_street = GameStreet.FLOP # Handled by deal_flop\ngame_bomb_pot.deal_flop()\n# game_bomb_pot.game_street = GameStreet.TURN # Handled by deal_turn\ngame_bomb_pot.deal_turn()\n# game_bomb_pot.game_street = GameStreet.RIVER # Handled by deal_river\ngame_bomb_pot.deal_river()\n\nprint(\"Community cards for Bomb Pot game:\")\nbomb_pot_board_str = cards_to_str_pretty(game_bomb_pot.boards[0].cards)\nprint(f\"Board 0: {bomb_pot_board_str}\")\n```\n\n### 3. Custom Hand Evaluation\n\nThe `Hand` class (from `pokermgr.hand`) can be used to evaluate poker hands represented by bitmasks. The `cardspy` library is used for card representations.\n\n```python\nfrom pokermgr.hand import Hand\nfrom cardspy.deck import cards_to_mask\nfrom cardspy.card import extract_cards\nfrom pokermgr.funcs import get_cards_properties\n\n# Example: Evaluate a specific hand (e.g., a full house)\n# Use string codes for cards: 'As' = Ace of Spades, 'Kd' = King of Diamonds, etc.\n# The order of cards does not matter for evaluation.\ncard_mask = cards_to_mask(['As', 'Ad', 'Ah', 'Kc', 'Kd'])\nhand = Hand(card_mask)\n\n# Display the hand in a human-readable way\nprint(\"Hand cards:\", extract_cards(card_mask))\nprint(\"Hand type:\", hand.type_name)\nprint(\"Hand weight:\", hand.weight)\nprint(\"Hand properties (bitmask):\", get_cards_properties(hand.cards))\n\n# Example: Straight Flush (Royal Flush in hearts)\nsf_mask = cards_to_mask(['Th', 'Jh', 'Qh', 'Kh', 'Ah'])\nsf_hand = Hand(sf_mask)\nprint(\"\\nStraight Flush cards:\", extract_cards(sf_mask))\nprint(\"Hand type:\", sf_hand.type_name)\nprint(\"Hand weight:\", sf_hand.weight)\n# You can also check for draws if relevant\n# print(\"Draws:\", hand.draws)\n\n\n## Project Structure\n\n```\npokermgr/\n\u251c\u2500\u2500 __init__.py\n\u251c\u2500\u2500 board.py # Board and board texture management\n\u251c\u2500\u2500 evaluate.py # Hand evaluation logic\n\u251c\u2500\u2500 funcs.py # Utility functions\n\u251c\u2500\u2500 game.py # Core game logic and variants\n\u251c\u2500\u2500 hand.py # Hand representation\n\u251c\u2500\u2500 hole_cards.py # Hole cards management\n\u251c\u2500\u2500 player.py # Player classes and logic\n\u251c\u2500\u2500 pot.py # Pot management\n\u2514\u2500\u2500 table.py # Table management\n\ntests/ # Comprehensive test suite\n```\n\n## Testing\n\nRun the test suite with pytest:\n\n```bash\npytest tests/\n```\n\n## License\n\nThis project is licensed under the MIT License - see the LICENSE file for details.\n\n## Contributing\n\nContributions are welcome! Please feel free to submit a Pull Request.\n",
"bugtrack_url": null,
"license": null,
"summary": "Comprehensive Python library for managing poker games",
"version": "3.4.0",
"project_urls": null,
"split_keywords": [
"poker",
" texas-holdem",
" omaha",
" card-games",
" game-evaluation"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "2e1647322050e352e2df41dea0ba2758abe6ea62bf1f69060145777e51d202f7",
"md5": "0b3c16486c218fd7d3a1b2ef42aed2c6",
"sha256": "3a0d78938b02a8a361af88b92b0af40cf191dfe9da361888d0c9e56f5c6c273d"
},
"downloads": -1,
"filename": "pokermgr-3.4.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "0b3c16486c218fd7d3a1b2ef42aed2c6",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.10",
"size": 76258,
"upload_time": "2025-07-29T02:50:59",
"upload_time_iso_8601": "2025-07-29T02:50:59.213840Z",
"url": "https://files.pythonhosted.org/packages/2e/16/47322050e352e2df41dea0ba2758abe6ea62bf1f69060145777e51d202f7/pokermgr-3.4.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "60b75bd6e3ba0238c244c6447cc64adf914a2ebc203c4b36627f9e8a7b1e6335",
"md5": "a4ed0ffe3ee2e999db5b0a82c1bc5e42",
"sha256": "0e59404e14df9785318d494ad781f2ebd7f6c3b9d826889c03e128372f247fea"
},
"downloads": -1,
"filename": "pokermgr-3.4.0.tar.gz",
"has_sig": false,
"md5_digest": "a4ed0ffe3ee2e999db5b0a82c1bc5e42",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10",
"size": 62371,
"upload_time": "2025-07-29T02:51:00",
"upload_time_iso_8601": "2025-07-29T02:51:00.498987Z",
"url": "https://files.pythonhosted.org/packages/60/b7/5bd6e3ba0238c244c6447cc64adf914a2ebc203c4b36627f9e8a7b1e6335/pokermgr-3.4.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-07-29 02:51:00",
"github": false,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"lcname": "pokermgr"
}
JSON