mkdocs2confluence 0.6.1__tar.gz → 0.6.2__tar.gz

{mkdocs2confluence-0.6.1/src/mkdocs2confluence.egg-info → mkdocs2confluence-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.6.1
+Version: 0.6.2
 Summary: Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more
 Author: Anders Hybertz
 License: GPL-3.0-or-later

{mkdocs2confluence-0.6.1 → mkdocs2confluence-0.6.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mkdocs2confluence"
-version = "0.6.1"
+version = "0.6.2"
 description = "Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more"
 readme = "README.md"
 license = { text = "GPL-3.0-or-later" }

{mkdocs2confluence-0.6.1 → mkdocs2confluence-0.6.2/src/mkdocs2confluence.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mkdocs2confluence
-Version: 0.6.1
+Version: 0.6.2
 Summary: Publish MkDocs Material pages to Confluence Cloud — admonitions, Mermaid diagrams, tabs, page properties and more
 Author: Anders Hybertz
 License: GPL-3.0-or-later

{mkdocs2confluence-0.6.1 → mkdocs2confluence-0.6.2}/src/mkdocs_to_confluence/transforms/mermaid.py

@@ -17,8 +17,10 @@ from __future__ import annotations
 import dataclasses
 import hashlib
 import sys
+import threading
 import urllib.error
 import urllib.request
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from typing import cast
 
@@ -29,6 +31,8 @@ _CACHE_DIR = Path.home() / ".cache" / "mk2conf" / "mermaid"
 DEFAULT_KROKI_URL = "https://kroki.io"
 _TIMEOUT = 30  # seconds — fail fast when Kroki is down
 _MIN_PNG_BYTES = 67  # smallest valid PNG (1×1 px) is 67 bytes
+_CACHE_LOCK = threading.Lock()
+_MAX_WORKERS = 8
 
 
 def _kroki_png(source: str, kroki_url: str) -> bytes:
@@ -58,12 +62,36 @@ def _warn(msg: str) -> None:
     print(f"  warning    {msg}", file=sys.stderr)
 
 
+def _render_one(source: str, kroki_url: str) -> Path | None:
+    """Render a single diagram to cache. Returns cache path on success, None on failure."""
+    path = _cache_path(source)
+    if path.exists():
+        print("        rendering  mermaid diagram (cached)")
+        return path
+    try:
+        print(f"        rendering  mermaid diagram via Kroki ({kroki_url})")
+        png = _kroki_png(source, kroki_url)
+        if len(png) < _MIN_PNG_BYTES:
+            raise ValueError(f"Kroki returned {len(png)} bytes (expected a valid PNG)")
+        with _CACHE_LOCK:
+            path.write_bytes(png)
+        return path
+    except urllib.error.HTTPError as exc:
+        _warn(f"mermaid diagram: Kroki returned HTTP {exc.code} {exc.reason} — falling back to code block")
+    except urllib.error.URLError as exc:
+        _warn(f"mermaid diagram: Kroki unreachable ({exc.reason}) — falling back to code block")
+    except (OSError, ValueError) as exc:
+        _warn(f"mermaid diagram: {exc} — falling back to code block")
+    return None
+
+
 def render_mermaid_diagrams(
     nodes: tuple[IRNode, ...],
     kroki_url: str = DEFAULT_KROKI_URL,
 ) -> tuple[tuple[IRNode, ...], list[Path]]:
     """Render all :class:`MermaidDiagram` nodes to PNG via Kroki.
 
+    Diagrams are rendered concurrently (up to ``_MAX_WORKERS`` threads).
     Returns the updated IR node tuple (with ``attachment_name`` set on each
     successfully rendered diagram) and a list of PNG :class:`Path` objects to
     upload as page attachments.
@@ -76,47 +104,44 @@ def render_mermaid_diagrams(
     except OSError as exc:
         _warn(f"cannot create mermaid cache dir {_CACHE_DIR}: {exc} — all diagrams will fall back to code blocks")
 
+    # Collect all unresolved MermaidDiagram nodes (deduplicated by source).
+    diagrams: list[MermaidDiagram] = []
+    seen_sources: set[str] = set()
+    for top_node in nodes:
+        for node in walk(top_node):
+            if isinstance(node, MermaidDiagram) and node.attachment_name is None:
+                if node.source not in seen_sources:
+                    diagrams.append(node)
+                    seen_sources.add(node.source)
+
+    if not diagrams:
+        return nodes, []
+
+    # Render all diagrams concurrently, preserving source → result mapping.
+    source_to_path: dict[str, Path | None] = {}
+    with ThreadPoolExecutor(max_workers=min(_MAX_WORKERS, len(diagrams))) as pool:
+        future_to_source = {
+            pool.submit(_render_one, d.source, kroki_url): d.source for d in diagrams
+        }
+        for future in as_completed(future_to_source):
+            source = future_to_source[future]
+            source_to_path[source] = future.result()
+
+    # Build replacements and attachments from results.
     attachments: list[Path] = []
     replacements: dict[int, IRNode] = {}
     seen_paths: set[Path] = set()
 
     for top_node in nodes:
         for node in walk(top_node):
-            if not isinstance(node, MermaidDiagram):
+            if not isinstance(node, MermaidDiagram) or node.attachment_name is not None:
                 continue
-            if node.attachment_name is not None:
-                continue  # already resolved
-
-            path = _cache_path(node.source)
-            if not path.exists():
-                try:
-                    print(f"        rendering  mermaid diagram via Kroki ({kroki_url})")
-                    png = _kroki_png(node.source, kroki_url)
-                    if len(png) < _MIN_PNG_BYTES:
-                        raise ValueError(f"Kroki returned {len(png)} bytes (expected a valid PNG)")
-                    path.write_bytes(png)
-                except urllib.error.HTTPError as exc:
-                    _warn(
-                        f"mermaid diagram: Kroki returned HTTP {exc.code} {exc.reason}"
-                        " — falling back to code block"
-                    )
-                    continue
-                except urllib.error.URLError as exc:
-                    _warn(
-                        f"mermaid diagram: Kroki unreachable ({exc.reason})"
-                        " — falling back to code block"
-                    )
-                    continue
-                except (OSError, ValueError) as exc:
-                    _warn(f"mermaid diagram: {exc} — falling back to code block")
-                    continue
-            else:
-                print("        rendering  mermaid diagram (cached)")
-
+            path = source_to_path.get(node.source)
+            if path is None:
+                continue  # render failed — leave as code block
             if path not in seen_paths:
                 attachments.append(path)
                 seen_paths.add(path)
-
             replacements[id(node)] = dataclasses.replace(
                 node, attachment_name=path.name, local_path=path
             )

{mkdocs2confluence-0.6.1 → mkdocs2confluence-0.6.2}/tests/test_mermaid.py

@@ -197,3 +197,75 @@ def test_render_mermaid_none_skips(tmp_path):
     mock_fetch.assert_not_called()
     assert len(attachments) == 0
     assert updated_nodes[0].attachment_name == "already_set.png"  # type: ignore[union-attr]
+
+
+# ── Parallel rendering ────────────────────────────────────────────────────────
+
+
+def test_render_multiple_diagrams_concurrently(tmp_path):
+    """Multiple distinct diagrams are all rendered (parallel path)."""
+    sources = [f"graph TD\n    A{i} --> B{i}\n" for i in range(4)]
+    nodes = tuple(MermaidDiagram(source=s) for s in sources)
+
+    with patch("mkdocs_to_confluence.transforms.mermaid._CACHE_DIR", tmp_path), \
+         patch("mkdocs_to_confluence.transforms.mermaid._kroki_png", return_value=_FAKE_PNG):
+        updated, attachments = render_mermaid_diagrams(nodes)
+
+    assert len(attachments) == 4
+    for node in updated:
+        assert isinstance(node, MermaidDiagram)
+        assert node.attachment_name is not None
+
+
+def test_render_one_failure_does_not_block_others(tmp_path):
+    """If one diagram fails, the rest still render successfully."""
+    import urllib.error
+
+    good_source = "graph TD\n    A --> B\n"
+    bad_source = "graph TD\n    X --> Y\n"
+    nodes = (MermaidDiagram(source=good_source), MermaidDiagram(source=bad_source))
+
+    def fake_kroki(source: str, url: str) -> bytes:
+        if source == bad_source:
+            raise urllib.error.URLError("timeout")
+        return _FAKE_PNG
+
+    with patch("mkdocs_to_confluence.transforms.mermaid._CACHE_DIR", tmp_path), \
+         patch("mkdocs_to_confluence.transforms.mermaid._kroki_png", side_effect=fake_kroki):
+        updated, attachments = render_mermaid_diagrams(nodes)
+
+    # One attachment for the successful diagram
+    assert len(attachments) == 1
+    # Good diagram got attachment_name; bad one stayed as code-block fallback
+    assert updated[0].attachment_name is not None  # type: ignore[union-attr]
+    assert updated[1].attachment_name is None  # type: ignore[union-attr]
+
+
+def test_render_one_cached(tmp_path):
+    """_render_one returns the cache path immediately for cached diagrams."""
+    from mkdocs_to_confluence.transforms.mermaid import _render_one, _cache_path
+
+    path = tmp_path / "mermaid_cached.png"
+    path.write_bytes(_FAKE_PNG)
+
+    with patch("mkdocs_to_confluence.transforms.mermaid._CACHE_DIR", tmp_path), \
+         patch("mkdocs_to_confluence.transforms.mermaid._cache_path", return_value=path), \
+         patch("mkdocs_to_confluence.transforms.mermaid._kroki_png") as mock_fetch:
+        result = _render_one(_SAMPLE_SOURCE, "https://kroki.io")
+
+    mock_fetch.assert_not_called()
+    assert result == path
+
+
+def test_render_one_network_failure_returns_none(tmp_path):
+    """_render_one returns None on network failure."""
+    import urllib.error
+    from mkdocs_to_confluence.transforms.mermaid import _render_one
+
+    with patch("mkdocs_to_confluence.transforms.mermaid._CACHE_DIR", tmp_path), \
+         patch("mkdocs_to_confluence.transforms.mermaid._kroki_png",
+               side_effect=urllib.error.URLError("connection refused")):
+        result = _render_one(_SAMPLE_SOURCE, "https://kroki.io")
+
+    assert result is None
+