mcruft-vectorcraft 0.1.2__tar.gz

mcruft_vectorcraft-0.1.2/.gitignore

@@ -0,0 +1,230 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+*.lcov
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# uv
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi/*
+!.pixi/config.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule*
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs/Zensical documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore that
+#   can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, you
+#   could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+# OMC runtime state
+.omc/
+.superpowers/
+
+# Generated by hatch-vcs; keep the release helper under lib/.
+packages/*/src/*/__version__.py
+!/lib/
+/lib/*
+!/lib/guard.sh

mcruft_vectorcraft-0.1.2/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.5
+Name: mcruft-vectorcraft
+Version: 0.1.2
+Summary: VectorCraft engine for mcruft
+License-Expression: Apache-2.0
+Requires-Python: >=3.12
+Requires-Dist: mcruft
+Requires-Dist: pypdf
+Provides-Extra: bundled
+Requires-Dist: mcruft-vectorcraft-bin; extra == 'bundled'

mcruft_vectorcraft-0.1.2/pyproject.toml

@@ -0,0 +1,35 @@
+# this_file: packages/mcruft_vectorcraft/pyproject.toml
+[project]
+license = "Apache-2.0"
+name = "mcruft-vectorcraft"
+description = "VectorCraft engine for mcruft"
+dynamic = ["version"]
+requires-python = ">=3.12"
+dependencies = ["mcruft", "pypdf"]
+
+[project.optional-dependencies]
+bundled = ["mcruft-vectorcraft-bin"]
+
+[project.entry-points."mcruft.engines"]
+vectorcraft = "mcruft_vectorcraft:engine"
+
+[tool.uv.sources]
+mcruft = { workspace = true }
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+fallback-version = "0.0.0"
+
+[tool.hatch.version.raw-options]
+root = "../.."
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/mcruft_vectorcraft/__version__.py"
+
+[tool.uv]
+# Rebuild editable installs when git state changes, so hatch-vcs metadata stays current.
+cache-keys = [{ file = "pyproject.toml" }, { git = { commit = true, tags = true } }]

mcruft_vectorcraft-0.1.2/src/mcruft_vectorcraft/__init__.py

@@ -0,0 +1,123 @@
+# this_file: packages/mcruft_vectorcraft/src/mcruft_vectorcraft/__init__.py
+import json
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from mcruft.engines.base import Capability
+from mcruft.engines.cli import CliEngine, page_indexes, pixel_scale
+from mcruft.report import Loss, Policy, Report
+from pypdf import PdfReader, PdfWriter
+
+try:
+    from .__version__ import __version__ as __version__
+except ImportError:
+    from importlib.metadata import version
+
+    __version__ = version("mcruft-vectorcraft")
+
+
+CONVERSIONS = [
+    ("svg", "pdf", "editable"),
+    ("svg", "png", "fidelity"),
+    ("svg", "ai", "editable"),
+    ("svg", "vectorcraft", "editable"),
+    ("pdf", "svg", "editable"),
+    ("pdf", "psd", "fidelity"),
+    ("vectorcraft", "pdf", "editable"),
+    ("vectorcraft", "svg", "editable"),
+    ("vectorcraft", "png", "fidelity"),
+]
+
+
+class VectorcraftEngine(CliEngine):
+    PRODUCT = "vectorcraft"
+    MIN_VERSION = "0.16.0"
+
+    def capabilities(self) -> list[Capability]:
+        routes = [("convert", *row) for row in CONVERSIONS]
+        routes += [
+            ("outline_text", src, dst, "fidelity")
+            for src in ("pdf", "svg", "vectorcraft", "ai")
+            for dst in ("pdf", "svg")
+        ]
+        routes += [("export_pages", src, "pdf", "editable") for src in ("vectorcraft", "svg", "ai")]
+        routes += [("export_pages", src, "png", "fidelity") for src in ("vectorcraft", "svg", "ai")]
+        routes += [("inspect", ext, ext, "editable") for ext in ("vectorcraft", "ai", "eps")]
+        return [Capability(*row, f"{self.PRODUCT}-cli {self.MIN_VERSION}") for row in routes]
+
+    def inspect(self, path: Path) -> list[tuple[float, float]]:
+        path = Path(path)
+        if path.suffix.lower() not in (".vectorcraft", ".ai", ".eps"):
+            return super().inspect(path)
+        info = json.loads(self.call(["info", path]))
+        # VectorCraft info uses [x, y, width, height], unlike DesignCraft bounds.
+        return [(float(a["rect"][2]), float(a["rect"][3])) for a in info["artboards"]]
+
+    def run(self, op: str, src: Path, dst: Path, *, policy: Policy, **opts) -> Report:
+        src, dst = Path(src), Path(dst)
+        self.check_route(op, src, dst, policy)
+        report = self.report(op, policy, [dst])
+        args = ["convert", src, dst]
+        if op == "outline_text":
+            args = [
+                "run",
+                "--in",
+                src,
+                "--cmd",
+                "select.all",
+                "--cmd",
+                "type.createOutlines",
+                "--export",
+                dst,
+            ]
+            report.losses.append(
+                Loss(
+                    "layout",
+                    "re-imported via VectorCraft: links, annotations and forms may be dropped",
+                )
+            )
+        elif op == "export_pages":
+            count = len(json.loads(self.call(["info", src]))["artboards"])
+            pages = page_indexes(opts.get("pages"), count)
+            if dst.suffix.lower() == ".png":
+                report.outputs = []
+                for page in pages:
+                    out = dst.with_name(f"{dst.stem}-{page:04d}.png")
+                    self.call(
+                        [
+                            "convert",
+                            src,
+                            out,
+                            "--artboard",
+                            str(page),
+                            "--scale",
+                            str(pixel_scale(opts.get("dpi", 150))),
+                        ],
+                        report,
+                    )
+                    report.outputs.append(out)
+                report.losses.append(Loss("raster", "vector artwork rasterised"))
+                return report
+            if len(set(pages)) != len(pages):
+                # --range drops duplicates; join single-artboard exports to retain them.
+                with TemporaryDirectory(dir=dst.parent) as directory, PdfWriter() as writer:
+                    for index, page in enumerate(pages):
+                        part = Path(directory) / f"{index}.pdf"
+                        self.call([*args[:2], part, "--artboard", str(page)], report)
+                        writer.append(PdfReader(part))
+                    writer.write(dst)
+                return report
+            args += (
+                ["--artboard", str(pages[0])]
+                if len(pages) == 1
+                else ["--range", ",".join(str(i + 1) for i in pages)]
+            )
+        elif dst.suffix.lower() == ".png":
+            args += ["--scale", str(pixel_scale(opts.get("dpi", 150)))]
+        if dst.suffix.lower() in (".png", ".psd"):
+            report.losses.append(Loss("raster", "vector artwork rasterised"))
+        self.call(args, report)
+        return report
+
+
+engine = VectorcraftEngine()

mcruft_vectorcraft-0.1.2/src/mcruft_vectorcraft/__version__.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.2'
+__version_tuple__ = version_tuple = (0, 1, 2)
+
+__commit_id__ = commit_id = None

mcruft_vectorcraft-0.1.2/tests/test_vectorcraft.py

@@ -0,0 +1,116 @@
+# this_file: packages/mcruft_vectorcraft/tests/test_vectorcraft.py
+import pytest
+from mcruft import UnsupportedRoute
+from mcruft.engines.cli import run_cli
+from mcruft_vectorcraft import engine
+from PIL import Image
+from pypdf import PdfReader, PdfWriter
+
+pytestmark = pytest.mark.skipif(not engine.available(), reason="vectorcraft-cli not installed")
+
+
+def test_unknown_route(tmp_path):
+    with pytest.raises(UnsupportedRoute):
+        engine.run("convert", tmp_path / "in.unknown", tmp_path / "out.unknown", policy="editable")
+
+
+def test_declared_routes(tmp_path):
+    svg = tmp_path / "input.svg"
+    svg.write_text(
+        '<svg xmlns="http://www.w3.org/2000/svg" width="96pt" height="48pt">'
+        '<text x="3" y="24" font-family="Arial" font-size="12">Hello</text></svg>'
+    )
+    inputs = {"svg": svg}
+    for ext in ("pdf", "vectorcraft", "ai", "eps"):
+        inputs[ext] = tmp_path / f"input.{ext}"
+        run_cli([engine.binary(), "convert", svg, inputs[ext]])
+    exercised = set()
+    for n, cap in enumerate(engine.capabilities()):
+        src = inputs[cap.src]
+        dst = tmp_path / f"route-{n}.{cap.dst}"
+        if cap.op == "inspect":
+            assert engine.inspect(src) == [(96, 48)]
+        else:
+            report = engine.run(cap.op, src, dst, policy=cap.policy, pages=[0], dpi=144)
+            if cap.op == "export_pages" and cap.dst == "png":
+                dst = dst.with_name(f"{dst.stem}-0000.png")
+            assert report.outputs == [dst]
+            assert dst.stat().st_size > 0
+            if cap.dst == "pdf":
+                assert len(PdfReader(dst).pages) == 1
+                assert float(PdfReader(dst).pages[0].mediabox.width) == pytest.approx(96)
+            if cap.dst == "png":
+                with Image.open(dst) as image:
+                    assert image.size == (192, 96)
+                assert any(loss.kind == "raster" for loss in report.losses)
+            if cap.dst == "psd":
+                with Image.open(dst) as image:
+                    assert image.size == (96, 48)
+                assert any(loss.kind == "raster" for loss in report.losses)
+            if cap.op == "outline_text":
+                assert report.losses[0].detail == (
+                    "re-imported via VectorCraft: links, annotations and forms may be dropped"
+                )
+                assert b"/FontFile" not in dst.read_bytes()
+                if cap.dst == "svg":
+                    assert "<text" not in dst.read_text()
+            elif cap.dst == "svg":
+                assert "<text" in dst.read_text()
+        exercised.add((cap.op, cap.src, cap.dst, cap.policy))
+    assert {
+        (c.op, c.src, c.dst, c.policy) for c in engine.capabilities() if c.verified_with
+    } <= exercised
+
+
+def test_export_svg_png_page_contract(tmp_path):
+    src = tmp_path / "input.svg"
+    src.write_text('<svg xmlns="http://www.w3.org/2000/svg" width="96pt" height="48pt"/>')
+    report = engine.run(
+        "export_pages", src, tmp_path / "page.png", policy="fidelity", pages=[0], dpi=72
+    )
+    assert report.outputs == [tmp_path / "page-0000.png"]
+    with Image.open(report.outputs[0]) as image:
+        assert image.size == (96, 48)
+
+
+def test_page_order_duplicates_and_warnings(tmp_path):
+    pdf = tmp_path / "input.pdf"
+    writer = PdfWriter()
+    writer.add_blank_page(96, 48)
+    writer.add_blank_page(144, 72)
+    writer.write(pdf)
+    native = tmp_path / "input.vectorcraft"
+    run_cli([engine.binary(), "convert", pdf, native])
+    for pages, expected in (
+        (None, [96, 144]),
+        ([1], [144]),
+        ([1, 0], [144, 96]),
+        ([1, 0, 1], [144, 96, 144]),
+    ):
+        dst = tmp_path / "selected.pdf"
+        report = engine.run("export_pages", native, dst, policy="editable", pages=pages)
+        assert [float(p.mediabox.width) for p in PdfReader(dst).pages] == expected
+        if pages == [1]:
+            assert any("Preserve editing" in warning for warning in report.warnings)
+    with pytest.raises((ValueError, IndexError)):
+        engine.run("export_pages", native, tmp_path / "bad.pdf", policy="editable", pages=[-1])
+
+
+def test_json_warnings_and_cli_failure(tmp_path, monkeypatch):
+    from mcruft import EngineFailed
+
+    binary = tmp_path / "fake-cli"
+    binary.write_text(
+        '#!/bin/sh\nif [ "$1" = "--version" ]; then echo "0.16.0"; exit; fi\n'
+        'echo \'{"warnings":["first"],"result":{"warnings":["second"]}}\'\n'
+        'echo \'{"warnings":["third"]}\'\n'
+    )
+    binary.chmod(0o755)
+    monkeypatch.setenv("MCRUFT_VECTORCRAFT_CLI", str(binary))
+    report = engine.run(
+        "outline_text", tmp_path / "in.svg", tmp_path / "out.svg", policy="fidelity"
+    )
+    assert report.warnings == ["first", "second", "third"]
+    binary.write_text('#!/bin/sh\necho "broken CLI" >&2\nexit 1\n')
+    with pytest.raises(EngineFailed, match="broken CLI"):
+        engine.run("convert", tmp_path / "in.svg", tmp_path / "out.pdf", policy="editable")