cad2d-ir 0.1.0__tar.gz

cad2d_ir-0.1.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.3
+Name: cad2d-ir
+Version: 0.1.0
+Summary: Intermediate representation (IR) for 2D CAD and DXF converters
+Keywords: cad,dxf,geometry,2d,intermediate-representation
+Author: neka-nat
+Author-email: neka-nat <nekanat.stock@gmail.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: jsonschema>=4.23.0
+Requires-Python: >=3.10
+Project-URL: Documentation, https://github.com/neka-nat/cad2d-ir/tree/main/docs
+Project-URL: Homepage, https://github.com/neka-nat/cad2d-ir
+Project-URL: Issues, https://github.com/neka-nat/cad2d-ir/issues
+Project-URL: Repository, https://github.com/neka-nat/cad2d-ir
+Description-Content-Type: text/markdown
+
+# cad2d-ir
+
+`cad2d-ir` is an intermediate representation (IR) for 2D CAD data, plus converters between DXF and that IR.
+
+The goal is to provide a stable, machine-friendly format for:
+- CAD ingestion pipelines
+- geometric post-processing
+- round-trip conversion workflows
+
+## Status
+
+The project currently supports:
+- `LINE`, `CIRCLE`, `ARC`, `LWPOLYLINE`, `TEXT`
+- `MTEXT`, `INSERT`, `HATCH`
+- staged support for `SPLINE`, `DIMENSION`, and `constraints`
+
+See `ir_schema.json` for the canonical schema.
+
+## Installation
+
+### With pip
+
+```bash
+pip install cad2d-ir
+```
+
+### For development (uv)
+
+```bash
+uv sync
+uv run pytest
+```
+
+## CLI
+
+```bash
+# Validate IR JSON
+cad2d-ir validate examples/ir/minimal.json
+
+# DXF -> IR
+cad2d-ir dxf2ir examples/dxf/simple_line.dxf -o /tmp/out.json --pretty
+
+# IR -> DXF
+cad2d-ir ir2dxf examples/ir/minimal.json -o /tmp/out.dxf
+```
+
+Warnings (for example when `constraints` cannot be represented in plain DXF) are printed to stderr.
+
+## Python API
+
+```python
+from cad2d_ir import convert_dxf_text_to_ir, convert_ir_to_dxf_text
+
+dxf_text = "0\nSECTION\n2\nENTITIES\n0\nLINE\n10\n0\n20\n0\n11\n1\n21\n1\n0\nENDSEC\n0\nEOF\n"
+to_ir = convert_dxf_text_to_ir(dxf_text)
+print(to_ir.document["entities"][0]["kind"])  # LINE
+
+to_dxf = convert_ir_to_dxf_text(to_ir.document)
+print(len(to_dxf.warnings))
+```
+
+Lower-level conversion functions (`dxf_to_ir`, `ir_to_dxf`) are also available.
+
+## Repository layout
+
+```text
+src/cad2d_ir/
+  api.py             # public high-level API
+  cli.py             # CLI entrypoint
+  schema.py          # schema loading + validation
+  codecs/dxf.py      # DXF <-> IR conversion
+  data/ir_schema.json
+ir_schema.json       # canonical schema source
+tests/
+examples/
+docs/
+```
+
+## Compatibility and limitations
+
+- `constraints` are preserved in IR but omitted when exporting to DXF.
+- `DIMENSION` support is semantic/staged and may not preserve every CAD-system-specific detail.
+- `HATCH` currently focuses on polyline-style loops.
+
+## Development
+
+```bash
+uv run pytest -q
+uv run cad2d-ir --help
+```
+
+See:
+- `CONTRIBUTING.md`
+- `docs/API.md`
+- `docs/SCHEMA_NOTES.md`
+
+## License
+
+MIT (`LICENSE`)

cad2d_ir-0.1.0/README.md

