morphconv 1.0.1__py3-none-any.whl

morph/converters/documents.py

@@ -0,0 +1,252 @@
+"""
+converters/documents.py — document family, powered by pandoc.
+
+Pandoc already handles most-to-most conversion natively in a single command
+(pandoc understands both the source and target format directly), so instead
+of writing one function per format pair we generate every valid (src, dst)
+edge from one shared FORMATS table and one shared _pandoc_convert() function.
+
+PDF is output-only: pandoc can't reliably *read* PDFs back into structured
+text, so "pdf" only ever appears as a destination here.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from ..registry import ConversionResult, OptionSpec, register
+
+# format id -> (pandoc reader name or None if input unsupported, pandoc writer name, default extension)
+FORMATS: dict[str, dict] = {
+    "md":     {"read": "markdown",  "write": "markdown", "ext": "md"},
+    "html":   {"read": "html",      "write": "html",     "ext": "html"},
+    "docx":   {"read": "docx",      "write": "docx",     "ext": "docx"},
+    "odt":    {"read": "odt",       "write": "odt",      "ext": "odt"},
+    "rtf":    {"read": "rtf",       "write": "rtf",      "ext": "rtf"},
+    "epub":   {"read": "epub",      "write": "epub",     "ext": "epub"},
+    "latex":  {"read": "latex",     "write": "latex",    "ext": "tex"},
+    "rst":    {"read": "rst",       "write": "rst",      "ext": "rst"},
+    "txt":    {"read": "markdown",  "write": "plain",    "ext": "txt"},
+    "pdf":    {"read": None,        "write": "pdf",      "ext": "pdf"},
+    "ipynb":  {"read": "ipynb",     "write": "ipynb",    "ext": "ipynb"},
+    "pptx":   {"read": "pptx",      "write": "pptx",     "ext": "pptx"},
+    "adoc":   {"read": "asciidoc",  "write": "asciidoc", "ext": "adoc"},
+    "org":    {"read": "org",       "write": "org",      "ext": "org"},
+    "opml":   {"read": "opml",      "write": "opml",     "ext": "opml"},
+    "man":    {"read": "man",       "write": "man",      "ext": "man"},
+}
+
+# tried in order; first one found on PATH is used
+_PDF_ENGINES = ["xelatex", "pdflatex", "wkhtmltopdf", "weasyprint", "tectonic"]
+
+
+def _available_pdf_engines() -> list[str]:
+    """All PDF engines that are actually on PATH, in preference order.
+
+    Being on PATH doesn't guarantee an engine works (e.g. a LaTeX install
+    missing packages like lmodern.sty still puts xelatex on PATH but fails
+    at render time) — see _pandoc_convert's fallback loop for how that's
+    handled.
+    """
+    return [e for e in _PDF_ENGINES if shutil.which(e)]
+
+
+def _run_pandoc(input_path: Path, output_path: Path, *, src_fmt: str, dst_fmt: str,
+                 dst: str, engine: Optional[str], extra_args: Optional[list[str]]) -> subprocess.CompletedProcess:
+    cmd = ["pandoc", str(input_path), "-f", src_fmt, "-t", dst_fmt, "-o", str(output_path)]
+    if dst not in ("pdf", "txt"):
+        cmd.append("--standalone")
+    if engine:
+        cmd += ["--pdf-engine", engine]
+    if extra_args:
+        cmd += extra_args
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    return subprocess.run(cmd, capture_output=True, text=True, encoding="utf-8", errors="replace")
+
+
+def _preprocess_svgs(input_path: Path, tmpdir: Path, src: str) -> Path:
+    if src not in ("md", "html", "txt"):
+        return input_path
+
+    try:
+        content = input_path.read_text(encoding="utf-8", errors="replace")
+    except Exception:
+        return input_path
+
+    import re
+    import hashlib
+    import urllib.request
+
+    try:
+        import cairosvg
+        # Trigger DLL loading immediately to verify if C libraries are functional
+        cairosvg.svg2pdf(bytestring=b"<svg></svg>")
+        has_cairo = True
+    except Exception:
+        has_cairo = False
+
+    converted_cache: dict[str, Path] = {}
+    modified = False
+
+    def get_converted_pdf(img_src: str) -> Optional[str]:
+        if not has_cairo:
+            return None
+
+        if img_src in converted_cache:
+            return converted_cache[img_src].as_posix()
+
+        # Generate a stable filename based on the hash of the image source
+        src_hash = hashlib.md5(img_src.encode("utf-8")).hexdigest()
+        pdf_path = tmpdir / f"svg_img_{src_hash}.pdf"
+
+        try:
+            is_url = img_src.startswith(("http://", "https://"))
+            if is_url:
+                req = urllib.request.Request(
+                    img_src,
+                    headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Antigravity/1.0'}
+                )
+                with urllib.request.urlopen(req, timeout=10) as response:
+                    svg_bytes = response.read()
+                cairosvg.svg2pdf(bytestring=svg_bytes, write_to=str(pdf_path))
+            else:
+                # Local file: resolve relative to input_path's parent directory
+                local_path = (input_path.parent / img_src).resolve()
+                if not local_path.exists():
+                    # Try directly as absolute or relative path
+                    local_path = Path(img_src).resolve()
+                if local_path.exists():
+                    cairosvg.svg2pdf(url=str(local_path), write_to=str(pdf_path))
+                else:
+                    return None
+
+            if pdf_path.exists() and pdf_path.stat().st_size > 0:
+                converted_cache[img_src] = pdf_path
+                return pdf_path.as_posix()
+        except Exception:
+            pass
+
+        return None
+
+    # Replace markdown images: ![alt](img.svg)
+    def md_repl(match):
+        nonlocal modified
+        prefix, img_src, suffix = match.groups()
+        pdf_url = get_converted_pdf(img_src)
+        if pdf_url:
+            modified = True
+            return f"{prefix}{pdf_url}{suffix}"
+        else:
+            # Convert image inclusion to a standard hyperlink to avoid LaTeX error
+            modified = True
+            # prefix is like '![alt]('
+            link_prefix = prefix.lstrip("!")
+            return f"{link_prefix}{img_src}{suffix}"
+
+    md_pattern = re.compile(r'(!\[.*?\]\()([^)]*?\.svg(?:[?#][^)]*)?)(\))', re.IGNORECASE)
+    content = md_pattern.sub(md_repl, content)
+
+    # Replace HTML images: <img src="img.svg" ...>
+    def html_repl(match):
+        nonlocal modified
+        prefix, img_src, suffix = match.groups()
+        pdf_url = get_converted_pdf(img_src)
+        if pdf_url:
+            modified = True
+            return f"{prefix}{pdf_url}{suffix}"
+        else:
+            modified = True
+            return f'<a href="{img_src}">[SVG Image]</a>'
+
+    html_pattern = re.compile(r'(<img\s+[^>]*src=["\'])([^"\']+\.svg(?:[?#][^"\']*)?)(["\'])', re.IGNORECASE)
+    content = html_pattern.sub(html_repl, content)
+
+    if modified:
+        temp_input = tmpdir / f"preprocessed_{input_path.name}"
+        temp_input.write_text(content, encoding="utf-8")
+        return temp_input
+
+    return input_path
+
+
+def _pandoc_convert(input_path: Path, output_path: Path, *, src: str, dst: str,
+                     pdf_engine: Optional[str] = None, extra_args: Optional[list[str]] = None,
+                     **_options) -> ConversionResult:
+    src_fmt = FORMATS[src]["read"]
+    dst_fmt = FORMATS[dst]["write"]
+
+    if dst != "pdf":
+        result = _run_pandoc(input_path, output_path, src_fmt=src_fmt, dst_fmt=dst_fmt,
+                              dst=dst, engine=None, extra_args=extra_args)
+        if result.returncode != 0:
+            raise RuntimeError(f"pandoc failed:\n{result.stderr.strip()}")
+        return ConversionResult(output=output_path)
+
+    # PDF: being on PATH doesn't mean an engine actually works (e.g. a LaTeX
+    # install missing lmodern.sty still resolves xelatex on PATH but fails at
+    # render time), so if the user didn't force one, try every available
+    # engine in preference order and only give up once they've all failed.
+    candidates = [pdf_engine] if pdf_engine else _available_pdf_engines()
+    if not candidates:
+        raise RuntimeError(
+            "No PDF engine found. Install one of: xelatex, pdflatex, wkhtmltopdf, "
+            "weasyprint, tectonic (morph can install wkhtmltopdf for you)."
+        )
+
+    errors: list[str] = []
+    import tempfile
+    with tempfile.TemporaryDirectory() as pdftmp:
+        preprocessed_input = _preprocess_svgs(input_path, Path(pdftmp), src)
+        for engine in candidates:
+            result = _run_pandoc(preprocessed_input, output_path, src_fmt=src_fmt, dst_fmt=dst_fmt,
+                                  dst=dst, engine=engine, extra_args=extra_args)
+            if result.returncode == 0:
+                return ConversionResult(output=output_path, pages=_count_pdf_pages(output_path),
+                                         extra={"pdf_engine": engine})
+            errors.append(f"  {engine}: {result.stderr.strip().splitlines()[-1] if result.stderr.strip() else 'failed'}")
+
+    raise RuntimeError(
+        f"All available PDF engines failed ({', '.join(candidates)}):\n" + "\n".join(errors)
+    )
+
+
+def _count_pdf_pages(pdf_path: Path) -> Optional[int]:
+    try:
+        raw = pdf_path.read_bytes()
+        return raw.count(b"/Type/Page") or raw.count(b"/Type /Page") or None
+    except Exception:
+        return None
+
+
+def _make_converter(src: str, dst: str):
+    def _convert(input_path: Path, output_path: Path, **options) -> ConversionResult:
+        return _pandoc_convert(input_path, output_path, src=src, dst=dst, **options)
+    _convert.__name__ = f"convert_{src}_to_{dst}"
+    return _convert
+
+
+_PDF_OPTIONS = [
+    OptionSpec("pdf_engine", ("--pdf-engine",),
+               "Force a specific PDF engine (xelatex, pdflatex, wkhtmltopdf, weasyprint, tectonic). "
+               "Default: try each available one until one works."),
+]
+
+# ── register every valid pandoc pair ────────────────────────────────────────
+for _src, _src_info in FORMATS.items():
+    if _src_info["read"] is None:
+        continue  # pdf: input not supported
+    for _dst, _dst_info in FORMATS.items():
+        if _dst == _src:
+            continue
+        register(
+            _src, _dst,
+            backend="pandoc",
+            requires_binary="pandoc",
+            family="document",
+            description=f"{_src} → {_dst} (pandoc)",
+            lossy=(_dst in ("txt", "pdf")),  # plain text and pdf drop structure/aren't re-editable
+            options=_PDF_OPTIONS if _dst == "pdf" else [],
+        )(_make_converter(_src, _dst))

morph/converters/ebooks.py

@@ -0,0 +1,36 @@
+"""
+converters/ebooks.py — ebook family (epub/mobi/azw3), via calibre's
+ebook-convert. epub -> pdf/docx/html/etc already exist through pandoc
+(documents.py); this file fills in the ebook-reader-specific formats pandoc
+doesn't understand, so mobi and azw3 join the graph and can reach everything
+epub can reach, transitively, for free.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+from ..registry import ConversionResult, register
+
+FORMATS = ["epub", "mobi", "azw3"]
+
+
+def _ebook_convert(input_path: Path, output_path: Path, **_options) -> ConversionResult:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    cmd = ["ebook-convert", str(input_path), str(output_path)]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        tail = "\n".join(result.stderr.strip().splitlines()[-8:] or result.stdout.strip().splitlines()[-8:])
+        raise RuntimeError(f"ebook-convert failed:\n{tail}")
+    return ConversionResult(output=output_path)
+
+
+for _src in FORMATS:
+    for _dst in FORMATS:
+        if _dst == _src:
+            continue
+        register(
+            _src, _dst, backend="calibre", requires_binary="ebook-convert", family="ebook",
+            description=f"{_src} → {_dst} (calibre)",
+        )(_ebook_convert)

