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

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: pymdownx-mahjong
-Version: 1.1.0
+Version: 1.2.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
+Project-URL: Documentation, https://tylernguyen.github.io/pymdownx-mahjong/
 Project-URL: Repository, https://github.com/tylernguyen/pymdownx-mahjong
 Project-URL: Issues, https://github.com/tylernguyen/pymdownx-mahjong/issues
 Author: Tyler Nguyen
@@ -41,7 +41,7 @@ Description-Content-Type: text/markdown
 
 [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
 
 Demo and documentation can be found at [https://tylernguyen.github.io/pymdownx-mahjong/](https://tylernguyen.github.io/pymdownx-mahjong/).
 

{pymdownx_mahjong-1.1.0 → pymdownx_mahjong-1.2.0}/README.md

@@ -4,7 +4,7 @@
 
 [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
 
 Demo and documentation can be found at [https://tylernguyen.github.io/pymdownx-mahjong/](https://tylernguyen.github.io/pymdownx-mahjong/).
 

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

@@ -4,7 +4,7 @@ from .extension import MahjongExtension, makeExtension
 from .inline import INLINE_TILE_PATTERN, MahjongInlineProcessor
 from .parser import Hand, MahjongParser, Meld, Tile
 from .renderer import MahjongRenderer
-from .superfences import superfences_formatter, superfences_validator
+from .superfences import configure_superfences, superfences_formatter, superfences_validator
 
 __all__ = [
     "MahjongExtension",
@@ -18,6 +18,7 @@ __all__ = [
     "Hand",
     "superfences_formatter",
     "superfences_validator",
+    "configure_superfences",
 ]
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"

{pymdownx_mahjong-1.1.0 → pymdownx_mahjong-1.2.0}/pymdownx_mahjong/extension.py

@@ -19,6 +19,15 @@ if TYPE_CHECKING:
     from markdown.blockparser import BlockParser
 
 
+def _to_bool(value: Any) -> bool:
+    """Convert a value to boolean, handling string 'true'/'false'."""
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        return value.lower() in ("true", "1", "yes")
+    return bool(value)
+
+
 class MahjongBlockProcessor(BlockProcessor):
     """Block processor that handles ```mahjong fenced code blocks.
 
@@ -43,10 +52,9 @@ class MahjongBlockProcessor(BlockProcessor):
         self.mj_parser = MahjongParser()
         self.renderer = MahjongRenderer(
             theme=config.get("theme", "light"),
-            css_class=config.get("css_class", "mahjong-hand"),
-            show_labels=config.get("show_labels", True),
-            inline_svg=config.get("inline_svg", True),
+            inline_svg=_to_bool(config.get("inline_svg", True)),
             assets_path=config.get("assets_path"),
+            closed_kan_style=config.get("closed_kan_style", "outer"),
         )
 
     def test(self, parent: etree.Element, block: str) -> bool:
@@ -158,13 +166,13 @@ class MahjongExtension(markdown.Extension):
             **kwargs: Configuration options
         """
         # Define configuration options with defaults
+        # Note: Use strings for boolean defaults for YAML compatibility
         self.config = {
             "theme": ["auto", "Color theme: 'light', 'dark', or 'auto'"],
-            "css_class": ["mahjong-hand", "CSS class for container"],
-            "show_labels": [True, "Show tile names as title attributes"],
-            "inline_svg": [True, "Inline SVG content vs img tags"],
+            "inline_svg": ["true", "Inline SVG content vs img tags"],
             "assets_path": ["", "Custom path to SVG assets"],
-            "enable_inline": [True, "Enable inline tile syntax (:1m:)"],
+            "enable_inline": ["true", "Enable inline tile syntax (:1m:)"],
+            "closed_kan_style": ["outer", "Closed kan style: 'outer' or 'inner'"],
         }
         super().__init__(**kwargs)
 
@@ -184,7 +192,7 @@ class MahjongExtension(markdown.Extension):
 
         # Register inline processor if enabled
         # Priority 76 to run before pymdownx.emoji (which uses 75)
-        if config.get("enable_inline", True):
+        if _to_bool(config.get("enable_inline", True)):
             inline_processor = MahjongInlineProcessor(INLINE_TILE_PATTERN, md, config)
             md.inlinePatterns.register(inline_processor, "mahjong_inline", 76)
 

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

@@ -20,6 +20,15 @@ if TYPE_CHECKING:
 INLINE_TILE_PATTERN: Final[str] = r":([0-9]+[mpsz])+:"
 
 
+def _to_bool(value: Any) -> bool:
+    """Convert a value to boolean, handling string 'true'/'false'."""
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, str):
+        return value.lower() in ("true", "1", "yes")
+    return bool(value)
+
+
 class MahjongInlineProcessor(InlineProcessor):
     """Inline processor for mahjong tile notation.
 
@@ -40,10 +49,9 @@ class MahjongInlineProcessor(InlineProcessor):
         self.parser = MahjongParser()
         self.renderer = MahjongRenderer(
             theme=config.get("theme", "auto"),
-            css_class="mahjong-inline",
-            show_labels=config.get("show_labels", True),
-            inline_svg=config.get("inline_svg", True),
+            inline_svg=_to_bool(config.get("inline_svg", True)),
             assets_path=config.get("assets_path"),
+            css_class="mahjong-inline",
         )
 
     def handleMatch(self, m: re.Match, data: str) -> tuple[str | None, int | None, int | None]:

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

@@ -50,9 +50,8 @@ class MahjongRenderer:
 
     Configuration options:
         theme: 'light', 'dark', or 'auto'
-        css_class: CSS class for the container
-        show_labels: Whether to show tile names as titles
-        inline_svg: Whether to inline SVG or use img tags
+        closed_kan_style: 'outer' (default) or 'inner'
+        inline_svg: Whether to inline SVG content (vs using img tags)
     """
 
     DEFAULT_TILE_WIDTH = 45
@@ -63,19 +62,21 @@ class MahjongRenderer:
     def __init__(
         self,
         theme: str = "light",
-        css_class: str = "mahjong-hand",
-        show_labels: bool = True,
         inline_svg: bool = True,
         assets_path: str | Path | None = None,
+        closed_kan_style: str = "outer",
+        css_class: str = "mahjong-hand",
     ) -> None:
         """Initialize the renderer.
 
         Args:
             theme: Color theme ('light', 'dark', or 'auto')
-            css_class: CSS class for the container element
-            show_labels: Show tile names as title attributes
             inline_svg: Inline SVG content vs img tags
             assets_path: Custom path to SVG assets
+            closed_kan_style: Style for closed kan back tiles:
+                'outer' (default) - back tiles on edges (back, front, front, back)
+                'inner' - back tiles in middle (front, back, back, front)
+            css_class: CSS class for container (internal use)
         """
         self.theme = theme
         self.tile_width = self.DEFAULT_TILE_WIDTH
@@ -83,9 +84,9 @@ class MahjongRenderer:
         self.tile_gap = self.DEFAULT_TILE_GAP
         self.meld_gap = self.DEFAULT_MELD_GAP
         self.css_class = css_class
-        self.show_labels = show_labels
         self.inline_svg = inline_svg
         self.assets_path = Path(assets_path) if assets_path else None
+        self.closed_kan_style = closed_kan_style
         self._svg_id_counter = 0
 
     def render(
@@ -209,7 +210,7 @@ class MahjongRenderer:
             classes.append("mahjong-tile-added")
 
         class_str = " ".join(classes)
-        title_attr = f' title="{info.display_name}"' if self.show_labels else ""
+        title_attr = f' title="{info.display_name}"'
 
         if self.inline_svg:
             svg_content = self._get_themed_svg_content(info)
@@ -271,9 +272,18 @@ class MahjongRenderer:
                 parts.append(self._render_tile(meld.tiles[2]))
         else:
             for i, tile in enumerate(meld.tiles):
-                # For closed kan, show back tiles for middle two
-                if meld.meld_type == MeldType.KAN_CLOSED and i in (1, 2):
-                    parts.append(self._render_back_tile())
+                # For closed kan, show back tiles based on style setting
+                if meld.meld_type == MeldType.KAN_CLOSED:
+                    if self.closed_kan_style == "inner":
+                        # 'inner': back tiles in middle: front, back, back, front
+                        is_back = i in (1, 2)
+                    else:
+                        # Default 'outer': back tiles on edges: back, front, front, back
+                        is_back = i in (0, 3)
+                    if is_back:
+                        parts.append(self._render_back_tile())
+                    else:
+                        parts.append(self._render_tile(tile))
                 else:
                     parts.append(self._render_tile(tile))
 

{pymdownx_mahjong-1.1.0 → pymdownx_mahjong-1.2.0}/pymdownx_mahjong/superfences.py

@@ -17,20 +17,32 @@ class _SuperfencesState:
     """Encapsulates global state for superfences integration.
 
     Uses lazy initialization to create parser/renderer on first use.
+    Allows configuration via configure() method.
     """
 
     def __init__(self) -> None:
         self._renderer: MahjongRenderer | None = None
         self._parser: MahjongParser | None = None
+        self._config: dict[str, Any] = {}
+
+    def configure(self, **kwargs: Any) -> None:
+        """Configure the superfences state.
+
+        Args:
+            **kwargs: Configuration options (theme, closed_kan_style, etc.)
+        """
+        self._config.update(kwargs)
+        # Reset renderer to apply new config
+        self._renderer = None
 
     @property
     def renderer(self) -> MahjongRenderer:
         """Get or create the renderer instance."""
         if self._renderer is None:
             self._renderer = MahjongRenderer(
-                theme="auto",
-                show_labels=True,
-                inline_svg=True,
+                theme=self._config.get("theme", "auto"),
+                inline_svg=self._config.get("inline_svg", True),
+                closed_kan_style=self._config.get("closed_kan_style", "outer"),
             )
         return self._renderer
 
@@ -46,6 +58,24 @@ class _SuperfencesState:
 _state = _SuperfencesState()
 
 
+def configure_superfences(**kwargs: Any) -> None:
+    """Configure the superfences integration.
+
+    Call this before using superfences to set options like closed_kan_style.
+
+    Example:
+        from pymdownx_mahjong import configure_superfences
+        configure_superfences(closed_kan_style='outer')
+
+    Args:
+        **kwargs: Configuration options
+            - theme: 'light', 'dark', or 'auto'
+            - closed_kan_style: 'outer' or 'inner'
+            - inline_svg: bool
+    """
+    _state.configure(**kwargs)
+
+
 def superfences_validator(
     language: str,
     inputs: dict[str, str],
@@ -65,6 +95,14 @@ def superfences_validator(
     Returns:
         True if this is a valid mahjong fence
     """
+    # Try to get config from the markdown instance's extension
+    if hasattr(md, 'registeredExtensions'):
+        for ext in md.registeredExtensions:
+            if hasattr(ext, 'config') and 'closed_kan_style' in ext.config:
+                config = {key: ext.getConfig(key) for key in ext.config}
+                _state.configure(**config)
+                break
+
     return language == "mahjong"
 
 

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pymdownx-mahjong"
-version = "1.1.0"
+version = "1.2.0"
 description = "Python Markdown extension to render and stylize Mahjong tiles."
 readme = "README.md"
 license = "CC-BY-NC-4.0"
@@ -52,7 +52,7 @@ dev = [
 
 [project.urls]
 Homepage = "https://github.com/tylernguyen/pymdownx-mahjong"
-Documentation = "https://github.com/tylernguyen/pymdownx-mahjong"
+Documentation = "https://tylernguyen.github.io/pymdownx-mahjong/"
 Repository = "https://github.com/tylernguyen/pymdownx-mahjong"
 Issues = "https://github.com/tylernguyen/pymdownx-mahjong/issues"
 

{pymdownx_mahjong-1.1.0 → pymdownx_mahjong-1.2.0}/tests/test_extension.py

@@ -109,8 +109,7 @@ invalid notation 8z9z
             extensions=["pymdownx_mahjong"],
             extension_configs={
                 "pymdownx_mahjong": {
-                    "css_class": "custom-mahjong",
-                    "show_labels": False,
+                    "theme": "dark",
                 }
             },
         )
@@ -123,7 +122,7 @@ invalid notation 8z9z
 """
         result = md.convert(source)
 
-        assert "custom-mahjong" in result
+        assert "mahjong-hand" in result
 
     def test_multiple_blocks(self):
         """Test converting multiple mahjong blocks."""
@@ -216,6 +215,6 @@ class TestMakeExtension:
         """Test makeExtension with configuration."""
         from pymdownx_mahjong import makeExtension
 
-        ext = makeExtension(theme="dark", css_class="custom-class")
+        ext = makeExtension(theme="dark", closed_kan_style="inner")
         assert ext.getConfig("theme") == "dark"
-        assert ext.getConfig("css_class") == "custom-class"
+        assert ext.getConfig("closed_kan_style") == "inner"

{pymdownx_mahjong-1.1.0 → pymdownx_mahjong-1.2.0}/tests/test_renderer.py

@@ -113,30 +113,22 @@ class TestMahjongRenderer:
 class TestRendererConfiguration:
     """Tests for renderer configuration options."""
 
-    def test_custom_css_class(self):
-        """Test custom CSS class."""
-        renderer = MahjongRenderer(css_class="custom-mahjong")
+    def test_default_css_class(self):
+        """Test default CSS class is mahjong-hand."""
+        renderer = MahjongRenderer()
         hand = parse_hand("123m")
         html = renderer.render(hand)
 
-        assert 'class="custom-mahjong"' in html
+        assert 'class="mahjong-hand"' in html
 
-    def test_show_labels_true(self):
-        """Test that tile titles are shown when show_labels is True."""
-        renderer = MahjongRenderer(show_labels=True)
+    def test_tile_titles_shown(self):
+        """Test that tile titles are always shown."""
+        renderer = MahjongRenderer()
         hand = parse_hand("1m")
         html = renderer.render(hand)
 
         assert 'title="1 Man"' in html
 
-    def test_show_labels_false(self):
-        """Test that tile titles are hidden when show_labels is False."""
-        renderer = MahjongRenderer(show_labels=False)
-        hand = parse_hand("1m")
-        html = renderer.render(hand)
-
-        assert "title=" not in html
-
     def test_inline_svg_true(self):
         """Test inline SVG mode."""
         renderer = MahjongRenderer(inline_svg=True)
@@ -174,6 +166,39 @@ class TestRendererConfiguration:
         assert 'class="mahjong-tile-light"' in html
         assert 'class="mahjong-tile-dark"' in html
 
+    def test_closed_kan_style_inner_default(self):
+        """Test that closed kan defaults to inner style (back tiles in middle)."""
+        renderer = MahjongRenderer(theme="light")
+        hand = parse_hand("[1111z]")
+        html = renderer.render(hand)
+
+        # Inner style: front, back, back, front
+        # Count back tiles - should appear in positions 1,2 (middle)
+        back_count = html.count('class="mahjong-tile mahjong-tile-back"')
+        assert back_count == 2
+
+    def test_closed_kan_style_outer(self):
+        """Test closed kan with outer style (back tiles on edges)."""
+        renderer = MahjongRenderer(theme="light", closed_kan_style="outer")
+        hand = parse_hand("[1111z]")
+        html = renderer.render(hand)
+
+        # Outer style: back, front, front, back
+        back_count = html.count('class="mahjong-tile mahjong-tile-back"')
+        assert back_count == 2
+        # Verify the style is set correctly
+        assert renderer.closed_kan_style == "outer"
+
+    def test_closed_kan_style_inner_explicit(self):
+        """Test closed kan with explicit inner style."""
+        renderer = MahjongRenderer(theme="light", closed_kan_style="inner")
+        hand = parse_hand("[1111z]")
+        html = renderer.render(hand)
+
+        assert renderer.closed_kan_style == "inner"
+        back_count = html.count('class="mahjong-tile mahjong-tile-back"')
+        assert back_count == 2
+
 
 class TestRenderTiles:
     """Tests for render_tiles method."""
@@ -225,6 +250,6 @@ class TestConvenienceFunction:
     def test_render_hand_with_kwargs(self):
         """Test render_hand with configuration kwargs."""
         hand = parse_hand("123m")
-        html = render_hand(hand, theme="dark", css_class="custom")
+        html = render_hand(hand, theme="dark")
 
-        assert 'class="custom"' in html
+        assert 'class="mahjong-hand"' in html