@@ -0,0 +1,99 @@
+# cad2d-ir
+
+`cad2d-ir` is an intermediate representation (IR) for 2D CAD data, plus converters between DXF and that IR.
+
+The goal is to provide a stable, machine-friendly format for:
+- CAD ingestion pipelines
+- geometric post-processing
+- round-trip conversion workflows
+
+## Status
+
+The project currently supports:
+- `LINE`, `CIRCLE`, `ARC`, `LWPOLYLINE`, `TEXT`
+- `MTEXT`, `INSERT`, `HATCH`
+- staged support for `SPLINE`, `DIMENSION`, and `constraints`
+
+See `ir_schema.json` for the canonical schema.
+
+## Installation
+
+### With pip
+
+```bash
+pip install cad2d-ir
+```
+
+### For development (uv)
+
+```bash
+uv sync
+uv run pytest
+```
+
+## CLI
+
+```bash
+# Validate IR JSON
+cad2d-ir validate examples/ir/minimal.json
+
+# DXF -> IR
+cad2d-ir dxf2ir examples/dxf/simple_line.dxf -o /tmp/out.json --pretty
+
+# IR -> DXF
+cad2d-ir ir2dxf examples/ir/minimal.json -o /tmp/out.dxf
+```
+
+Warnings (for example when `constraints` cannot be represented in plain DXF) are printed to stderr.
+
+## Python API
+
+```python
+from cad2d_ir import convert_dxf_text_to_ir, convert_ir_to_dxf_text
+
+dxf_text = "0\nSECTION\n2\nENTITIES\n0\nLINE\n10\n0\n20\n0\n11\n1\n21\n1\n0\nENDSEC\n0\nEOF\n"
+to_ir = convert_dxf_text_to_ir(dxf_text)
+print(to_ir.document["entities"][0]["kind"])  # LINE
+
+to_dxf = convert_ir_to_dxf_text(to_ir.document)
+print(len(to_dxf.warnings))
+```
+
+Lower-level conversion functions (`dxf_to_ir`, `ir_to_dxf`) are also available.
+
+## Repository layout
+
+```text
+src/cad2d_ir/
+  api.py             # public high-level API
+  cli.py             # CLI entrypoint
+  schema.py          # schema loading + validation
+  codecs/dxf.py      # DXF <-> IR conversion
+  data/ir_schema.json
+ir_schema.json       # canonical schema source
+tests/
+examples/
+docs/
+```
+
+## Compatibility and limitations
+
+- `constraints` are preserved in IR but omitted when exporting to DXF.
+- `DIMENSION` support is semantic/staged and may not preserve every CAD-system-specific detail.
+- `HATCH` currently focuses on polyline-style loops.
+
+## Development
+
+```bash
+uv run pytest -q
+uv run cad2d-ir --help
+```
+
+See:
+- `CONTRIBUTING.md`
+- `docs/API.md`
+- `docs/SCHEMA_NOTES.md`
+
+## License
+
+MIT (`LICENSE`)

cad2d_ir-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[project]
+name = "cad2d-ir"
+version = "0.1.0"
+description = "Intermediate representation (IR) for 2D CAD and DXF converters"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "neka-nat", email = "nekanat.stock@gmail.com" }
+]
+requires-python = ">=3.10"
+keywords = ["cad", "dxf", "geometry", "2d", "intermediate-representation"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "jsonschema>=4.23.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/neka-nat/cad2d-ir"
+Repository = "https://github.com/neka-nat/cad2d-ir"
+Documentation = "https://github.com/neka-nat/cad2d-ir/tree/main/docs"
+Issues = "https://github.com/neka-nat/cad2d-ir/issues"
+
+[project.scripts]
+cad2d-ir = "cad2d_ir.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.8.15,<0.9.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.4.1",
+    "pytest-cov>=6.0.0",
+    "ruff>=0.8.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

cad2d_ir-0.1.0/src/cad2d_ir/__init__.py

@@ -0,0 +1,33 @@
+from cad2d_ir.api import (
+    DxfToIrResult,
+    IrToDxfResult,
+    convert_dxf_file_to_ir,
+    convert_dxf_text_to_ir,
+    convert_ir_file_to_dxf,
+    convert_ir_to_dxf_text,
+    dump_ir_json,
+    load_ir_json,
+)
+from cad2d_ir.codecs.dxf import dxf_to_ir, ir_to_dxf, read_dxf_file, write_dxf_file
+from cad2d_ir.schema import IRValidationError, load_schema, validate_ir
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    "DxfToIrResult",
+    "IRValidationError",
+    "IrToDxfResult",
+    "convert_dxf_file_to_ir",
+    "convert_dxf_text_to_ir",
+    "convert_ir_file_to_dxf",
+    "convert_ir_to_dxf_text",
+    "dxf_to_ir",
+    "dump_ir_json",
+    "ir_to_dxf",
+    "load_ir_json",
+    "load_schema",
+    "read_dxf_file",
+    "validate_ir",
+    "write_dxf_file",
+]