morph/converters/fonts.py

@@ -0,0 +1,72 @@
+"""
+converters/fonts.py — font family, powered by fontTools.
+
+ttf/otf are the "raw" outline formats; woff/woff2 are web-compression
+wrappers around the same outline data. fontTools reads any of these and
+re-saves with a different `flavor`, so one function covers every pair.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from fontTools.ttLib import TTFont
+
+from ..registry import ConversionResult, register
+
+# format id -> fontTools "flavor" (None means a bare sfnt: .ttf or .otf)
+_FLAVORS: dict[str, str | None] = {"ttf": None, "otf": None, "woff": "woff", "woff2": "woff2"}
+FORMATS = list(_FLAVORS.keys())
+
+
+def _font_convert(input_path: Path, output_path: Path, dst: str, **_options) -> ConversionResult:
+    font = TTFont(input_path)
+
+    # The real constraint isn't "ttf vs otf" as a pair — it's outline format
+    # (glyf vs CFF/CFF2). woff/woff2 are just compression wrappers around
+    # whichever outline table the font already has, so a multi-hop route
+    # like ttf -> woff -> otf can silently smuggle a glyf-outline font into
+    # a .otf file without ever hitting a direct ttf->otf edge. Check the
+    # actual table contents at every hop that lands on a bare sfnt.
+    if dst == "ttf" and "glyf" not in font:
+        raise RuntimeError(
+            "Refusing to save as .ttf: this font has no 'glyf' outline table "
+            "(it's CFF-based, i.e. really an OTF). fontTools can't convert "
+            "CFF outlines to TrueType outlines by just relabeling the file."
+        )
+    if dst == "otf" and "glyf" in font and "CFF " not in font and "CFF2" not in font:
+        raise RuntimeError(
+            "Refusing to save as .otf: this font has a 'glyf' outline table "
+            "(it's TrueType-based, i.e. really a TTF). fontTools can't convert "
+            "TrueType outlines to CFF outlines by just relabeling the file."
+        )
+
+    font.flavor = _FLAVORS[dst]
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    font.save(str(output_path))
+    name_table = font.get("name")
+    family = None
+    if name_table is not None:
+        family = name_table.getDebugName(1)
+    return ConversionResult(output=output_path, extra={"family": family})
+
+
+def _make_converter(dst: str):
+    def _convert(input_path: Path, output_path: Path, **options) -> ConversionResult:
+        return _font_convert(input_path, output_path, dst, **options)
+    return _convert
+
+
+for _src in FORMATS:
+    for _dst in FORMATS:
+        if _dst == _src:
+            continue
+        # ttf <-> otf both being "no flavor" sfnt containers with genuinely
+        # different outline formats (glyf vs CFF) isn't a safe blind resave —
+        # fontTools won't convert glyph outlines between quadratic/cubic for you.
+        if {_src, _dst} == {"ttf", "otf"}:
+            continue
+        register(
+            _src, _dst, backend="fonttools", family="font",
+            description=f"{_src} → {_dst} (fontTools)",
+        )(_make_converter(_dst))

morph/converters/images.py

@@ -0,0 +1,119 @@
+"""
+converters/images.py — raster image family, powered by Pillow.
+
+Same pattern as documents.py: one shared FORMATS table + one shared convert
+function, looped to register every (src, dst) pair. Pure Python, no external
+binary required, so this domain works the moment `pip install morph` finishes.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+from PIL import Image
+import pillow_heif
+import pillow_avif
+
+pillow_heif.register_heif_opener()
+
+from ..registry import ConversionResult, OptionSpec, register
+
+# format id -> Pillow format name
+FORMATS: dict[str, str] = {
+    "png": "PNG", "jpg": "JPEG", "jpeg": "JPEG", "webp": "WEBP",
+    "bmp": "BMP", "gif": "GIF", "tiff": "TIFF", "ico": "ICO",
+    "heic": "HEIF", "avif": "AVIF", "pdf": "PDF", "icns": "ICNS",
+}
+
+# formats whose writer supports a quality setting
+_QUALITY_FORMATS = {"JPEG", "WEBP", "HEIF", "AVIF"}
+
+# formats that can't store an alpha channel — need RGB flattening first
+_NO_ALPHA_FORMATS = {"JPEG", "BMP", "PDF"}
+
+
+def _parse_resize(spec: str, size: tuple[int, int]) -> tuple[int, int]:
+    """'800x600' -> (800, 600); '800x' or 'x600' keeps the other dimension
+    proportional; a bare '50%' scales both dimensions."""
+    w, h = size
+    if spec.endswith("%"):
+        pct = float(spec[:-1]) / 100
+        return (max(1, round(w * pct)), max(1, round(h * pct)))
+    parts = spec.lower().split("x")
+    if len(parts) != 2:
+        raise ValueError(f"Invalid --resize value: {spec!r} (expected WIDTHxHEIGHT, e.g. 800x600)")
+    new_w = int(parts[0]) if parts[0] else None
+    new_h = int(parts[1]) if parts[1] else None
+    if new_w and not new_h:
+        new_h = round(h * (new_w / w))
+    elif new_h and not new_w:
+        new_w = round(w * (new_h / h))
+    if not new_w or not new_h:
+        raise ValueError(f"Invalid --resize value: {spec!r}")
+    return (new_w, new_h)
+
+
+def _image_convert(input_path: Path, output_path: Path, *, dst_pil: str,
+                    quality: Optional[int] = None, resize: Optional[str] = None,
+                    **_options) -> ConversionResult:
+    img = Image.open(input_path)
+
+    if resize:
+        img = img.resize(_parse_resize(resize, img.size))
+
+    if dst_pil in _NO_ALPHA_FORMATS and img.mode in ("RGBA", "P", "LA"):
+        background = Image.new("RGB", img.size, (255, 255, 255))
+        rgba = img.convert("RGBA")
+        background.paste(rgba, mask=rgba.split()[-1])
+        img = background
+    elif dst_pil == "ICO":
+        img = img.convert("RGBA")
+
+    save_kwargs: dict = {}
+    if quality is not None and dst_pil in _QUALITY_FORMATS:
+        save_kwargs["quality"] = quality
+    if dst_pil == "ICO":
+        save_kwargs["sizes"] = [(s, s) for s in (16, 32, 48, 64, 128, 256) if s <= max(img.size)] or [(256, 256)]
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    img.save(output_path, format=dst_pil, **save_kwargs)
+    return ConversionResult(output=output_path, extra={"size": img.size})
+
+
+def _make_converter(dst_pil: str):
+    def _convert(input_path: Path, output_path: Path, **options) -> ConversionResult:
+        return _image_convert(input_path, output_path, dst_pil=dst_pil, **options)
+    return _convert
+
+
+_OPTIONS_BY_DST = {
+    "jpg": [
+        OptionSpec("quality", ("--quality",), "Output quality 1-100 (JPEG). Default: Pillow's default (~75).", type=int),
+        OptionSpec("resize", ("--resize",), "Resize before saving: '800x600', '800x' (keep ratio), or '50%'."),
+    ],
+    "jpeg": [
+        OptionSpec("quality", ("--quality",), "Output quality 1-100 (JPEG). Default: Pillow's default (~75).", type=int),
+        OptionSpec("resize", ("--resize",), "Resize before saving: '800x600', '800x' (keep ratio), or '50%'."),
+    ],
+    "webp": [
+        OptionSpec("quality", ("--quality",), "Output quality 1-100 (WEBP). Default: 80.", type=int, default=80),
+        OptionSpec("resize", ("--resize",), "Resize before saving: '800x600', '800x' (keep ratio), or '50%'."),
+    ],
+}
+_DEFAULT_OPTIONS = [
+    OptionSpec("resize", ("--resize",), "Resize before saving: '800x600', '800x' (keep ratio), or '50%'."),
+]
+
+for _src in FORMATS:
+    for _dst, _dst_pil in FORMATS.items():
+        if _dst == _src:
+            continue
+        register(
+            _src, _dst,
+            backend="pillow",
+            family="image",
+            description=f"{_src} → {_dst} (Pillow)",
+            lossy=(_dst_pil in _QUALITY_FORMATS or _dst == "ico"),
+            options=_OPTIONS_BY_DST.get(_dst, _DEFAULT_OPTIONS),
+        )(_make_converter(_dst_pil))

