haiyingjiang7/poker_task1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

修改

Browse Source
This commit is contained in:
haiyingjiang7@1price.io
2025-09-23 09:59:55 +08:00
commit 674a7b16b7
16 changed files with 1413 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
.gitignore vendored Normal file
View File

@@ -0,0 +1,10 @@
# Python-generated files
__pycache__/
*.py[oc]
build/
dist/
wheels/
*.egg-info
# Virtual environments
.venv

1
.python-version Normal file
View File

@@ -0,0 +1 @@
3.13

177
README.md Normal file
View File

@@ -0,0 +1,177 @@
# Poker Hand Evaluation Program
一个用Python实现的扑克牌手牌评估程序，能够从7张牌中找出最佳的5张牌组合并返回手牌排名。
## 功能特性
- **完整的数据结构**：实现了Card、Deck、HandRanking等核心类
- **字符串解析**：支持从字符串格式解析扑克牌（如 "AsKs AhAdAc6s7s"）
- **手牌评估**：支持所有标准扑克手牌类型的识别和排名
- **最佳组合选择**：从7张牌中自动选择最佳的5张牌组合
- **全面测试**：包含完整的单元测试套件
## 支持的手牌类型
1. **皇家同花顺** (Royal Flush) - A♠K♠Q♠J♠T♠
2. **同花顺** (Straight Flush) - 连续的五张同花色牌
3. **四条** (Four of a Kind) - 四张相同点数的牌
4. **满堂红** (Full House) - 三条加一对
5. **同花** (Flush) - 五张同花色的牌
6. **顺子** (Straight) - 五张连续点数的牌（包括A-2-3-4-5轮子）
7. **三条** (Three of a Kind) - 三张相同点数的牌
8. **两对** (Two Pair) - 两个对子
9. **一对** (One Pair) - 一个对子
10. **高牌** (High Card) - 没有组合的单张高牌
## 安装和使用
### 环境要求
- Python 3.13+
- uv 包管理器
### 运行程序
```bash
# 基本用法
python main.py "AsKs AhAdAc6s7s"
# 输出: Quad(A)
# 其他示例
python main.py "AhKhQhJhTh2c3c"
# 输出: Royal Flush
python main.py "2h3h4h5h6h7s8s"
# 输出: Straight Flush(6 high)
python main.py "JsJhJdQcQs2h3d"
# 输出: Full House(J over Q)
```
### 输入格式
输入字符串应包含恰好7张牌，每张牌用2个字符表示：
- 第一个字符是点数：`2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `T`, `J`, `Q`, `K`, `A`
- 第二个字符是花色：`s`(黑桃), `h`(红桃), `d`(方块), `c`(梅花)
牌之间可以用空格分隔，也可以连续书写。
### 运行测试
```bash
# 运行自定义测试套件
python run_tests.py
# 如果安装了pytest，也可以运行：
pytest tests/ -v
```
## 项目结构
```
poker_emd_task/
├── poker/ # 核心模块
│ ├── __init__.py # 模块初始化
│ ├── card.py # Card、Rank、Suit类
│ ├── deck.py # Deck类
│ ├── hand_ranking.py # HandRanking、HandType类
│ └── hand_evaluator.py # HandEvaluator类（核心算法）
├── tests/ # 测试文件
│ ├── test_card.py
│ ├── test_deck.py
│ ├── test_hand_ranking.py
│ ├── test_hand_evaluator.py
│ └── test_integration.py
├── main.py # 主程序入口
├── run_tests.py # 简化的测试运行器
├── pyproject.toml # 项目配置
└── README.md # 项目说明
```
## 设计特点
### 核心数据结构
- **Card类**：表示单张扑克牌，包含点数和花色
- **Rank枚举**：定义牌的点数，支持比较操作
- **Suit枚举**：定义牌的花色
- **HandType枚举**：定义所有手牌类型及其强度
- **HandRanking类**：表示手牌评估结果，包含类型和关键牌
- **Deck类**：表示一副标准52张牌
- **HandEvaluator类**：核心算法，评估手牌并选择最佳组合
### 算法实现
1. **穷举法**：从7张牌中穷举所有可能的5张牌组合（21种）
2. **模式识别**：对每个5张牌组合识别手牌类型
3. **排名比较**：选择强度最高的手牌组合
4. **特殊处理**：正确处理A-2-3-4-5轮子顺子等特殊情况
### 错误处理
- 输入验证：检查牌数是否为7张
- 格式验证：验证每张牌的格式是否正确
- 范围验证：确保点数和花色在有效范围内
- 友好错误信息：提供清晰的错误提示
## 示例用法
```python
from poker.hand_evaluator import HandEvaluator
from poker.card import Card, Rank, Suit
# 方式1：从字符串评估
ranking = HandEvaluator.evaluate_from_input("AsKs AhAdAc6s7s")
print(ranking) # Quad(A)
# 方式2：从Card对象评估
cards = [
Card(Rank.ACE, Suit.SPADES),
Card(Rank.KING, Suit.SPADES),
# ... 更多牌
]
ranking = HandEvaluator.evaluate_hand(cards)
print(ranking)
```
## 测试覆盖
项目包含全面的测试套件，覆盖：
- 所有核心类的功能测试
- 各种手牌类型的识别测试
- 边界条件和错误情况测试
- 集成测试和端到端测试
运行测试确保所有功能正常工作：
```bash
python run_tests.py
```
预期输出：
```
Running poker hand evaluation tests...
Testing Card functionality...
✓ Card tests passed
Testing hand parsing...
✓ Hand parsing tests passed
Testing hand evaluation...
✓ Hand evaluation tests passed
Testing wheel straight...
✓ Wheel straight test passed
Testing deck functionality...
✓ Deck tests passed
Testing error handling...
✓ Error handling tests passed
Test Results: 6 passed, 0 failed
All tests passed! 🎉
```
## 技术栈
- **语言**：Python 3.13
- **包管理**：uv / poetry
- **测试**：自定义测试框架（也支持pytest）
- **开发环境**：VS Code

32
main.py Normal file
View File

@@ -0,0 +1,32 @@
#!/usr/bin/env python3
"""
Poker hand evaluation program
Takes 7 cards as string input and outputs the best HandRanking
"""
import sys
from poker.hand_evaluator import HandEvaluator
def main():
if len(sys.argv) != 2:
print("Usage: python main.py \"<7 cards>\"")
print("Example: python main.py \"AsKs AhAdAc6s7s\"")
sys.exit(1)
cards_str = sys.argv[1]
try:
# 评估手牌
hand_ranking = HandEvaluator.evaluate_from_input(cards_str)
# 输出结果
print(hand_ranking)
except Exception as e:
print(f"Error: {e}")
sys.exit(1)
if __name__ == "__main__":
main()

9
poker/__init__.py Normal file
View File

@@ -0,0 +1,9 @@
"""
Poker hand evaluation module
"""
from .card import Card, Suit, Rank
from .hand_ranking import HandRanking, HandType
from .hand_evaluator import HandEvaluator
__all__ = ['Card', 'Suit', 'Rank', 'HandRanking', 'HandType', 'HandEvaluator']

129
poker/card.py Normal file
View File

@@ -0,0 +1,129 @@
"""
Card module for poker game
"""
from enum import Enum
from typing import List, Tuple, Optional
class Suit(Enum):
SPADES = 's' # 黑桃
HEARTS = 'h' # 红桃
DIAMONDS = 'd' # 方块
CLUBS = 'c' # 梅花
def __str__(self):
return self.value
class Rank(Enum):
TWO = (2, '2')
THREE = (3, '3')
FOUR = (4, '4')
FIVE = (5, '5')
SIX = (6, '6')
SEVEN = (7, '7')
EIGHT = (8, '8')
NINE = (9, '9')
TEN = (10, 'T')
JACK = (11, 'J')
QUEEN = (12, 'Q')
KING = (13, 'K')
ACE = (14, 'A')
def __new__(cls, value, symbol):
obj = object.__new__(cls)
obj._value_ = value
obj.numeric_value = value
obj.symbol = symbol
return obj
def __str__(self):
return self.symbol
def __lt__(self, other):
if not isinstance(other, Rank):
return NotImplemented
return self.numeric_value < other.numeric_value
class Card:
def __init__(self, rank: Rank, suit: Suit):
self.rank = rank
self.suit = suit
def __str__(self):
return f"{self.rank}{self.suit}"
def __eq__(self, other):
if not isinstance(other, Card):
return False
return self.rank == other.rank and self.suit == other.suit
def __lt__(self, other):
if not isinstance(other, Card):
return NotImplemented
return self.rank.numeric_value < other.rank.numeric_value
@classmethod
def create_card(cls, card_str: str) -> 'Card':
"""
从字符串创建Card对象，例如 "As", "Kh", "2c"
"""
if len(card_str) != 2:
raise ValueError(f"Invalid card string: {card_str}")
rank_char = card_str[0]
suit_char = card_str[1].lower()
# 查找rank
rank = None
for r in Rank:
if r.symbol == rank_char:
rank = r
break
if rank is None:
raise ValueError(f"Invalid rank: {rank_char}")
# 查找suit
suit = None
for s in Suit:
if s.value == suit_char:
suit = s
break
if suit is None:
raise ValueError(f"Invalid suit: {suit_char}")
return cls(rank, suit)
@classmethod
def parse_cards(cls, cards_str: str) -> List['Card']:
"""
从字符串解析多张牌，例如 "AsKs AhAdAc6s7s"
"""
cards_str = cards_str.strip()
if not cards_str:
return []
# 将字符串分割成单独的牌
card_strings = []
i = 0
while i < len(cards_str):
if cards_str[i].isspace():
i += 1
continue
if i + 1 < len(cards_str):
card_str = cards_str[i:i+2]
card_strings.append(card_str)
i += 2
else:
raise ValueError(f"Invalid card format at position {i}")
result = []
for card_str in card_strings:
card_tmp = cls.create_card(card_str)
result.append(card_tmp)
return result

140
poker/hand_evaluator.py Normal file
View File

@@ -0,0 +1,140 @@
"""
Hand evaluator module for poker game
"""
from typing import List, Tuple, Dict
from collections import Counter
from itertools import combinations
from .card import Card, Rank, Suit
from .hand_ranking import HandRanking, HandType
class HandEvaluator:
"""
手牌评估器类，用于评估扑克手牌
"""
@staticmethod
def evaluate_hand(cards: List[Card]) -> HandRanking:
"""
从7张牌中评估出最好的5张牌组合
"""
if len(cards) != 7:
raise ValueError(f"Expected 7 cards, got {len(cards)}")
best_ranking = None
best_cards = None
# 尝试所有可能的5张牌组合
for five_cards in combinations(cards, 5):
ranking = HandEvaluator._evaluate_five_cards(list(five_cards))
if best_ranking is None or ranking > best_ranking:
best_ranking = ranking
best_cards = list(five_cards)
# 更新最佳ranking的cards
best_ranking.cards = best_cards
return best_ranking
@staticmethod
def _evaluate_five_cards(cards: List[Card]) -> HandRanking:
"""
评估5张牌的手牌类型
"""
if len(cards) != 5:
raise ValueError(f"Expected 5 cards, got {len(cards)}")
# 按点数排序（降序）
sorted_cards = sorted(cards, key=lambda c: c.rank.numeric_value, reverse=True)
ranks = [card.rank for card in sorted_cards]
suits = [card.suit for card in sorted_cards]
# 统计点数出现次数
rank_counts = Counter(ranks)
count_values = sorted(rank_counts.values(), reverse=True)
# 检查是否是同花
is_flush = len(set(suits)) == 1
# 检查是否是顺子
is_straight, straight_high = HandEvaluator._is_straight(ranks)
# 根据牌型返回相应的HandRanking
if is_straight and is_flush:
if straight_high == Rank.ACE and ranks == [Rank.ACE, Rank.KING, Rank.QUEEN, Rank.JACK, Rank.TEN]:
return HandRanking(HandType.ROYAL_FLUSH, [Rank.ACE], sorted_cards)
else:
return HandRanking(HandType.STRAIGHT_FLUSH, [straight_high], sorted_cards)
elif count_values == [4, 1]: # 四条
quad_rank = [rank for rank, count in rank_counts.items() if count == 4][0]
kicker = [rank for rank, count in rank_counts.items() if count == 1][0]
return HandRanking(HandType.FOUR_OF_A_KIND, [quad_rank, kicker], sorted_cards)
elif count_values == [3, 2]: # 三条加一对
trips_rank = [rank for rank, count in rank_counts.items() if count == 3][0]
pair_rank = [rank for rank, count in rank_counts.items() if count == 2][0]
return HandRanking(HandType.FULL_HOUSE, [trips_rank, pair_rank], sorted_cards)
elif is_flush: # 同花
return HandRanking(HandType.FLUSH, ranks, sorted_cards)
elif is_straight: # 顺子
return HandRanking(HandType.STRAIGHT, [straight_high], sorted_cards)
elif count_values == [3, 1, 1]: # 三条
trips_rank = [rank for rank, count in rank_counts.items() if count == 3][0]
kickers = sorted([rank for rank, count in rank_counts.items() if count == 1], reverse=True)
return HandRanking(HandType.THREE_OF_A_KIND, [trips_rank] + kickers, sorted_cards)
elif count_values == [2, 2, 1]: # 两对
pairs = sorted([rank for rank, count in rank_counts.items() if count == 2], reverse=True)
kicker = [rank for rank, count in rank_counts.items() if count == 1][0]
return HandRanking(HandType.TWO_PAIR, pairs + [kicker], sorted_cards)
elif count_values == [2, 1, 1, 1]: # 一对
pair_rank = [rank for rank, count in rank_counts.items() if count == 2][0]
kickers = sorted([rank for rank, count in rank_counts.items() if count == 1], reverse=True)
return HandRanking(HandType.ONE_PAIR, [pair_rank] + kickers, sorted_cards)
else: # 高牌
return HandRanking(HandType.HIGH_CARD, ranks, sorted_cards)
@staticmethod
def _is_straight(ranks: List[Rank]) -> Tuple[bool, Rank]:
"""
检查是否是顺子，返回(是否是顺子, 最高牌)
"""
# 排序点数值
values = sorted([rank.numeric_value for rank in ranks], reverse=True)
# 检查常规顺子
is_regular_straight = True
for i in range(1, len(values)):
if values[i-1] - values[i] != 1:
is_regular_straight = False
break
if is_regular_straight:
# 返回最高牌
highest_rank = None
for rank in ranks:
if rank.numeric_value == values[0]:
highest_rank = rank
break
return True, highest_rank
# 检查A-2-3-4-5的特殊顺子（轮子）
if values == [14, 5, 4, 3, 2]: # A, 5, 4, 3, 2
return True, Rank.FIVE # 在轮子中，5是最高牌
return False, None
@staticmethod
def evaluate_from_input(cards_str: str) -> HandRanking:
"""
从字符串评估手牌，例如 "AsKs AhAdAc6s7s"
"""
cards = Card.parse_cards(cards_str)
return HandEvaluator.evaluate_hand(cards)

125
poker/hand_ranking.py Normal file
View File

@@ -0,0 +1,125 @@
"""
Hand ranking module for poker game
"""
from enum import Enum
from typing import List, Tuple
from .card import Card, Rank
class HandType(Enum):
"""
手牌类型枚举，按强度排序
"""
HIGH_CARD = (1, "High Card")
ONE_PAIR = (2, "Pair")
TWO_PAIR = (3, "Two Pair")
THREE_OF_A_KIND = (4, "Three of a Kind")
STRAIGHT = (5, "Straight")
FLUSH = (6, "Flush")
FULL_HOUSE = (7, "Full House")
FOUR_OF_A_KIND = (8, "Four of a Kind")
STRAIGHT_FLUSH = (9, "Straight Flush")
ROYAL_FLUSH = (10, "Royal Flush")
def __new__(cls, strength, name):
obj = object.__new__(cls)
obj._value_ = strength
obj.strength = strength
obj.type_name = name
return obj
def __str__(self):
return self.type_name
def __lt__(self, other):
if not isinstance(other, HandType):
return NotImplemented
return self.strength < other.strength
def __le__(self, other):
if not isinstance(other, HandType):
return NotImplemented
return self.strength <= other.strength
def __gt__(self, other):
if not isinstance(other, HandType):
return NotImplemented
return self.strength > other.strength
def __ge__(self, other):
if not isinstance(other, HandType):
return NotImplemented
return self.strength >= other.strength
class HandRanking:
"""
手牌排名类，包含手牌类型和关键牌
"""
def __init__(self, hand_type: HandType, key_ranks: List[Rank], cards: List[Card]):
self.hand_type = hand_type
self.key_ranks = key_ranks # 用于比较的关键点数
self.cards = cards # 组成这个排名的5张牌
def __str__(self):
"""
返回手牌排名的字符串表示
"""
if self.hand_type == HandType.FOUR_OF_A_KIND:
return f"Quad({self.key_ranks[0].symbol})"
elif self.hand_type == HandType.FULL_HOUSE:
return f"Full House({self.key_ranks[0].symbol} over {self.key_ranks[1].symbol})"
elif self.hand_type == HandType.FLUSH:
return f"Flush({self.key_ranks[0].symbol} high)"
elif self.hand_type == HandType.STRAIGHT:
return f"Straight({self.key_ranks[0].symbol} high)"
elif self.hand_type == HandType.STRAIGHT_FLUSH:
if self.key_ranks[0] == Rank.ACE:
return "Royal Flush"
else:
return f"Straight Flush({self.key_ranks[0].symbol} high)"
elif self.hand_type == HandType.ROYAL_FLUSH:
return "Royal Flush"
elif self.hand_type == HandType.THREE_OF_A_KIND:
return f"Three of a Kind({self.key_ranks[0].symbol})"
elif self.hand_type == HandType.TWO_PAIR:
return f"Two Pair({self.key_ranks[0].symbol} and {self.key_ranks[1].symbol})"
elif self.hand_type == HandType.ONE_PAIR:
return f"Pair({self.key_ranks[0].symbol})"
else: # HIGH_CARD
return f"High Card({self.key_ranks[0].symbol})"
def __repr__(self):
return f"HandRanking({self.hand_type}, {[r.symbol for r in self.key_ranks]})"
def __eq__(self, other):
if not isinstance(other, HandRanking):
return False
return (self.hand_type == other.hand_type and
self.key_ranks == other.key_ranks)
def __lt__(self, other):
if not isinstance(other, HandRanking):
return NotImplemented
# 首先比较手牌类型
if self.hand_type != other.hand_type:
return self.hand_type < other.hand_type
# 如果手牌类型相同，比较关键点数
for self_rank, other_rank in zip(self.key_ranks, other.key_ranks):
if self_rank != other_rank:
return self_rank < other_rank
return False # 完全相等
def __le__(self, other):
return self == other or self < other
def __gt__(self, other):
return not self <= other
def __ge__(self, other):
return not self < other

20
pyproject.toml Normal file
View File

@@ -0,0 +1,20 @@
[project]
name = "poker-emd-task"
version = "0.1.0"
description = "Poker hand evaluation program"
readme = "README.md"
requires-python = ">=3.13"
dependencies = [
"pytest>=8.4.2",
]
[project.optional-dependencies]
dev = ["pytest>=7.0.0"]
[build-system]
requires = ["setuptools", "wheel"]
build-backend = "setuptools.build_meta"
[tool.pytest.ini_options]
testpaths = ["tests"]
python_files = ["test_*.py"]

144
run_tests.py Normal file
View File

@@ -0,0 +1,144 @@
#!/usr/bin/env python3
"""
Simple test runner without pytest dependency
"""
import sys
import traceback
from poker.card import Card, Rank, Suit
from poker.hand_evaluator import HandEvaluator
from poker.hand_ranking import HandType
def test_basic_card_functionality():
"""Test basic card functionality"""
print("Testing Card functionality...")
# Test card creation and string representation
card = Card(Rank.ACE, Suit.SPADES)
assert str(card) == "As", f"Expected 'As', got '{str(card)}'"
# Test card parsing
parsed_card = Card.from_string("Kh")
assert parsed_card.rank == Rank.KING
assert parsed_card.suit == Suit.HEARTS
# Test card comparison
ace = Card(Rank.ACE, Suit.SPADES)
king = Card(Rank.KING, Suit.HEARTS)
assert king < ace, "King should be less than Ace"
print("✓ Card tests passed")
def test_hand_parsing():
"""Test hand parsing from string"""
print("Testing hand parsing...")
cards = Card.parse_cards("AsKs AhAdAc6s7s")
assert len(cards) == 7, f"Expected 7 cards, got {len(cards)}"
assert str(cards[0]) == "As"
assert str(cards[6]) == "7s"
print("✓ Hand parsing tests passed")
def test_hand_evaluation_examples():
"""Test hand evaluation with known examples"""
print("Testing hand evaluation...")
test_cases = [
("AsKs AhAdAc6s7s", "Quad(A)", HandType.FOUR_OF_A_KIND),
("AhKhQhJhTh2c3c", "Royal Flush", HandType.ROYAL_FLUSH), # Royal flush has its own type
("2h3h4h5h6h7s8s", "Straight Flush(6 high)", HandType.STRAIGHT_FLUSH),
("AsAhAd KsKh6s7s", "Full House(A over K)", HandType.FULL_HOUSE),
("AhKh6h4h2h7s8s", "Flush(A high)", HandType.FLUSH),
("AsTsJhQdKh7s8s", "Straight(A high)", HandType.STRAIGHT),
("AsAhAd6s7h8s9s", "Three of a Kind(A)", HandType.THREE_OF_A_KIND),
("AsAh6d6s7h8c9s", "Two Pair(A and 6)", HandType.TWO_PAIR), # Changed to avoid straight
("AsAh6d7c8h9cJd", "Pair(A)", HandType.ONE_PAIR), # Changed to avoid straight
("As6h7d8s9hJdQc", "High Card(A)", HandType.HIGH_CARD), # Changed to avoid straight
]
for cards_str, expected_str, expected_type in test_cases:
ranking = HandEvaluator.evaluate_from_input(cards_str)
actual_str = str(ranking)
assert ranking.hand_type == expected_type, f"Wrong hand type for {cards_str}: expected {expected_type}, got {ranking.hand_type}"
assert actual_str == expected_str, f"Wrong string for {cards_str}: expected '{expected_str}', got '{actual_str}'"
print("✓ Hand evaluation tests passed")
def test_wheel_straight():
"""Test A-2-3-4-5 straight (wheel)"""
print("Testing wheel straight...")
cards_str = "As2h3d4c5h7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.STRAIGHT
assert ranking.key_ranks[0] == Rank.FIVE, "In wheel straight, 5 should be the high card"
assert str(ranking) == "Straight(5 high)"
print("✓ Wheel straight test passed")
def test_error_handling():
"""Test error handling"""
print("Testing error handling...")
# Test invalid card string
try:
Card.from_string("Xx")
assert False, "Should have raised ValueError for invalid card"
except ValueError:
pass # Expected
# Test wrong number of cards
try:
HandEvaluator.evaluate_from_input("AsKh")
assert False, "Should have raised ValueError for wrong number of cards"
except ValueError:
pass # Expected
print("✓ Error handling tests passed")
def run_all_tests():
"""Run all tests"""
print("Running poker hand evaluation tests...\n")
test_functions = [
test_basic_card_functionality,
test_hand_parsing,
test_hand_evaluation_examples,
test_wheel_straight,
test_error_handling,
]
passed = 0
failed = 0
for test_func in test_functions:
try:
test_func()
passed += 1
except Exception as e:
print(f"✗ {test_func.__name__} FAILED: {e}")
traceback.print_exc()
failed += 1
print(f"\nTest Results: {passed} passed, {failed} failed")
if failed > 0:
print("Some tests failed!")
return False
else:
print("All tests passed! 🎉")
return True
if __name__ == "__main__":
success = run_all_tests()
sys.exit(0 if success else 1)

3
tests/__init__.py Normal file
View File

@@ -0,0 +1,3 @@
"""
Test module initialization
"""

155
tests/test_card.py Normal file
View File

@@ -0,0 +1,155 @@
"""
Tests for Card, Rank, and Suit classes
"""
import pytest
from poker.card import Card, Rank, Suit
class TestRank:
"""Test cases for Rank enum"""
def test_rank_values(self):
"""Test rank numeric values"""
assert Rank.TWO.numeric_value == 2
assert Rank.ACE.numeric_value == 14
assert Rank.KING.numeric_value == 13
assert Rank.JACK.numeric_value == 11
def test_rank_symbols(self):
"""Test rank symbols"""
assert Rank.TWO.symbol == '2'
assert Rank.ACE.symbol == 'A'
assert Rank.KING.symbol == 'K'
assert Rank.TEN.symbol == 'T'
def test_rank_comparison(self):
"""Test rank comparison operations"""
assert Rank.TWO < Rank.THREE
assert Rank.KING < Rank.ACE
assert Rank.JACK > Rank.TEN
assert Rank.ACE >= Rank.KING
assert Rank.TWO <= Rank.TWO
def test_rank_str(self):
"""Test string representation"""
assert str(Rank.ACE) == 'A'
assert str(Rank.KING) == 'K'
assert str(Rank.TWO) == '2'
class TestSuit:
"""Test cases for Suit enum"""
def test_suit_values(self):
"""Test suit values"""
assert Suit.SPADES.value == 's'
assert Suit.HEARTS.value == 'h'
assert Suit.DIAMONDS.value == 'd'
assert Suit.CLUBS.value == 'c'
def test_suit_str(self):
"""Test string representation"""
assert str(Suit.SPADES) == 's'
assert str(Suit.HEARTS) == 'h'
class TestCard:
"""Test cases for Card class"""
def test_card_creation(self):
"""Test card creation"""
card = Card(Rank.ACE, Suit.SPADES)
assert card.rank == Rank.ACE
assert card.suit == Suit.SPADES
def test_card_str(self):
"""Test string representation"""
card = Card(Rank.ACE, Suit.SPADES)
assert str(card) == 'As'
card2 = Card(Rank.KING, Suit.HEARTS)
assert str(card2) == 'Kh'
def test_card_equality(self):
"""Test card equality"""
card1 = Card(Rank.ACE, Suit.SPADES)
card2 = Card(Rank.ACE, Suit.SPADES)
card3 = Card(Rank.ACE, Suit.HEARTS)
assert card1 == card2
assert card1 != card3
def test_card_comparison(self):
"""Test card comparison (by rank)"""
ace_spades = Card(Rank.ACE, Suit.SPADES)
king_hearts = Card(Rank.KING, Suit.HEARTS)
two_clubs = Card(Rank.TWO, Suit.CLUBS)
assert two_clubs < king_hearts
assert king_hearts < ace_spades
assert not (ace_spades < king_hearts)
def test_from_string_valid(self):
"""Test creating card from valid string"""
card = Card.from_string("As")
assert card.rank == Rank.ACE
assert card.suit == Suit.SPADES
card2 = Card.from_string("Kh")
assert card2.rank == Rank.KING
assert card2.suit == Suit.HEARTS
card3 = Card.from_string("2c")
assert card3.rank == Rank.TWO
assert card3.suit == Suit.CLUBS
card4 = Card.from_string("Td")
assert card4.rank == Rank.TEN
assert card4.suit == Suit.DIAMONDS
def test_from_string_invalid(self):
"""Test creating card from invalid string"""
with pytest.raises(ValueError):
Card.from_string("A") # Too short
with pytest.raises(ValueError):
Card.from_string("Asx") # Too long
with pytest.raises(ValueError):
Card.from_string("Xs") # Invalid rank
with pytest.raises(ValueError):
Card.from_string("Ax") # Invalid suit
def test_parse_cards_valid(self):
"""Test parsing multiple cards from string"""
cards = Card.parse_cards("AsKs AhAdAc6s7s")
assert len(cards) == 7
assert str(cards[0]) == "As"
assert str(cards[1]) == "Ks"
assert str(cards[2]) == "Ah"
assert str(cards[6]) == "7s"
def test_parse_cards_with_spaces(self):
"""Test parsing cards with various spacing"""
cards = Card.parse_cards("As Ks Ah Ad Ac 6s 7s")
assert len(cards) == 7
assert str(cards[0]) == "As"
assert str(cards[6]) == "7s"
def test_parse_cards_empty(self):
"""Test parsing empty string"""
cards = Card.parse_cards("")
assert len(cards) == 0
cards = Card.parse_cards(" ")
assert len(cards) == 0
def test_parse_cards_invalid(self):
"""Test parsing invalid card strings"""
with pytest.raises(ValueError):
Card.parse_cards("AsKs A") # Incomplete card
with pytest.raises(ValueError):
Card.parse_cards("AsKs Ax") # Invalid suit

161
tests/test_hand_evaluator.py Normal file
View File

@@ -0,0 +1,161 @@
"""
Tests for HandEvaluator class
"""
import pytest
from poker.hand_evaluator import HandEvaluator
from poker.hand_ranking import HandType
from poker.card import Card, Rank, Suit
class TestHandEvaluator:
"""Test cases for HandEvaluator class"""
def test_royal_flush(self):
"""Test royal flush detection"""
cards_str = "AhKhQhJhTh2c3c"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.ROYAL_FLUSH
assert str(ranking) == "Royal Flush"
def test_straight_flush(self):
"""Test straight flush detection"""
cards_str = "2h3h4h5h6h7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.STRAIGHT_FLUSH
assert str(ranking) == "Straight Flush(6 high)"
def test_four_of_a_kind(self):
"""Test four of a kind detection"""
cards_str = "AsKs AhAdAc6s7s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.FOUR_OF_A_KIND
assert str(ranking) == "Quad(A)"
def test_full_house(self):
"""Test full house detection"""
cards_str = "AsAhAd KsKh6s7s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.FULL_HOUSE
assert "Full House(A over K)" in str(ranking)
def test_flush(self):
"""Test flush detection"""
cards_str = "AhKh6h4h2h7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.FLUSH
assert "Flush(A high)" in str(ranking)
def test_straight(self):
"""Test straight detection"""
cards_str = "As2h3d4c5h7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.STRAIGHT
assert str(ranking) == "Straight(5 high)" # A-2-3-4-5 wheel
def test_straight_ace_high(self):
"""Test straight with ace high"""
cards_str = "AsTsJhQdKh7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.STRAIGHT
assert str(ranking) == "Straight(A high)"
def test_three_of_a_kind(self):
"""Test three of a kind detection"""
cards_str = "AsAhAd6s7h8s9s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.THREE_OF_A_KIND
assert str(ranking) == "Three of a Kind(A)"
def test_two_pair(self):
"""Test two pair detection"""
cards_str = "AsAh6d6s7h8s9s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.TWO_PAIR
assert "Two Pair(A and 6)" in str(ranking)
def test_one_pair(self):
"""Test one pair detection"""
cards_str = "AsAh6d4s2h3cJd"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.ONE_PAIR
assert str(ranking) == "Pair(A)"
def test_high_card(self):
"""Test high card detection"""
cards_str = "As6h4d8s9hJdKc"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.HIGH_CARD
assert str(ranking) == "High Card(A)"
def test_wheel_straight(self):
"""Test A-2-3-4-5 straight (wheel)"""
cards_str = "As2h3d4c5h7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.STRAIGHT
assert ranking.key_ranks[0] == Rank.FIVE # 5 is high in wheel
def test_invalid_input_not_seven_cards(self):
"""Test error handling for wrong number of cards"""
with pytest.raises(ValueError):
HandEvaluator.evaluate_from_input("AsKh")
with pytest.raises(ValueError):
HandEvaluator.evaluate_from_input("AsKhQdJc9h8s7d6c")
def test_invalid_card_format(self):
"""Test error handling for invalid card format"""
with pytest.raises(ValueError):
HandEvaluator.evaluate_from_input("AsKhQdJcXh8s7d")
def test_seven_cards_best_five_selected(self):
"""Test that best 5 cards are selected from 7"""
# Should pick the straight flush over the pair
cards_str = "2h3h4h5h6hAsAd"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.STRAIGHT_FLUSH
assert str(ranking) == "Straight Flush(6 high)"
def test_multiple_possible_straights(self):
"""Test selecting highest straight from multiple possibilities"""
cards_str = "As2h3d4c5h6s7s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.STRAIGHT
# Should pick 3-4-5-6-7 over A-2-3-4-5
assert ranking.key_ranks[0] == Rank.SEVEN
def test_multiple_possible_flushes(self):
"""Test selecting best flush from multiple suits"""
cards_str = "AhKh6h4h2h7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert ranking.hand_type == HandType.FLUSH
assert ranking.key_ranks[0] == Rank.ACE
def test_evaluate_five_cards_directly(self):
"""Test evaluating exactly 5 cards"""
cards = [
Card(Rank.ACE, Suit.SPADES),
Card(Rank.ACE, Suit.HEARTS),
Card(Rank.ACE, Suit.DIAMONDS),
Card(Rank.ACE, Suit.CLUBS),
Card(Rank.KING, Suit.SPADES)
]
ranking = HandEvaluator._evaluate_five_cards(cards)
assert ranking.hand_type == HandType.FOUR_OF_A_KIND
assert ranking.key_ranks[0] == Rank.ACE

137
tests/test_hand_ranking.py Normal file
View File

@@ -0,0 +1,137 @@
"""
Tests for HandRanking and HandType classes
"""
import pytest
from poker.hand_ranking import HandRanking, HandType
from poker.card import Card, Rank, Suit
class TestHandType:
"""Test cases for HandType enum"""
def test_hand_type_values(self):
"""Test hand type strength values"""
assert HandType.HIGH_CARD.strength == 1
assert HandType.ONE_PAIR.strength == 2
assert HandType.ROYAL_FLUSH.strength == 10
def test_hand_type_names(self):
"""Test hand type names"""
assert HandType.HIGH_CARD.type_name == "High Card"
assert HandType.FOUR_OF_A_KIND.type_name == "Four of a Kind"
assert str(HandType.ROYAL_FLUSH) == "Royal Flush"
def test_hand_type_comparison(self):
"""Test hand type comparison"""
assert HandType.HIGH_CARD < HandType.ONE_PAIR
assert HandType.FULL_HOUSE > HandType.FLUSH
assert HandType.ROYAL_FLUSH >= HandType.STRAIGHT_FLUSH
assert HandType.TWO_PAIR <= HandType.THREE_OF_A_KIND
class TestHandRanking:
"""Test cases for HandRanking class"""
def test_hand_ranking_creation(self):
"""Test hand ranking creation"""
cards = [
Card(Rank.ACE, Suit.SPADES),
Card(Rank.ACE, Suit.HEARTS),
Card(Rank.ACE, Suit.DIAMONDS),
Card(Rank.ACE, Suit.CLUBS),
Card(Rank.KING, Suit.SPADES)
]
ranking = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE, Rank.KING], cards)
assert ranking.hand_type == HandType.FOUR_OF_A_KIND
assert ranking.key_ranks == [Rank.ACE, Rank.KING]
assert ranking.cards == cards
def test_quad_string_representation(self):
"""Test string representation for four of a kind"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
ranking = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE, Rank.KING], cards)
assert str(ranking) == "Quad(A)"
def test_full_house_string_representation(self):
"""Test string representation for full house"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
ranking = HandRanking(HandType.FULL_HOUSE, [Rank.ACE, Rank.KING], cards)
assert str(ranking) == "Full House(A over K)"
def test_flush_string_representation(self):
"""Test string representation for flush"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
ranking = HandRanking(HandType.FLUSH, [Rank.ACE], cards)
assert str(ranking) == "Flush(A high)"
def test_straight_string_representation(self):
"""Test string representation for straight"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
ranking = HandRanking(HandType.STRAIGHT, [Rank.ACE], cards)
assert str(ranking) == "Straight(A high)"
def test_straight_flush_string_representation(self):
"""Test string representation for straight flush"""
cards = [Card(Rank.KING, Suit.SPADES)] * 5 # Dummy cards
ranking = HandRanking(HandType.STRAIGHT_FLUSH, [Rank.KING], cards)
assert str(ranking) == "Straight Flush(K high)"
def test_royal_flush_string_representation(self):
"""Test string representation for royal flush"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
ranking1 = HandRanking(HandType.ROYAL_FLUSH, [Rank.ACE], cards)
assert str(ranking1) == "Royal Flush"
# Also test straight flush with Ace high
ranking2 = HandRanking(HandType.STRAIGHT_FLUSH, [Rank.ACE], cards)
assert str(ranking2) == "Royal Flush"
def test_three_of_a_kind_string_representation(self):
"""Test string representation for three of a kind"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
ranking = HandRanking(HandType.THREE_OF_A_KIND, [Rank.ACE], cards)
assert str(ranking) == "Three of a Kind(A)"
def test_two_pair_string_representation(self):
"""Test string representation for two pair"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
ranking = HandRanking(HandType.TWO_PAIR, [Rank.ACE, Rank.KING], cards)
assert str(ranking) == "Two Pair(A and K)"
def test_one_pair_string_representation(self):
"""Test string representation for one pair"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
ranking = HandRanking(HandType.ONE_PAIR, [Rank.ACE], cards)
assert str(ranking) == "Pair(A)"
def test_high_card_string_representation(self):
"""Test string representation for high card"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
ranking = HandRanking(HandType.HIGH_CARD, [Rank.ACE], cards)
assert str(ranking) == "High Card(A)"
def test_hand_ranking_equality(self):
"""Test hand ranking equality"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
ranking1 = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE, Rank.KING], cards)
ranking2 = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE, Rank.KING], cards)
ranking3 = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.KING, Rank.ACE], cards)
assert ranking1 == ranking2
assert ranking1 != ranking3
def test_hand_ranking_comparison(self):
"""Test hand ranking comparison"""
cards = [Card(Rank.ACE, Suit.SPADES)] * 5 # Dummy cards
# Different hand types
quad_aces = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE], cards)
full_house = HandRanking(HandType.FULL_HOUSE, [Rank.ACE], cards)
assert full_house < quad_aces
# Same hand type, different ranks
quad_aces = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE], cards)
quad_kings = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.KING], cards)
assert quad_kings < quad_aces

86
tests/test_integration.py Normal file
View File

@@ -0,0 +1,86 @@
"""
Integration tests for the main program
"""
import pytest
import sys
import io
from unittest.mock import patch
from poker.hand_evaluator import HandEvaluator
class TestMainProgram:
"""Integration tests for main program functionality"""
def test_example_input(self):
"""Test the example input from the requirements"""
cards_str = "AsKs AhAdAc6s7s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert str(ranking) == "Quad(A)"
def test_various_hand_types(self):
"""Test various hand types work correctly end-to-end"""
test_cases = [
("AhKhQhJhTh2c3c", "Royal Flush"),
("2h3h4h5h6h7s8s", "Straight Flush(6 high)"),
("AsKs AhAdAc6s7s", "Quad(A)"),
("AsAhAd KsKh6s7s", "Full House(A over K)"),
("AhKh6h4h2h7s8s", "Flush(A high)"),
("AsTsJhQdKh7s8s", "Straight(A high)"),
("AsAhAd6s7h8s9s", "Three of a Kind(A)"),
("AsAh6d6s7h8s9s", "Two Pair(A and 6)"),
("AsAh6d4s2h3cJd", "Pair(A)"),
("As6h4d8s9hJdKc", "High Card(A)"),
]
for cards_str, expected_result in test_cases:
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert str(ranking) == expected_result, f"Failed for {cards_str}"
def test_wheel_straight(self):
"""Test A-2-3-4-5 straight (wheel)"""
cards_str = "As2h3d4c5h7s8s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert str(ranking) == "Straight(5 high)"
def test_different_card_formats(self):
"""Test different ways of writing the same cards"""
# These should all represent the same hand
formats = [
"AsKsAhAdAc6s7s",
"As Ks Ah Ad Ac 6s 7s",
"As Ks Ah Ad Ac 6s 7s",
]
expected_result = "Quad(A)"
for cards_str in formats:
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert str(ranking) == expected_result
def test_case_insensitive_suits(self):
"""Test that suits are case insensitive"""
cards_str = "AsKsAhAdAc6s7s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert str(ranking) == "Quad(A)"
def test_edge_cases(self):
"""Test edge cases and boundary conditions"""
# All same rank except one
cards_str = "2s2h2d2c3s4h5d"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert str(ranking) == "Quad(2)"
# Minimum straight
cards_str = "As2h3d4c5h6s7s"
ranking = HandEvaluator.evaluate_from_input(cards_str)
# Should pick 3-4-5-6-7 over A-2-3-4-5
assert "Straight(7 high)" in str(ranking)
# Maximum straight
cards_str = "9sTsJhQdKhAsAd"
ranking = HandEvaluator.evaluate_from_input(cards_str)
assert str(ranking) == "Straight(A high)"

84
uv.lock generated Normal file
View File

@@ -0,0 +1,84 @@
version = 1
revision = 3
requires-python = ">=3.13"
[[package]]
name = "colorama"
version = "0.4.6"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
]
[[package]]
name = "iniconfig"
version = "2.1.0"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793, upload-time = "2025-03-19T20:09:59.721Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050, upload-time = "2025-03-19T20:10:01.071Z" },
]
[[package]]
name = "packaging"
version = "25.0"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
]
[[package]]
name = "pluggy"
version = "1.6.0"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
]
[[package]]
name = "poker-emd-task"
version = "0.1.0"
source = { editable = "." }
dependencies = [
{ name = "pytest" },
]
[package.optional-dependencies]
dev = [
{ name = "pytest" },
]
[package.metadata]
requires-dist = [
{ name = "pytest", specifier = ">=8.4.2" },
{ name = "pytest", marker = "extra == 'dev'", specifier = ">=7.0.0" },
]
provides-extras = ["dev"]
[[package]]
name = "pygments"
version = "2.19.2"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
]
[[package]]
name = "pytest"
version = "8.4.2"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "colorama", marker = "sys_platform == 'win32'" },
{ name = "iniconfig" },
{ name = "packaging" },
{ name = "pluggy" },
{ name = "pygments" },
]
sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750, upload-time = "2025-09-04T14:34:20.226Z" },
]