refactor: improve hand divider performance a bit (#185)

* refactor: improve hand divider performance a bit

* fix linter

* address pr comments

* address pr comments

Author: Nihisil

CHANGELOG.md

@@ -93,6 +93,7 @@ The following methods are now available as static methods:
 - Yakuhai detection (hatsu, haku, chun, winds) now uses `has_pon_or_kan_of()` instead of counting triplets. Behavior changes for invalid hands with two or more identical triplets of the same tile.
 - Fixed an issue where `KokushiMusou.is_condition_met()` would return `None` if the condition was not met. It now consistently returns a `bool` value. Remove any `None` checks in the code that relied on the previous behavior.
 - `Shanten.calculate_shanten()` and `Shanten.calculate_shanten_for_regular_hand()` now raises `ValueError` instead of `assert` when the number of tiles is 15 or more.
+- `HandDivider.divide_hand()` now determines block type from `Meld.type` instead of inferring it from `Meld.tiles`. Behavior may differ for invalid `Meld.tiles` or inconsistent `Meld.type` and `Meld.tiles` combinations.
 
 ## What's Changed
 - Placeholder. It would be filled on release automatically

mahjong/hand_calculating/divider.py

@@ -1,47 +1,37 @@
 from collections.abc import Collection, Sequence
 from dataclasses import dataclass
-from enum import Enum
-from functools import lru_cache, total_ordering
+from enum import IntEnum
+from functools import lru_cache
 from typing import Literal
 
 from mahjong.meld import Meld
-from mahjong.utils import is_chi, is_kan, is_pon
 
 
-class _BlockType(Enum):
+class _BlockType(IntEnum):
     QUAD = 0
     TRIPLET = 1
     PAIR = 2
     SEQUENCE = 3
 
 
-@total_ordering
-@dataclass(frozen=True)
-class _Block:  # noqa: PLW1641 __hash__ is automatically implemented
-    ty: _BlockType
+@dataclass(frozen=True, order=True)
+class _Block:
     tile_34: int
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, _Block):
-            return NotImplemented
-        return (self.tile_34, self.ty.value) == (other.tile_34, other.ty.value)
-
-    def __lt__(self, other: object) -> bool:
-        if not isinstance(other, _Block):
-            return NotImplemented
-        return (self.tile_34, self.ty.value) < (other.tile_34, other.ty.value)
+    ty: _BlockType
 
     @classmethod
     def from_meld(cls, meld: Meld) -> "_Block":
-        tiles_34 = meld.tiles_34
-        if is_chi(tiles_34):
-            return cls(_BlockType.SEQUENCE, tiles_34[0])
-        if is_pon(tiles_34):
-            return cls(_BlockType.TRIPLET, tiles_34[0])
-        if is_kan(tiles_34):
-            return cls(_BlockType.QUAD, tiles_34[0])
-        msg = f"invalid meld type: {meld.type}, tiles: {tiles_34}"
-        raise RuntimeError(msg)
+        tile_34 = meld.tiles_34[0]
+        match meld.type:
+            case Meld.CHI:
+                return cls(tile_34, _BlockType.SEQUENCE)
+            case Meld.PON:
+                return cls(tile_34, _BlockType.TRIPLET)
+            case Meld.KAN | Meld.SHOUMINKAN:
+                return cls(tile_34, _BlockType.QUAD)
+            case _:
+                msg = f"invalid meld type: {meld.type}, tiles: {meld.tiles_34}"
+                raise RuntimeError(msg)
 
     @property
     def tiles_34(self) -> list[int]:
@@ -126,21 +116,28 @@ def _divide_hand_impl(pure_hand: tuple[int, ...], melds: tuple[_Block, ...]) ->
 
     @staticmethod
     def _decompose_chiitoitsu(pure_hand: list[int]) -> list[_Block]:
-        blocks = [_Block(_BlockType.PAIR, i) for i, count in enumerate(pure_hand) if count == 2]
+        blocks = [_Block(i, _BlockType.PAIR) for i, count in enumerate(pure_hand) if count == 2]
         return blocks if len(blocks) == 7 else []
 
     @staticmethod
     def _decompose_single_color_hand(single_color_hand: list[int], suit: Literal[0, 9, 18]) -> list[list[_Block]]:
-        combinations = HandDivider._decompose_single_color_hand_without_pair(single_color_hand, [], 0, suit)
+        remaining = sum(single_color_hand)
+        combinations = HandDivider._decompose_single_color_hand_without_pair(single_color_hand, [], 0, suit, remaining)
 
         if not combinations:
             for pair in range(9):
                 if single_color_hand[pair] < 2:
                     continue
 
                 single_color_hand[pair] -= 2