cad2d_ir-0.1.0/src/cad2d_ir/api.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+from cad2d_ir.codecs.dxf import dxf_to_ir, ir_to_dxf
+from cad2d_ir.schema import validate_ir
+
+
+@dataclass(slots=True)
+class DxfToIrResult:
+    document: dict[str, Any]
+    warnings: list[str]
+
+
+@dataclass(slots=True)
+class IrToDxfResult:
+    dxf_text: str
+    warnings: list[str]
+
+
+def convert_dxf_text_to_ir(
+    dxf_text: str,
+    *,
+    ir_version: str = "0.1.0",
+    validate: bool = True,
+) -> DxfToIrResult:
+    warnings: list[str] = []
+    document = dxf_to_ir(
+        dxf_text,
+        ir_version=ir_version,
+        validate=validate,
+        warnings=warnings,
+    )
+    return DxfToIrResult(document=document, warnings=warnings)
+
+
+def convert_dxf_file_to_ir(
+    path: str | Path,
+    *,
+    ir_version: str = "0.1.0",
+    validate: bool = True,
+) -> DxfToIrResult:
+    dxf_text = Path(path).read_text(encoding="utf-8")
+    return convert_dxf_text_to_ir(dxf_text, ir_version=ir_version, validate=validate)
+
+
+def convert_ir_to_dxf_text(
+    document: dict[str, Any],
+    *,
+    validate: bool = True,
+) -> IrToDxfResult:
+    warnings: list[str] = []
+    dxf_text = ir_to_dxf(document, validate=validate, warnings=warnings)
+    return IrToDxfResult(dxf_text=dxf_text, warnings=warnings)
+
+
+def convert_ir_file_to_dxf(
+    path: str | Path,
+    *,
+    validate: bool = True,
+) -> IrToDxfResult:
+    document = load_ir_json(path, validate=validate)
+    return convert_ir_to_dxf_text(document, validate=validate)
+
+
+def load_ir_json(path: str | Path, *, validate: bool = True) -> dict[str, Any]:
+    document = json.loads(Path(path).read_text(encoding="utf-8"))
+    if validate:
+        validate_ir(document)
+    return document
+
+
+def dump_ir_json(
+    document: dict[str, Any],
+    path: str | Path,
+    *,
+    pretty: bool = True,
+    validate: bool = True,
+) -> None:
+    if validate:
+        validate_ir(document)
+    indent = 2 if pretty else None
+    text = json.dumps(document, ensure_ascii=False, indent=indent)
+    if pretty:
+        text += "\n"
+    Path(path).write_text(text, encoding="utf-8")

cad2d_ir-0.1.0/src/cad2d_ir/cli.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+from typing import Sequence
+
+from cad2d_ir.api import convert_dxf_text_to_ir, convert_ir_to_dxf_text, load_ir_json
+from cad2d_ir.schema import IRValidationError, validate_ir
+
+
+def _read_json(path: Path) -> dict:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _write_text(path: Path | None, text: str) -> None:
+    if path is None:
+        print(text, end="")
+        return
+    path.write_text(text, encoding="utf-8")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="cad2d-ir")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    validate_parser = subparsers.add_parser("validate", help="Validate an IR JSON document")
+    validate_parser.add_argument("input", type=Path, help="Path to IR JSON file")
+
+    dxf2ir_parser = subparsers.add_parser("dxf2ir", help="Convert DXF file to IR JSON")
+    dxf2ir_parser.add_argument("input", type=Path, help="Path to DXF file")
+    dxf2ir_parser.add_argument("-o", "--output", type=Path, help="Output IR JSON path")
+    dxf2ir_parser.add_argument("--pretty", action="store_true", help="Pretty-print JSON")
+    dxf2ir_parser.add_argument("--ir-version", default="0.1.0", help="IR version string")
+
+    ir2dxf_parser = subparsers.add_parser("ir2dxf", help="Convert IR JSON to DXF file")
+    ir2dxf_parser.add_argument("input", type=Path, help="Path to IR JSON file")
+    ir2dxf_parser.add_argument("-o", "--output", type=Path, help="Output DXF path")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    try:
+        if args.command == "validate":
+            validate_ir(_read_json(args.input))
+            print("IR document is valid.")
+            return 0
+
+        if args.command == "dxf2ir":
+            result = convert_dxf_text_to_ir(
+                args.input.read_text(encoding="utf-8"),
+                ir_version=args.ir_version,
+                validate=True,
+            )
+            indent = 2 if args.pretty else None
+            text = json.dumps(result.document, ensure_ascii=False, indent=indent)
+            if indent is not None:
+                text += "\n"
+            _write_text(args.output, text)
+            for warning in result.warnings:
+                print(f"Warning: {warning}", file=sys.stderr)
+            return 0
+
+        if args.command == "ir2dxf":
+            result = convert_ir_to_dxf_text(load_ir_json(args.input, validate=True), validate=True)
+            _write_text(args.output, result.dxf_text)
+            for warning in result.warnings:
+                print(f"Warning: {warning}", file=sys.stderr)
+            return 0
+    except (IRValidationError, ValueError, json.JSONDecodeError) as exc:
+        print(f"Error: {exc}")
+        return 2
+
+    parser.error(f"Unknown command: {args.command}")
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cad2d_ir-0.1.0/src/cad2d_ir/codecs/__init__.py

@@ -0,0 +1,3 @@
+from cad2d_ir.codecs.dxf import dxf_to_ir, ir_to_dxf, read_dxf_file, write_dxf_file
+
+__all__ = ["dxf_to_ir", "ir_to_dxf", "read_dxf_file", "write_dxf_file"]