morph/converters/json_yaml.py

@@ -0,0 +1,26 @@
+"""converters/json_yaml.py — json <-> yaml, native implementation."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import yaml
+
+from ..registry import ConversionResult, register
+
+
+@register("json", "yaml", backend="native", family="data", description="json → yaml")
+def json_to_yaml(input_path: Path, output_path: Path, **options) -> ConversionResult:
+    data = json.loads(input_path.read_text(encoding="utf-8"))
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(yaml.dump(data, sort_keys=False, allow_unicode=True), encoding="utf-8")
+    return ConversionResult(output=output_path)
+
+
+@register("yaml", "json", backend="native", family="data", description="yaml → json")
+def yaml_to_json(input_path: Path, output_path: Path, **options) -> ConversionResult:
+    data = yaml.safe_load(input_path.read_text(encoding="utf-8"))
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+    return ConversionResult(output=output_path)

morph/converters/models_3d.py

@@ -0,0 +1,149 @@
+"""
+3D Model conversions using the native blender python module (`bpy`).
+Provides format conversions (obj, stl, fbx, gltf, blend) and headless rendering (png).
+"""
+import sys
+import subprocess
+from pathlib import Path
+from typing import Dict, Optional
+
+from ..registry import ConversionResult, register
+
+def _run_bpy_script(script_content: str) -> None:
+    """Run a bpy script in an isolated subprocess to prevent global state corruption/memory leaks."""
+    code = f"""
+import bpy
+import sys
+import os
+
+def main():
+    try:
+        # Clear factory settings first if not loading a blend file
+{script_content}
+    except Exception as e:
+        print(f"ERROR: {{e}}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()
+"""
+    result = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"3D conversion failed.\nStdout: {result.stdout}\nStderr: {result.stderr}")
+
+def _get_import_code(filepath: Path) -> str:
+    ext = filepath.suffix.lower().lstrip('.')
+    path_str = repr(str(filepath.absolute()))
+    
+    if ext == 'blend':
+        return f"        bpy.ops.wm.open_mainfile(filepath={path_str})"
+    elif ext == 'obj':
+        return f"        bpy.ops.wm.obj_import(filepath={path_str})"
+    elif ext == 'stl':
+        return f"        bpy.ops.wm.stl_import(filepath={path_str})"
+    elif ext == 'fbx':
+        return f"        bpy.ops.import_scene.fbx(filepath={path_str})"
+    elif ext in ('gltf', 'glb'):
+        return f"        bpy.ops.import_scene.gltf(filepath={path_str})"
+    else:
+        raise ValueError(f"Unsupported 3D import format: {ext}")
+
+def _get_export_code(filepath: Path) -> str:
+    ext = filepath.suffix.lower().lstrip('.')
+    path_str = repr(str(filepath.absolute()))
+    
+    if ext == 'blend':
+        return f"        bpy.ops.wm.save_as_mainfile(filepath={path_str})"
+    elif ext == 'obj':
+        return f"        bpy.ops.wm.obj_export(filepath={path_str})"
+    elif ext == 'stl':
+        return f"        bpy.ops.wm.stl_export(filepath={path_str})"
+    elif ext == 'fbx':
+        return f"        bpy.ops.export_scene.fbx(filepath={path_str})"
+    elif ext in ('gltf', 'glb'):
+        return f"        bpy.ops.export_scene.gltf(filepath={path_str})"
+    else:
+        raise ValueError(f"Unsupported 3D export format: {ext}")
+
+def _3d_to_3d(input_path: Path, output_path: Path, **kwargs) -> ConversionResult:
+    """Converts a 3D model from one format to another."""
+    import_cmd = _get_import_code(input_path)
+    export_cmd = _get_export_code(output_path)
+    
+    # If the input isn't a blend file, we should clear the default scene first
+    clear_scene_cmd = ""
+    if input_path.suffix.lower() != '.blend':
+        clear_scene_cmd = "        bpy.ops.wm.read_factory_settings(use_empty=True)"
+        
+    script = f"""
+{clear_scene_cmd}
+{import_cmd}
+{export_cmd}
+    """
+    
+    _run_bpy_script(script)
+    return ConversionResult(output_path)
+
+def _3d_to_image(input_path: Path, output_path: Path, **kwargs) -> ConversionResult:
+    """Renders a 3D model into a PNG image headlessly."""
+    import_cmd = _get_import_code(input_path)
+    
+    clear_scene_cmd = ""
+    if input_path.suffix.lower() != '.blend':
+        clear_scene_cmd = "        bpy.ops.wm.read_factory_settings(use_empty=True)"
+        
+    out_path_str = repr(str(output_path.absolute()))
+    
+    script = f"""
+{clear_scene_cmd}
+{import_cmd}
+
+        # Select all objects to find bounding box center
+        bpy.ops.object.select_all(action='SELECT')
+        
+        # Add a camera (if no camera exists)
+        if not any(obj.type == 'CAMERA' for obj in bpy.context.scene.objects):
+            bpy.ops.object.camera_add(location=(10, -10, 10))
+            cam = bpy.context.active_object
+            cam.rotation_euler = (0.9, 0, 0.785)
+            bpy.context.scene.camera = cam
+            
+        # Add light (if no light exists)
+        if not any(obj.type == 'LIGHT' for obj in bpy.context.scene.objects):
+            bpy.ops.object.light_add(type='SUN', location=(5, 5, 5))
+            
+        # Setup render settings
+        bpy.context.scene.render.engine = 'CYCLES'
+        bpy.context.scene.render.filepath = {out_path_str}
+        bpy.context.scene.render.resolution_x = 1024
+        bpy.context.scene.render.resolution_y = 1024
+        
+        # Render
+        bpy.ops.render.render(write_still=True)
+    """
+    
+    _run_bpy_script(script)
+    return ConversionResult(output_path)
+
+
+
+# 3D to 3D conversions
+formats_3d = ['obj', 'stl', 'fbx', 'gltf', 'glb', 'blend']
+for in_ext in formats_3d:
+    for out_ext in formats_3d:
+        if in_ext != out_ext:
+            register(
+                in_ext, out_ext,
+                backend="bpy",
+                family="3d_model",
+                description=f"{in_ext} → {out_ext} (blender/bpy)"
+            )(_3d_to_3d)
+            
+# 3D to Image conversions
+for in_ext in formats_3d:
+    register(
+        in_ext, 'png',
+        backend="bpy",
+        family="3d_model",
+        description=f"{in_ext} → png (blender/bpy headless render)"
+    )(_3d_to_image)