markdocx 3.0.0__tar.gz → 4.0.0__tar.gz

{markdocx-3.0.0 → markdocx-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdocx
-Version: 3.0.0
+Version: 4.0.0
 Summary: Convert AI-generated Markdown textbooks to polished DOCX with native math equations and syntax-highlighted code
 License-Expression: MIT
 License-File: LICENSE

{markdocx-3.0.0 → markdocx-4.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "markdocx"
-version = "3.0.0"
+version = "4.0.0"
 description = "Convert AI-generated Markdown textbooks to polished DOCX with native math equations and syntax-highlighted code"
 readme = "README.md"
 license = "MIT"

{markdocx-3.0.0 → markdocx-4.0.0}/src/markdocx/__init__.py

@@ -7,5 +7,5 @@ with native math equations and syntax-highlighted code.
 
 from markdocx.core import convert_file, convert_directory
 
-__version__ = "3.0.0"
+__version__ = "4.0.0"
 __all__ = ["convert_file", "convert_directory"]

{markdocx-3.0.0 → markdocx-4.0.0}/src/markdocx/diagram_renderer.py

@@ -731,42 +731,76 @@ def _render_workflow(code: str):
     n = len(steps)
     is_vertical = direction.startswith("v")
 
-    # Calculate figure size
+    # ── Measure text to compute adaptive box sizes ──────────────
+    def _wrap_text(text, max_chars):
+        """Wrap text into multiple lines if too long."""
+        if len(text) <= max_chars:
+            return text
+        words = text.split()
+        lines = []
+        current = ""
+        for word in words:
+            test = f"{current} {word}".strip() if current else word
+            if len(test) <= max_chars:
+                current = test
+            else:
+                if current:
+                    lines.append(current)
+                current = word
+        if current:
+            lines.append(current)
+        return "\n".join(lines) if lines else text
+
+    # Find longest text to size boxes appropriately
+    max_text_len = max(len(s.get("text", "")) for s in steps)
+
     if is_vertical:
-        fig_w = max(5, 6)
-        fig_h = max(3, n * 1.5 + 1.5)
+        # Vertical: boxes can be wide
+        max_chars_per_line = 30
+        box_w = max(3.0, min(6.0, max_text_len * 0.18 + 1.0))
+        box_h = 0.9
+        fontsize_normal = 12
+        fontsize_decision = 11
+        spacing_y = 1.8  # center-to-center vertical distance
+
+        fig_w = max(6, box_w + 3.0)
+        fig_h = max(4, n * spacing_y + 2.0)
     else:
-        fig_w = max(4, n * 2.5 + 1)
-        fig_h = max(3, 4)
+        # Horizontal: limited width per box, allow wrapping
+        max_chars_per_line = 14
+        box_w = max(2.2, min(3.5, max_text_len * 0.15 + 0.8))
+        box_h = 1.0
+        fontsize_normal = 11
+        fontsize_decision = 10
+        spacing_x = box_w + 1.0  # center-to-center horizontal distance
+
+        fig_w = max(6, n * spacing_x + 2.0)
+        fig_h = max(3.5, 4.0)
 
     fig, ax = plt.subplots(figsize=(fig_w, fig_h))
-    ax.set_aspect("equal")
+    # Do NOT use set_aspect("equal") — it distorts boxes
     ax.axis("off")
 
-    # Shape dimensions
-    box_w = 2.0
-    box_h = 0.7
-    spacing = 1.5  # center-to-center distance
-
-    # Calculate positions
+    # ── Calculate positions ─────────────────────────────────────
     positions = []
     for i in range(n):
         if is_vertical:
             x = fig_w / 2
-            y = fig_h - 1.0 - i * spacing
+            y = fig_h - 1.5 - i * spacing_y
         else:
-            x = 1.5 + i * (box_w + 0.8)
+            x = 1.5 + i * spacing_x
             y = fig_h / 2
         positions.append((x, y))
 
     # Adjust axes limits
     all_x = [p[0] for p in positions]
     all_y = [p[1] for p in positions]
-    margin = 2.0
-    ax.set_xlim(min(all_x) - margin, max(all_x) + margin)
-    ax.set_ylim(min(all_y) - margin, max(all_y) + margin)
+    pad_x = box_w / 2 + 1.5
+    pad_y = box_h + 1.5
+    ax.set_xlim(min(all_x) - pad_x, max(all_x) + pad_x)
+    ax.set_ylim(min(all_y) - pad_y, max(all_y) + pad_y)
 
-    # Color scheme for step types
+    # ── Color scheme ────────────────────────────────────────────
     type_colors = {
         "terminal": ("#34A853", "white"),
         "start": ("#34A853", "white"),
@@ -776,17 +810,21 @@ def _render_workflow(code: str):
         "io": ("#7B61FF", "white"),
     }
 
-    # Draw steps
+    # ── Draw steps ──────────────────────────────────────────────
     for i, step in enumerate(steps):
         x, y = positions[i]
         step_type = step.get("type", "process")
-        text = step.get("text", "")
+        raw_text = step.get("text", "")
+        display_text = _wrap_text(raw_text, max_chars_per_line)
         bg_color, text_color = type_colors.get(step_type, ("#4285F4", "white"))
 
+        # Count lines for height adjustment
+        n_lines = display_text.count("\n") + 1
+        effective_h = max(box_h, box_h + (n_lines - 1) * 0.3)
+
         if step_type == "decision":
-            # Diamond shape
-            diamond_w = box_w * 0.7
-            diamond_h = box_h * 1.2
+            diamond_w = box_w * 0.55
+            diamond_h = effective_h * 0.9
             diamond = plt.Polygon([
                 (x, y + diamond_h),
                 (x + diamond_w, y),
@@ -795,68 +833,82 @@ def _render_workflow(code: str):
             ], closed=True, facecolor=bg_color, edgecolor="#333333",
                 linewidth=1.5, zorder=3)
             ax.add_patch(diamond)
-            ax.text(x, y, text, ha="center", va="center",
-                    fontsize=9, fontweight="bold", color=text_color, zorder=4,
-                    wrap=True)
+            ax.text(x, y, display_text, ha="center", va="center",
+                    fontsize=fontsize_decision, fontweight="bold",
+                    color=text_color, zorder=4, linespacing=1.2)
 
         elif step_type in ("terminal", "start", "end"):
-            # Rounded rectangle (stadium shape)
             patch = FancyBboxPatch(
-                (x - box_w / 2, y - box_h / 2), box_w, box_h,
+                (x - box_w / 2, y - effective_h / 2), box_w, effective_h,
                 boxstyle="round,pad=0.15", facecolor=bg_color,
                 edgecolor="#333333", linewidth=1.5, zorder=3
             )
             ax.add_patch(patch)
-            ax.text(x, y, text, ha="center", va="center",
-                    fontsize=10, fontweight="bold", color=text_color, zorder=4)
+            ax.text(x, y, display_text, ha="center", va="center",
+                    fontsize=fontsize_normal, fontweight="bold",
+                    color=text_color, zorder=4, linespacing=1.2)
 
         elif step_type == "io":
-            # Parallelogram
-            skew = 0.2
+            skew = 0.25
             pgram = plt.Polygon([
-                (x - box_w / 2 + skew, y + box_h / 2),
-                (x + box_w / 2 + skew, y + box_h / 2),
-                (x + box_w / 2 - skew, y - box_h / 2),
-                (x - box_w / 2 - skew, y - box_h / 2)
+                (x - box_w / 2 + skew, y + effective_h / 2),
+                (x + box_w / 2 + skew, y + effective_h / 2),
+                (x + box_w / 2 - skew, y - effective_h / 2),
+                (x - box_w / 2 - skew, y - effective_h / 2)
             ], closed=True, facecolor=bg_color, edgecolor="#333333",
                 linewidth=1.5, zorder=3)
             ax.add_patch(pgram)
-            ax.text(x, y, text, ha="center", va="center",
-                    fontsize=10, fontweight="bold", color=text_color, zorder=4)
+            ax.text(x, y, display_text, ha="center", va="center",
+                    fontsize=fontsize_normal, fontweight="bold",
+                    color=text_color, zorder=4, linespacing=1.2)
 
         else:  # process
-            # Rectangle
             patch = FancyBboxPatch(
-                (x - box_w / 2, y - box_h / 2), box_w, box_h,
+                (x - box_w / 2, y - effective_h / 2), box_w, effective_h,
                 boxstyle="square,pad=0.1", facecolor=bg_color,
                 edgecolor="#333333", linewidth=1.5, zorder=3
             )
             ax.add_patch(patch)
-            ax.text(x, y, text, ha="center", va="center",
-                    fontsize=10, fontweight="bold", color=text_color, zorder=4)
+            ax.text(x, y, display_text, ha="center", va="center",
+                    fontsize=fontsize_normal, fontweight="bold",
+                    color=text_color, zorder=4, linespacing=1.2)
 
-    # Draw arrows between steps
+    # ── Draw arrows between steps ───────────────────────────────
     for i in range(n - 1):
         x1, y1 = positions[i]
         x2, y2 = positions[i + 1]
 
-        step_type = steps[i].get("type", "process")
+        cur_type = steps[i].get("type", "process")
+        next_type = steps[i + 1].get("type", "process")
+
+        # Recompute effective heights for arrow endpoints
+        cur_text = _wrap_text(steps[i].get("text", ""), max_chars_per_line)
+        next_text = _wrap_text(steps[i + 1].get("text", ""), max_chars_per_line)
+        cur_h = max(box_h, box_h + (cur_text.count("\n")) * 0.3)
+        next_h = max(box_h, box_h + (next_text.count("\n")) * 0.3)
 
         if is_vertical:
-            start_y = y1 - box_h / 2 - 0.05
-            end_y = y2 + box_h / 2 + 0.05
-            if step_type == "decision":
-                start_y = y1 - box_h * 1.2 - 0.05
-            next_type = steps[i + 1].get("type", "process")
+            if cur_type == "decision":
+                start_y = y1 - cur_h * 0.9 - 0.08
+            else:
+                start_y = y1 - cur_h / 2 - 0.08
             if next_type == "decision":
-                end_y = y2 + box_h * 1.2 + 0.05
+                end_y = y2 + next_h * 0.9 + 0.08
+            else:
+                end_y = y2 + next_h / 2 + 0.08
             ax.annotate("", xy=(x2, end_y), xytext=(x1, start_y),
                         arrowprops=dict(arrowstyle="-|>", color="#555555",
                                         lw=2, mutation_scale=15),
                         zorder=2)
         else:
-            start_x = x1 + box_w / 2 + 0.05
-            end_x = x2 - box_w / 2 - 0.05
+            if cur_type == "decision":
+                start_x = x1 + box_w * 0.55 + 0.08
+            else:
+                start_x = x1 + box_w / 2 + 0.08
+            if next_type == "decision":
+                end_x = x2 - box_w * 0.55 - 0.08
+            else:
+                end_x = x2 - box_w / 2 - 0.08
             ax.annotate("", xy=(end_x, y2), xytext=(start_x, y1),
                         arrowprops=dict(arrowstyle="-|>", color="#555555",
                                         lw=2, mutation_scale=15),

{markdocx-3.0.0 → markdocx-4.0.0}/uv.lock

@@ -158,7 +158,7 @@ wheels = [
 
 [[package]]
 name = "markdocx"
-version = "2.0.0"
+version = "3.0.0"
 source = { editable = "." }
 dependencies = [
     { name = "latex2mathml" },