修改

.gitignore

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

.python-version

@@ -0,0 +1 @@
+3.13

README.md

@@ -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
+

main.py

@@ -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()

poker/__init__.py

@@ -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']

poker/card.py

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

poker/hand_evaluator.py

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

poker/hand_ranking.py

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

pyproject.toml

@@ -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"]

run_tests.py

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

tests/__init__.py

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

tests/test_card.py

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

tests/test_hand_evaluator.py

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

tests/test_hand_ranking.py

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

tests/test_integration.py

@@ -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)"

uv.lock

@@ -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" },
+]