pymdownx-mahjong 1.0.0__tar.gz → 1.1.0__tar.gz

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymdownx-mahjong
-Version: 1.0.0
+Version: 1.1.0
 Summary: Python Markdown extension to render and stylize Mahjong tiles.
 Project-URL: Homepage, https://github.com/tylernguyen/pymdownx-mahjong
 Project-URL: Documentation, https://github.com/tylernguyen/pymdownx-mahjong
@@ -35,9 +35,15 @@ Requires-Dist: mkdocs-material>=9.0; extra == 'mkdocs'
 Requires-Dist: mkdocs>=1.4; extra == 'mkdocs'
 Description-Content-Type: text/markdown
 
+![PyPI - Version](https://img.shields.io/pypi/v/pymdownx-mahjong)
+
 # PyMdown Mahjong
 
-Extensions for [Python Markdown](https://python-markdown.github.io) that aids writing Mahjong content
+[Python Markdown](https://python-markdown.github.io) extension to render and stylize Mahjong tiles. Designed for use with [MkDocs](https://github.com/mkdocs/mkdocs) and [Zensical](https://github.com/zensical/zensical).
+
+## Documentation
+
+Demo and documentation can be found at [https://tylernguyen.github.io/pymdownx-mahjong/](https://tylernguyen.github.io/pymdownx-mahjong/).
 
 ## License
 

pymdownx_mahjong-1.1.0/README.md

@@ -0,0 +1,13 @@
+![PyPI - Version](https://img.shields.io/pypi/v/pymdownx-mahjong)
+
+# PyMdown Mahjong
+
+[Python Markdown](https://python-markdown.github.io) extension to render and stylize Mahjong tiles. Designed for use with [MkDocs](https://github.com/mkdocs/mkdocs) and [Zensical](https://github.com/zensical/zensical).
+
+## Documentation
+
+Demo and documentation can be found at [https://tylernguyen.github.io/pymdownx-mahjong/](https://tylernguyen.github.io/pymdownx-mahjong/).
+
+## License
+
+License is Creative Commons Attribution-NonCommercial 4.0 International.  See [LICENSE](https://github.com/tylernguyen/pymdownx-mahjong/blob/main/LICENSE).

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.1.0}/pymdownx_mahjong/__init__.py

@@ -20,4 +20,4 @@ __all__ = [
     "superfences_validator",
 ]
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"

pymdownx_mahjong-1.1.0/pymdownx_mahjong/assets/README.md

@@ -0,0 +1,3 @@
+Original assets by https://github.com/FluffyStuff/riichi-mahjong-tiles, available in the public domain.
+
+Some assets have been recolored, tweaks, minified, or otherwise modified.

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.1.0}/pymdownx_mahjong/css/mahjong.css

@@ -23,7 +23,7 @@
     --mahjong-error-border: #dc2626;
     --mahjong-error-color: #fca5a5;
     --mahjong-tile-bg: #1e1e1e;
-    --mahjong-tile-border: #9a9a8a;
+    --mahjong-tile-border: #47473e;
     --mahjong-tile-shadow: rgba(0, 0, 0, 0.3);
 }
 
@@ -48,7 +48,7 @@
     display: contents;
 }
 
-/* Main container */
+/* NOTE Main container */
 .mahjong-hand {
     display: block;
     margin: 1em 0;
@@ -58,24 +58,24 @@
     border-radius: 4px;
 }
 
-/* Override MkDocs Material theme figure margins */
+/* NOTE Override MkDocs Material/Zensical theme figure margins */
 .md-typeset .mahjong-hand {
     margin-left: 1rem;
 }
 
-/* Hand row - contains left (tiles/melds), draw, and right (dora) sections */
+/* NOTE Hand row - contains left (tiles/melds), draw, and right (dora) sections */
 .mahjong-hand-row {
     display: flex;
     flex-wrap: nowrap;
     align-items: flex-end;
 }
 
-/* Left section - closed tiles and melds */
+/* NOTE Left section - closed tiles and melds */
 .mahjong-hand-left {
     flex: 0 0 auto;
 }
 
-/* Draw tile section - separated from main hand */
+/* NOTE Draw tile section */
 .mahjong-hand-draw {
     flex: 0 0 auto;
     margin-left: calc(var(--mahjong-meld-gap) * 0.75);
@@ -96,13 +96,13 @@
     pointer-events: none;
 }
 
-/* Melds section - after draw tile */
+/* NOTE Melds section - after draw tile */
 .mahjong-hand-melds {
     flex: 0 0 auto;
     margin-left: calc(var(--mahjong-meld-gap) * 0.75);
 }
 
-/* Tiles container - flexbox layout */
+/* NOTE Tiles container - flexbox layout */
 .mahjong-tiles {
     display: flex;
     flex-wrap: wrap;
@@ -110,7 +110,7 @@
     gap: var(--mahjong-tile-gap);
 }
 
-/* Individual tile - styled like physical riichi tiles */
+/* NOTE Individual tile - styled like physical riichi tiles */
 .mahjong-tile {
     display: inline-flex;
     align-items: center;
@@ -122,9 +122,6 @@
     background: var(--mahjong-tile-bg);
     border: 2px solid var(--mahjong-tile-border);
     border-radius: 6px;
-    box-shadow:
-        1px 2px 3px var(--mahjong-tile-shadow),
-        inset 0 1px 0 rgba(255, 255, 255, 0.3);
     padding: 2px;
     box-sizing: border-box;
     position: relative;
@@ -144,6 +141,8 @@
 /* Rotated tile (called from another player) */
 .mahjong-tile-rotated {
     transform: rotate(90deg);
+    will-change: transform;
+    backface-visibility: hidden;
     margin-left: calc(var(--mahjong-tile-gap) * 6);
     margin-right: calc(var(--mahjong-tile-gap) * 6);
     position: relative;

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.1.0}/pymdownx_mahjong/inline.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Final
 
 from markdown.inlinepatterns import InlineProcessor
 
@@ -17,7 +17,7 @@ if TYPE_CHECKING:
 # Pattern matches :123m:, :1z:, :0m: (red dora), etc.
 # Must be valid MPSZ: one or more groups of digits followed by m/p/s/z
 # Examples: :1m:, :123p:, :5z:, :0s:, :123m456p:
-INLINE_TILE_PATTERN = r":([0-9]+[mpsz])+:"
+INLINE_TILE_PATTERN: Final[str] = r":([0-9]+[mpsz])+:"
 
 
 class MahjongInlineProcessor(InlineProcessor):

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.1.0}/pymdownx_mahjong/parser.py

@@ -3,8 +3,10 @@
 from __future__ import annotations
 
 import re
+from collections import Counter
 from dataclasses import dataclass, field
 from enum import Enum
+from typing import Final, Pattern
 
 from .tiles import TileInfo, get_tile_info, is_valid_tile
 
@@ -127,11 +129,11 @@ class MahjongParser:
     """
 
     # Pattern for a group of numbers followed by a suit
-    TILE_GROUP_PATTERN = re.compile(r"([0-9]+)([mpsz])")
+    TILE_GROUP_PATTERN: Final[Pattern[str]] = re.compile(r"([0-9]+)([mpsz])")
 
     # Pattern for melds: (tiles<) or [tiles] with optional source marker inside brackets
     # For added kan, use + to mark the added tile: (111+1m<)
-    MELD_PATTERN = re.compile(r"(\[|\()([0-9]+)(\+)?([0-9])?([mpsz])([<^>])?(\]|\))")
+    MELD_PATTERN: Final[Pattern[str]] = re.compile(r"(\[|\()([0-9]+)(\+)?([0-9])?([mpsz])([<^>])?(\]|\))")
 
     def __init__(self) -> None:
         self.errors: list[str] = []
@@ -163,6 +165,9 @@ class MahjongParser:
         # Parse closed tiles
         hand.closed_tiles = self._parse_tiles(closed_part)
 
+        # Validate tile counts (max 4 of each tile type)
+        self._validate_tile_counts(hand)
+
         if self.errors:
             raise ParseError("; ".join(self.errors))
 
@@ -336,6 +341,32 @@ class MahjongParser:
 
         return numbers[1] == numbers[0] + 1 and numbers[2] == numbers[1] + 1
 
+    def _validate_tile_counts(self, hand: Hand) -> None:
+        """Validate that no tile appears more than 4 times.
+
+        In Mahjong, there are exactly 4 copies of each tile type.
+        Having more than 4 of the same tile is invalid.
+
+        Args:
+            hand: The Hand object to validate
+        """
+        # Count all tiles including melds
+        # Note: Red 5 (0) and regular 5 are different tiles, so we count them separately
+        all_tiles = list(hand.closed_tiles)
+        for meld in hand.melds:
+            all_tiles.extend(meld.tiles)
+        if hand.draw_tile:
+            all_tiles.append(hand.draw_tile)
+
+        counts = Counter((t.suit, t.number) for t in all_tiles)
+
+        for (suit, number), count in counts.items():
+            if count > 4:
+                tile_notation = f"{number}{suit}"
+                self.errors.append(
+                    f"Invalid tile count: {tile_notation} appears {count} times (max 4)"
+                )
+
 
 def parse_hand(notation: str) -> Hand:
     """Convenience function to parse a hand notation.

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.1.0}/pymdownx_mahjong/renderer.py

@@ -2,23 +2,47 @@
 
 from __future__ import annotations
 
+import functools
 import html
 import importlib.resources
 import re
 from pathlib import Path
+from typing import Final, Pattern
 
 from .parser import Hand, Meld, MeldType, Tile
 from .tiles import TileInfo, get_special_tile
 
 # Pre-compiled regex patterns for SVG processing
-_RE_XML_DECL = re.compile(r"<\?xml[^?]*\?>")
-_RE_SODIPODI_SELF = re.compile(r"<sodipodi:namedview[^>]*/>")
-_RE_SODIPODI_FULL = re.compile(r"<sodipodi:namedview[^>]*>.*?</sodipodi:namedview>", re.DOTALL)
-_RE_METADATA = re.compile(r"<metadata[^>]*>.*?</metadata>", re.DOTALL)
-_RE_WIDTH = re.compile(r'width="[^"]*"')
-_RE_HEIGHT = re.compile(r'height="[^"]*"')
+_RE_XML_DECL: Final[Pattern[str]] = re.compile(r"<\?xml[^?]*\?>")
+_RE_SODIPODI_SELF: Final[Pattern[str]] = re.compile(r"<sodipodi:namedview[^>]*/>")
+_RE_SODIPODI_FULL: Final[Pattern[str]] = re.compile(r"<sodipodi:namedview[^>]*>.*?</sodipodi:namedview>", re.DOTALL)
+_RE_METADATA: Final[Pattern[str]] = re.compile(r"<metadata[^>]*>.*?</metadata>", re.DOTALL)
+_RE_WIDTH: Final[Pattern[str]] = re.compile(r'width="[^"]*"')
+_RE_HEIGHT: Final[Pattern[str]] = re.compile(r'height="[^"]*"')
 # Pattern to find IDs in SVGs
-_RE_ID = re.compile(r'id="([^"]+)"')
+_RE_ID: Final[Pattern[str]] = re.compile(r'id="([^"]+)"')
+
+
+@functools.lru_cache(maxsize=128)
+def _load_svg_from_package(asset_name: str, theme: str) -> str:
+    """Load SVG content from package resources with caching.
+
+    This is a module-level cached function to avoid repeated file I/O
+    for the same tile assets across multiple renderer instances.
+
+    Args:
+        asset_name: Name of the asset (e.g., '1m', 'back')
+        theme: Theme to load ('light' or 'dark')
+
+    Returns:
+        Raw SVG content string
+
+    Raises:
+        FileNotFoundError: If the asset doesn't exist
+    """
+    assets = importlib.resources.files("pymdownx_mahjong") / "assets" / theme
+    svg_file = assets / f"{asset_name}.svg"
+    return svg_file.read_text(encoding="utf-8")
 
 
 class MahjongRenderer:
@@ -62,7 +86,6 @@ class MahjongRenderer:
         self.show_labels = show_labels
         self.inline_svg = inline_svg
         self.assets_path = Path(assets_path) if assets_path else None
-        self._svg_cache: dict[tuple[str, str], str] = {}
         self._svg_id_counter = 0
 
     def render(
@@ -290,17 +313,12 @@ class MahjongRenderer:
             SVG content string with unique IDs
         """
         theme = theme or (self.theme if self.theme != "auto" else "light")
-        cache_key = (theme, info.asset_name)
 
-        # Cache raw loaded SVG content (before ID uniquification)
-        if cache_key not in self._svg_cache:
-            svg_content = self._load_svg(info, theme)
-            # Process but don't add unique IDs yet - cache the base processed version
-            svg_content = self._process_svg(svg_content, unique_prefix=None)
-            self._svg_cache[cache_key] = svg_content
+        # Load and process SVG (package assets use module-level LRU cache)
+        svg_content = self._load_svg(info, theme)
+        svg_content = self._process_svg(svg_content)
 
-        # Get cached SVG and make IDs unique for this instance
-        svg_content = self._svg_cache[cache_key]
+        # Make IDs unique for this instance
         self._svg_id_counter += 1
         return self._make_ids_unique(svg_content, f"mj{self._svg_id_counter}_")
 
@@ -342,32 +360,28 @@ class MahjongRenderer:
         """
         theme = theme or (self.theme if self.theme != "auto" else "light")
 
-        # Try custom assets path first
+        # Try custom assets path first (not cached since it's user-specific)
         if self.assets_path:
             svg_path = self.assets_path / theme / f"{info.asset_name}.svg"
             if svg_path.exists():
                 return svg_path.read_text(encoding="utf-8")
 
-        # Fall back to package assets
+        # Fall back to package assets (uses module-level LRU cache)
         try:
-            assets = importlib.resources.files("pymdownx_mahjong") / "assets" / theme
-            svg_file = assets / f"{info.asset_name}.svg"
-            return svg_file.read_text(encoding="utf-8")
+            return _load_svg_from_package(info.asset_name, theme)
         except (FileNotFoundError, TypeError):
             # Return a placeholder SVG
             return self._placeholder_svg(info)
 
-    def _process_svg(self, svg_content: str, unique_prefix: str | None = None) -> str:
+    def _process_svg(self, svg_content: str) -> str:
         """Process SVG content for inline use.
 
         - Removes XML declaration
         - Removes unnecessary metadata
         - Adds sizing attributes
-        - Makes IDs unique to avoid conflicts when multiple SVGs are on the same page
 
         Args:
             svg_content: Raw SVG content
-            unique_prefix: Optional prefix to make IDs unique
 
         Returns:
             Processed SVG content
@@ -384,10 +398,6 @@ class MahjongRenderer:
         svg_content = _RE_WIDTH.sub(f'width="{self.tile_width}"', svg_content, count=1)
         svg_content = _RE_HEIGHT.sub(f'height="{self.tile_height}"', svg_content, count=1)
 
-        # Make IDs unique if prefix is provided
-        if unique_prefix:
-            svg_content = self._make_ids_unique(svg_content, unique_prefix)
-
         return svg_content.strip()
 
     def _make_ids_unique(self, svg_content: str, prefix: str) -> str:

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.1.0}/pymdownx_mahjong/tiles.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import NamedTuple
+from typing import Final, NamedTuple
 
 
 class TileInfo(NamedTuple):
@@ -12,7 +12,7 @@ class TileInfo(NamedTuple):
     display_name: str
 
 
-TILE_DATABASE: dict[tuple[str, int], TileInfo] = {
+TILE_DATABASE: Final[dict[tuple[str, int], TileInfo]] = {
     # Manzu
     ("m", 1): TileInfo("1m", "1 Man"),
     ("m", 2): TileInfo("2m", "2 Man"),
@@ -57,7 +57,7 @@ TILE_DATABASE: dict[tuple[str, int], TileInfo] = {
     ("z", 7): TileInfo("7z", "Red Dragon"),
 }
 
-SPECIAL_TILES: dict[str, TileInfo] = {
+SPECIAL_TILES: Final[dict[str, TileInfo]] = {
     "back": TileInfo("back", "Face Down"),
     "blank": TileInfo("blank", "Blank"),
     "front": TileInfo("front", "Front"),

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pymdownx-mahjong"
-version = "1.0.0"
+version = "1.1.0"
 description = "Python Markdown extension to render and stylize Mahjong tiles."
 readme = "README.md"
 license = "CC-BY-NC-4.0"

{pymdownx_mahjong-1.0.0 → pymdownx_mahjong-1.1.0}/tests/test_parser.py

@@ -239,7 +239,8 @@ class TestHandProperties:
 
     def test_hand_properties(self):
         """Test Hand helper properties."""
-        hand = parse_hand("123m456p11z (789s<) [1111z]")
+        # Using 2222z in kan instead of 1111z to avoid conflict with closed 11z
+        hand = parse_hand("123m456p11z (789s<) [2222z]")
         assert hand.meld_count == 2
         # closed: 8, chi: 3, kan: 4 = 15 total tiles
         assert hand.total_tile_count == 15
@@ -260,3 +261,76 @@ class TestHandProperties:
         all_tiles = hand.all_tiles
         assert len(all_tiles) == 14
         assert all_tiles[-1].notation == "2z"
+
+
+class TestTileCountValidation:
+    """Tests for tile count validation (max 4 of each tile type)."""
+
+    def test_five_of_same_tile_raises_error(self):
+        """Test that 5 copies of same tile raises ParseError."""
+        parser = MahjongParser()
+        with pytest.raises(ParseError) as exc_info:
+            parser.parse("11111m")
+        assert "1m appears 5 times" in str(exc_info.value)
+
+    def test_six_of_same_tile_raises_error(self):
+        """Test that 6 copies of same tile raises ParseError."""
+        parser = MahjongParser()
+        with pytest.raises(ParseError) as exc_info:
+            parser.parse("111111z")
+        assert "1z appears 6 times" in str(exc_info.value)
+
+    def test_four_of_same_tile_valid(self):
+        """Test that 4 copies of same tile is valid."""
+        hand = parse_hand("1111m")
+        assert len(hand.closed_tiles) == 4
+
+    def test_four_with_meld_total_five_raises_error(self):
+        """Test that 4 closed + 1 in meld = 5 raises error."""
+        parser = MahjongParser()
+        with pytest.raises(ParseError) as exc_info:
+            # 1m appears in closed (11m = 2) and meld (111m = 3) = 5 total
+            parser.parse("111m (111m<)")
+        assert "1m appears 6 times" in str(exc_info.value)
+
+    def test_red_dora_counted_separately(self):
+        """Test that red 5 (0) and regular 5 are counted separately."""
+        # 4 regular 5m + 1 red 5m (0m) should be valid
+        # because they are different tile types
+        hand = parse_hand("55550m")
+        assert len(hand.closed_tiles) == 5
+
+    def test_five_red_dora_raises_error(self):
+        """Test that 5 red dora of same suit raises error."""
+        parser = MahjongParser()
+        with pytest.raises(ParseError) as exc_info:
+            parser.parse("00000m")
+        assert "0m appears 5 times" in str(exc_info.value)
+
+    def test_honor_tiles_validated(self):
+        """Test that honor tiles are also validated."""
+        parser = MahjongParser()
+        with pytest.raises(ParseError) as exc_info:
+            parser.parse("77777z")  # 5 red dragons
+        assert "7z appears 5 times" in str(exc_info.value)
+
+    def test_multiple_violations_reports_all(self):
+        """Test that multiple violations are all reported."""
+        parser = MahjongParser()
+        with pytest.raises(ParseError) as exc_info:
+            parser.parse("11111m22222p")  # 5 of two different tiles
+        error_msg = str(exc_info.value)
+        assert "1m appears 5 times" in error_msg
+        assert "2p appears 5 times" in error_msg
+
+    def test_valid_complete_hand(self):
+        """Test that a normal valid hand passes validation."""
+        # Standard 14-tile hand should be valid
+        hand = parse_hand("123m456p789s11222z")
+        assert hand.total_tile_count == 14
+
+    def test_valid_hand_with_kan(self):
+        """Test that hand with kan (4 of same) is valid."""
+        hand = parse_hand("123m456p [1111z]")
+        assert len(hand.melds) == 1
+        # 1z appears in kan only = 4 times, valid