-                blocks = [_Block(_BlockType.PAIR, suit + pair)]
-                comb = HandDivider._decompose_single_color_hand_without_pair(single_color_hand, blocks, 0, suit)
+                blocks = [_Block(suit + pair, _BlockType.PAIR)]
+                comb = HandDivider._decompose_single_color_hand_without_pair(
+                    single_color_hand,
+                    blocks,
+                    0,
+                    suit,
+                    remaining - 2,
+                )
                 single_color_hand[pair] += 2
 
                 if not comb:
@@ -156,25 +153,33 @@ def _decompose_single_color_hand_without_pair(
         blocks: list[_Block],
         i: int,
         suit: Literal[0, 9, 18],
+        remaining: int,
     ) -> list[list[_Block]]:
         if i == 9:
-            return [blocks] if sum(single_color_hand) == 0 else []
+            return [blocks] if remaining == 0 else []
 
         if single_color_hand[i] == 0:
-            return HandDivider._decompose_single_color_hand_without_pair(single_color_hand, blocks, i + 1, suit)
+            return HandDivider._decompose_single_color_hand_without_pair(
+                single_color_hand,
+                blocks,
+                i + 1,
+                suit,
+                remaining,
+            )
 
         combinations: list[list[_Block]] = []
 
         if i < 7 and single_color_hand[i] >= 1 and single_color_hand[i + 1] >= 1 and single_color_hand[i + 2] >= 1:
             single_color_hand[i] -= 1
             single_color_hand[i + 1] -= 1
             single_color_hand[i + 2] -= 1
-            new_blocks = [*blocks, _Block(_BlockType.SEQUENCE, suit + i)]
+            new_blocks = [*blocks, _Block(suit + i, _BlockType.SEQUENCE)]
             new_combination = HandDivider._decompose_single_color_hand_without_pair(
                 single_color_hand,
                 new_blocks,
                 i,
                 suit,
+                remaining - 3,
             )
             combinations.extend(new_combination)
             single_color_hand[i + 2] += 1
@@ -183,12 +188,13 @@ def _decompose_single_color_hand_without_pair(
 
         if single_color_hand[i] >= 3:
             single_color_hand[i] -= 3
-            new_blocks = [*blocks, _Block(_BlockType.TRIPLET, suit + i)]
+            new_blocks = [*blocks, _Block(suit + i, _BlockType.TRIPLET)]
             new_combination = HandDivider._decompose_single_color_hand_without_pair(
                 single_color_hand,
                 new_blocks,
                 i + 1,
                 suit,
+                remaining - 3,
             )
             combinations.extend(new_combination)
             single_color_hand[i] += 3
@@ -206,10 +212,10 @@ def _decompose_honors_hand(honors_hand: list[int]) -> list[_Block]:
                 case 2:
                     if has_pair:
                         return []
-                    blocks.append(_Block(_BlockType.PAIR, 27 + i))
+                    blocks.append(_Block(27 + i, _BlockType.PAIR))
                     has_pair = True
                 case 3:
-                    blocks.append(_Block(_BlockType.TRIPLET, 27 + i))
+                    blocks.append(_Block(27 + i, _BlockType.TRIPLET))
                 case _:
                     return []
 

tests/hand_calculating/tests_hand_dividing.py

@@ -102,7 +102,7 @@ def test_fix_not_correct_kan_handling() -> None:
     ids=["int", "str", "float", "None"],
 )
 def test_block_eq_with_non_block_returns_not_implemented(other: object) -> None:
-    block = _Block(_BlockType.TRIPLET, _string_to_34_tile(man="1"))
+    block = _Block(tile_34=_string_to_34_tile(man="1"), ty=_BlockType.TRIPLET)
     assert block.__eq__(other) is NotImplemented
 
 
@@ -112,7 +112,7 @@ def test_block_eq_with_non_block_returns_not_implemented(other: object) -> None:
     ids=["int", "str", "float", "None"],
 )
 def test_block_lt_with_non_block_returns_not_implemented(other: object) -> None:
-    block = _Block(_BlockType.TRIPLET, _string_to_34_tile(man="1"))
+    block = _Block(tile_34=_string_to_34_tile(man="1"), ty=_BlockType.TRIPLET)
     assert block.__lt__(other) is NotImplemented