diagram2code 0.1.2__tar.gz

diagram2code-0.1.2/PKG-INFO

@@ -0,0 +1,215 @@
+Metadata-Version: 2.4
+Name: diagram2code
+Version: 0.1.2
+Summary: Convert simple diagram images into runnable code (matplotlib/graphviz).
+Author: Kazi Samiul Islam
+License: MIT
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: opencv-python>=4.8
+Requires-Dist: numpy>=1.26
+Requires-Dist: matplotlib>=3.8
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.5.0; extra == "dev"
+Provides-Extra: ocr
+Requires-Dist: pytesseract>=0.3.10; extra == "ocr"
+
+# diagram2code
+
+Convert simple flowchart-style diagrams into runnable Python programs.
+
+`diagram2code` takes a diagram image (rectangular steps + arrows), detects the flow, and generates:
+
+- a graph representation (`graph.json`)
+- a runnable Python program (`generated_program.py`)
+- optional debug visualizations (`debug_nodes.png`, `debug_arrows.png`)
+- an optional exportable bundle (`--export`)
+
+> This project is designed for **learning, prototyping, and experimentation**, not for production-grade diagram parsing. :contentReference[oaicite:1]{index=1}
+
+---
+
+## Table of Contents
+
+1. [Installation](#installation)
+2. [Quick Start](#quick-start)
+3. [Using Labels](#using-labels)
+4. [Export Bundle](#export-bundle)
+5. [Generated Files](#generated-files)
+6. [Examples](#examples)
+7. [Limitations](#limitations)
+
+---
+
+## Installation
+
+Clone the repo and install in editable mode:
+
+```bash
+git clone https://github.com/Nimil785477/diagram2code.git
+cd diagram2code
+
+python -m venv .venv
+```
+Activate the environment
+```
+# Linux / macOS
+source .venv/bin/activate
+
+# Windows (PowerShell)
+.\.venv\Scripts\Activate.ps1
+```
+Install:
+```
+pip install -e .
+```
+### Basic (no OCR)
+```bash
+pip install diagram2code
+```
+With OCR support(optional)
+```bash
+pip install diagram2code[ocr]
+```
+You must also install Tesseract OCR on your system:
+- Windows: https://github.com/UB-Mannheim/tesseract/wiki
+- macOS:
+```bash
+brew install tesseract
+```
+- Ubuntu/Debian:
+```bash
+sudo apt install tesseract-ocr
+```
+Then run:
+```bash
+diagram2code image.png --extract-labels
+```
+
+This matches exactly what your code already does ✔️
+
+---
+
+## 3️⃣ (Optional but recommended) Add a runtime hint
+
+You already handle this well, but one tiny UX improvement:
+
+In `cli.py`, after `--extract-labels` failure, you could optionally print:
+
+```python
+safe_print("Hint: install OCR support with `pip install diagram2code[ocr]` and install Tesseract.")
+```
+
+## Quick Start
+Run diagram2code on a simple diagram:
+```
+python -m diagram2code.cli examples/simple/diagram.png --out outputs
+```
+This will write outputs (see Generated Files)
+
+## Using Labels
+You can provide custom labels for nodes using a JSON file
+
+Example labels.json
+```
+{
+  "0": "Step_1_Load_Data",
+  "1": "Step_2_Train_Model"
+}
+```
+Run with labels
+```
+python -m diagram2code.cli diagram.png --out outputs --labels labels.json
+```
+The exported program will then use labeled function names (sanitized into valid Python identifiers).
+
+## Export Bundle
+The **--export** fag creates a self-contained runnable bundle(easy to share).
+```
+python -m diagram2code.cli diagram.png --out outputs --export export_bundle
+```
+
+When using --export, the following files are copied:
+```
+export_bundle/
+├── generated_program.py
+├── graph.json
+├── labels.json            (if provided)
+├── debug_nodes.png        (if exists)
+├── debug_arrows.png       (if exists)
+├── render_graph.py        (if exists)
+├── run.ps1
+├── run.sh
+└── README_EXPORT.md
+```
+Running the exported bundle
+
+Windows (PowerShell):
+```
+cd export_bundle
+.\run.ps1
+```
+Linux/macOS:
+```
+cd export_bundle
+bash run.sh
+```
+or directly:
+```
+python generated_program.py
+```
+
+## Generated Files
+After a normal run **(--out outputs)**:
+| File                   | Description                          |
+| ---------------------- | ------------------------------------ |
+| `preprocessed.png`     | Binary image used for detection      |
+| `debug_nodes.png`      | Detected rectangles overlay          |
+| `debug_arrows.png`     | Detected arrows overlay (if enabled) |
+| `graph.json`           | Graph structure (nodes + edges)      |
+| `render_graph.py`      | Script to visualize the graph        |
+| `generated_program.py` | Generated executable Python program  |
+
+## Examples
+Simple linear flow
+```
+[ A ] → [ B ] → [ C ]
+```
+Branching flow
+```
+      → [ B ]
+[ A ]
+      → [ C ]
+```
+
+### OCR (Optional)
+`diagram2code` can extract text labels using Tesseract OCR.
+
+Requirements:
+- System: `tesseract-ocr`
+- Python: `pytesseract`
+
+If OCR is unavailable, the pipeline still works and labels default to empty.
+
+## Limitations
+- Only rectangular nodes are supported
+- Arrow detection is heuristic-based
+- Complex curves, diagonals, or overlapping arrows may fail
+- No text extraction from inside shapes
+- Not intended for UML, BPMN, or hand-drawn diagrams
+
+## Demo
+
+Convert a simple diagram image into runnable Python code:
+
+```bash
+diagram2code tests/fixtures/simple.png --out demo_outputs --extract-labels
+```
+
+
+
+
+
+
+

diagram2code-0.1.2/README.md

@@ -0,0 +1,198 @@
+# diagram2code
+
+Convert simple flowchart-style diagrams into runnable Python programs.
+
+`diagram2code` takes a diagram image (rectangular steps + arrows), detects the flow, and generates:
+
+- a graph representation (`graph.json`)
+- a runnable Python program (`generated_program.py`)
+- optional debug visualizations (`debug_nodes.png`, `debug_arrows.png`)
+- an optional exportable bundle (`--export`)
+
+> This project is designed for **learning, prototyping, and experimentation**, not for production-grade diagram parsing. :contentReference[oaicite:1]{index=1}
+
+---
+
+## Table of Contents
+
+1. [Installation](#installation)
+2. [Quick Start](#quick-start)
+3. [Using Labels](#using-labels)
+4. [Export Bundle](#export-bundle)
+5. [Generated Files](#generated-files)
+6. [Examples](#examples)
+7. [Limitations](#limitations)
+
+---
+
+## Installation
+
+Clone the repo and install in editable mode:
+
+```bash
+git clone https://github.com/Nimil785477/diagram2code.git
+cd diagram2code
+
+python -m venv .venv
+```
+Activate the environment
+```
+# Linux / macOS
+source .venv/bin/activate
+
+# Windows (PowerShell)
+.\.venv\Scripts\Activate.ps1
+```
+Install:
+```
+pip install -e .
+```
+### Basic (no OCR)
+```bash
+pip install diagram2code
+```
+With OCR support(optional)
+```bash
+pip install diagram2code[ocr]
+```
+You must also install Tesseract OCR on your system:
+- Windows: https://github.com/UB-Mannheim/tesseract/wiki
+- macOS:
+```bash
+brew install tesseract
+```
+- Ubuntu/Debian:
+```bash
+sudo apt install tesseract-ocr
+```
+Then run:
+```bash
+diagram2code image.png --extract-labels
+```
+
+This matches exactly what your code already does ✔️
+
+---
+
+## 3️⃣ (Optional but recommended) Add a runtime hint
+
+You already handle this well, but one tiny UX improvement:
+
+In `cli.py`, after `--extract-labels` failure, you could optionally print:
+
+```python
+safe_print("Hint: install OCR support with `pip install diagram2code[ocr]` and install Tesseract.")
+```
+
+## Quick Start
+Run diagram2code on a simple diagram:
+```
+python -m diagram2code.cli examples/simple/diagram.png --out outputs
+```
+This will write outputs (see Generated Files)
+
+## Using Labels
+You can provide custom labels for nodes using a JSON file
+
+Example labels.json
+```
+{
+  "0": "Step_1_Load_Data",
+  "1": "Step_2_Train_Model"
+}
+```
+Run with labels
+```
+python -m diagram2code.cli diagram.png --out outputs --labels labels.json
+```
+The exported program will then use labeled function names (sanitized into valid Python identifiers).
+
+## Export Bundle
+The **--export** fag creates a self-contained runnable bundle(easy to share).
+```
+python -m diagram2code.cli diagram.png --out outputs --export export_bundle
+```
+
+When using --export, the following files are copied:
+```
+export_bundle/
+├── generated_program.py
+├── graph.json
+├── labels.json            (if provided)
+├── debug_nodes.png        (if exists)
+├── debug_arrows.png       (if exists)
+├── render_graph.py        (if exists)
+├── run.ps1
+├── run.sh
+└── README_EXPORT.md
+```
+Running the exported bundle
+
+Windows (PowerShell):
+```
+cd export_bundle
+.\run.ps1
+```
+Linux/macOS:
+```
+cd export_bundle
+bash run.sh
+```
+or directly:
+```
+python generated_program.py
+```
+
+## Generated Files
+After a normal run **(--out outputs)**:
+| File                   | Description                          |
+| ---------------------- | ------------------------------------ |
+| `preprocessed.png`     | Binary image used for detection      |
+| `debug_nodes.png`      | Detected rectangles overlay          |
+| `debug_arrows.png`     | Detected arrows overlay (if enabled) |
+| `graph.json`           | Graph structure (nodes + edges)      |
+| `render_graph.py`      | Script to visualize the graph        |
+| `generated_program.py` | Generated executable Python program  |
+
+## Examples
+Simple linear flow
+```
+[ A ] → [ B ] → [ C ]
+```
+Branching flow
+```
+      → [ B ]
+[ A ]
+      → [ C ]
+```
+
+### OCR (Optional)
+`diagram2code` can extract text labels using Tesseract OCR.
+
+Requirements:
+- System: `tesseract-ocr`
+- Python: `pytesseract`
+
+If OCR is unavailable, the pipeline still works and labels default to empty.
+
+## Limitations
+- Only rectangular nodes are supported
+- Arrow detection is heuristic-based
+- Complex curves, diagonals, or overlapping arrows may fail
+- No text extraction from inside shapes
+- Not intended for UML, BPMN, or hand-drawn diagrams
+
+## Demo
+
+Convert a simple diagram image into runnable Python code:
+
+```bash
+diagram2code tests/fixtures/simple.png --out demo_outputs --extract-labels
+```
+
+
+
+
+
+
+

diagram2code-0.1.2/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "diagram2code"
+version = "0.1.2"
+description = "Convert simple diagram images into runnable code (matplotlib/graphviz)."
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "Kazi Samiul Islam"}]
+dependencies = ["opencv-python>=4.8", "numpy>=1.26", "matplotlib>=3.8"]
+requires-python = ">=3.11,<3.14"
+
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "ruff>=0.5.0",
+]
+
+ocr = [
+    "pytesseract>=0.3.10",
+]
+
+[project.scripts]
+diagram2code = "diagram2code.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

diagram2code-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

diagram2code-0.1.2/src/diagram2code/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

diagram2code-0.1.2/src/diagram2code/cli.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import cv2
+
+
+def safe_print(msg: str) -> None:
+    # Avoid UnicodeEncodeError on Windows CI/console encodings
+    try:
+        print(msg)
+    except UnicodeEncodeError:
+        print(msg.encode("utf-8", errors="replace").decode("utf-8"))
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="diagram2code",
+        description="Convert simple diagram images into runnable code.",
+    )
+    parser.add_argument("input", nargs="?", help="Path to input image")
+    parser.add_argument("--out", default="outputs", help="Output directory (default: outputs)")
+    parser.add_argument("--version", action="store_true", help="Print version")
+
+    # labels:
+    parser.add_argument("--labels", default=None, help="Path to labels JSON (optional)")
+    parser.add_argument(
+        "--extract-labels",
+        action="store_true",
+        help="Extract labels via OCR and write labels.json into --out (optional; requires pytesseract + tesseract).",
+    )
+
+    # export:
+    parser.add_argument("--export", type=str, default=None, help="Export runnable bundle to directory")
+
+    args = parser.parse_args(argv)
+
+    if args.version:
+        try:
+            from importlib.metadata import version
+            safe_print(f"diagram2code {version('diagram2code')}")
+        except Exception:
+            safe_print("diagram2code (unknown version)")
+        return 0
+
+    if not args.input:
+        parser.print_help()
+        return 0
+
+    out_dir = Path(args.out)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    # --- imports for pipeline ---
+    from diagram2code.vision.preprocess import preprocess_image
+    from diagram2code.vision.detect_shapes import detect_rectangles, draw_nodes_on_image
+    from diagram2code.vision.detect_arrows import detect_arrow_edges
+    from diagram2code.export_graph import save_graph_json
+    from diagram2code.export_matplotlib import generate_from_graph_json as gen_render_script
+    from diagram2code.export_program import generate_from_graph_json as gen_program
+    from diagram2code.labels import load_labels
+
+    # ============================
+    # Step 1: Preprocess
+    # ============================
+    result = preprocess_image(args.input, out_dir)
+    safe_print(f"Wrote: {result.output_path}")
+
+    # ============================
+    # Step 2: Detect nodes
+    # ============================
+    nodes = detect_rectangles(result.image_bin)
+
+    bgr = cv2.imread(str(args.input))
+    if bgr is None:
+        safe_print(f"Error: Could not read image: {args.input}")
+        return 1
+
+    debug_nodes = draw_nodes_on_image(bgr, nodes)
+    debug_nodes_path = out_dir / "debug_nodes.png"
+    cv2.imwrite(str(debug_nodes_path), debug_nodes)
+    safe_print(f"Detected nodes: {len(nodes)}")
+    safe_print(f"Wrote: {debug_nodes_path}")
+
+    # ============================
+    # Step 3: Detect arrows (edges)
+    # ============================
+    edges = detect_arrow_edges(result.image_bin, nodes, debug_path=out_dir / "debug_arrows.png")
+    safe_print(f"Wrote: {out_dir / 'debug_arrows.png'}")
+
+    # ============================
+    # Step 4: graph.json
+    # ============================
+    graph_path = save_graph_json(nodes, edges, out_dir / "graph.json")
+    safe_print(f"Wrote: {graph_path}")
+
+    # ============================
+    # Step 5: render_graph.py
+    # ============================
+    script_path = gen_render_script(out_dir / "graph.json", out_dir / "render_graph.py")
+    safe_print(f"Wrote: {script_path}")
+
+    # ============================
+    # Step 6: labels (either load from --labels, or OCR extract to out_dir/labels.json, or empty)
+    # ============================
+    labels_dict = {}
+
+    if args.labels:
+        labels_dict = load_labels(args.labels)
+
+    elif args.extract_labels:
+        # OCR is optional: only run when user asks for it
+        try:
+            from diagram2code.vision.extract_labels import extract_node_labels
+
+            labels_dict = extract_node_labels(bgr, nodes) or {}
+        except Exception as e:
+            # IMPORTANT: do NOT fail the whole CLI; just continue without labels
+            safe_print(f"Warning: OCR label extraction failed/unavailable: {type(e).__name__}: {e}")
+            labels_dict = {}
+
+        labels_out = out_dir / "labels.json"
+        labels_out.write_text(
+            json.dumps({str(k): v for k, v in labels_dict.items()}, indent=2),
+            encoding="utf-8",
+        )
+        safe_print(f"Wrote: {labels_out}")
+
+    # ============================
+    # Step 7: generated_program.py
+    # ============================
+    program_path = gen_program(out_dir / "graph.json", out_dir / "generated_program.py", labels=labels_dict)
+    safe_print(f"Wrote: {program_path}")
+
+    # ============================
+    # Step 8: optional export bundle
+    # ============================
+    export_dir = Path(args.export) if args.export else None
+    if export_dir:
+        export_dir.mkdir(parents=True, exist_ok=True)
+
+        import shutil
+
+        # Copy required artifacts
+        shutil.copy2(out_dir / "graph.json", export_dir / "graph.json")
+        shutil.copy2(out_dir / "generated_program.py", export_dir / "generated_program.py")
+
+        # Optional artifacts if they exist
+        for name in [
+            "labels.json",
+            "debug_nodes.png",
+            "debug_arrows.png",
+            "preprocessed.png",
+            "render_graph.py",
+            "render_graph.png",
+        ]:
+            p = out_dir / name
+            if p.exists():
+                shutil.copy2(p, export_dir / name)
+
+        # Run scripts
+        (export_dir / "run.ps1").write_text("python .\\generated_program.py\n", encoding="utf-8")
+        (export_dir / "run.sh").write_text(
+            "#!/usr/bin/env bash\nset -e\npython3 generated_program.py\n",
+            encoding="utf-8",
+        )
+
+        # README
+        (export_dir / "README_EXPORT.md").write_text(
+            "# diagram2code export\n\n"
+            "This folder contains an exported runnable bundle.\n\n"
+            "## Run\n\n"
+            "### Windows (PowerShell)\n"
+            "```powershell\n"
+            ".\\run.ps1\n"
+            "```\n\n"
+            "### macOS / Linux\n"
+            "```bash\n"
+            "bash run.sh\n"
+            "```\n",
+            encoding="utf-8",
+        )
+
+        safe_print(f"Exported bundle to: {export_dir}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

diagram2code-0.1.2/src/diagram2code/export_graph.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import List, Tuple
+
+from diagram2code.schema import Node
+
+
+def save_graph_json(nodes: List[Node], edges: List[Tuple[int, int]], out_path: str | Path) -> Path:
+    out_path = Path(out_path)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+
+    data = {
+        "nodes": [{"id": n.id, "bbox": list(n.bbox)} for n in nodes],
+        "edges": [{"from": a, "to": b} for a, b in edges],
+    }
+
+    out_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    return out_path