morphconv 1.0.1__py3-none-any.whl

morph/converters/ocr.py

@@ -0,0 +1,49 @@
+"""
+converters/ocr.py — OCR extraction from images via pytesseract (Tesseract).
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import pytesseract
+from PIL import Image
+
+from ..registry import ConversionResult, OptionSpec, register
+from .images import FORMATS as IMAGE_FORMATS
+
+_OCR_OPTIONS = [
+    OptionSpec("lang", ("-l", "--lang"), "Language code(s) for OCR, e.g. 'eng', 'eng+fra'. Default: 'eng'."),
+    OptionSpec("psm", ("--psm",), "Page Segmentation Mode (0-13). Default: 3 (Fully automatic).", type=int),
+]
+
+def _extract_text(input_path: Path, output_path: Path, *, lang: Optional[str] = None, psm: Optional[int] = None, **_options) -> ConversionResult:
+    try:
+        img = Image.open(input_path)
+    except Exception as e:
+        raise RuntimeError(f"Failed to open image for OCR: {e}")
+
+    # Build config string
+    config = ""
+    if psm is not None:
+        config += f"--psm {psm} "
+
+    # Run OCR
+    try:
+        text = pytesseract.image_to_string(img, lang=lang, config=config.strip())
+    except pytesseract.TesseractNotFoundError:
+        raise RuntimeError("tesseract executable not found. Please install Tesseract OCR and ensure it is on your PATH.")
+    except Exception as e:
+        raise RuntimeError(f"OCR failed: {e}")
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(text, encoding="utf-8")
+    
+    return ConversionResult(output=output_path)
+
+# Register from all valid image inputs to txt
+for _src in IMAGE_FORMATS:
+    register(
+        _src, "txt", backend="tesseract", requires_binary="tesseract", family="ocr",
+        description=f"{_src} → txt (OCR)", lossy=True, options=_OCR_OPTIONS
+    )(_extract_text)

morph/converters/pandas_extra.py

@@ -0,0 +1,127 @@
+"""
+converters/pandas_extra.py — additional data formats supported natively by pandas.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+import pandas as pd
+from sqlalchemy import create_engine, inspect
+
+from ..registry import ConversionResult, register, OptionSpec
+
+def _read_csv(path: Path) -> pd.DataFrame:
+    return pd.read_csv(path, keep_default_na=True)
+
+# ── Parquet ───────────────────────────────────────────────────────────────────
+@register("csv", "parquet", backend="native", family="data", description="csv → parquet")
+def csv_to_parquet(input_path: Path, output_path: Path, **options) -> ConversionResult:
+    df = _read_csv(input_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_parquet(output_path, index=False)
+    return ConversionResult(output=output_path, rows=len(df))
+
+@register("parquet", "csv", backend="native", family="data", description="parquet → csv")
+def parquet_to_csv(input_path: Path, output_path: Path, **options) -> ConversionResult:
+    df = pd.read_parquet(input_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_csv(output_path, index=False)
+    return ConversionResult(output=output_path, rows=len(df))
+
+# ── Feather ───────────────────────────────────────────────────────────────────
+@register("csv", "feather", backend="native", family="data", description="csv → feather")
+def csv_to_feather(input_path: Path, output_path: Path, **options) -> ConversionResult:
+    df = _read_csv(input_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_feather(output_path)
+    return ConversionResult(output=output_path, rows=len(df))
+
+@register("feather", "csv", backend="native", family="data", description="feather → csv")
+def feather_to_csv(input_path: Path, output_path: Path, **options) -> ConversionResult:
+    df = pd.read_feather(input_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_csv(output_path, index=False)
+    return ConversionResult(output=output_path, rows=len(df))
+
+# ── ODS ───────────────────────────────────────────────────────────────────────
+@register("csv", "ods", backend="native", family="data", description="csv → ods")
+def csv_to_ods(input_path: Path, output_path: Path, **options) -> ConversionResult:
+    df = _read_csv(input_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_excel(output_path, index=False, engine="odf")
+    return ConversionResult(output=output_path, rows=len(df))
+
+@register("ods", "csv", backend="native", family="data", description="ods → csv")
+def ods_to_csv(input_path: Path, output_path: Path, **options) -> ConversionResult:
+    df = pd.read_excel(input_path, engine="odf")
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_csv(output_path, index=False)
+    return ConversionResult(output=output_path, rows=len(df))
+
+# ── XML ───────────────────────────────────────────────────────────────────────
+@register("csv", "xml", backend="native", family="data", description="csv → xml")
+def csv_to_xml(input_path: Path, output_path: Path, **options) -> ConversionResult:
+    df = _read_csv(input_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_xml(output_path, index=False)
+    return ConversionResult(output=output_path, rows=len(df))
+
+@register("xml", "csv", backend="native", family="data", description="xml → csv")
+def xml_to_csv(input_path: Path, output_path: Path, **options) -> ConversionResult:
+    df = pd.read_xml(input_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_csv(output_path, index=False)
+    return ConversionResult(output=output_path, rows=len(df))
+
+# ── HTML ──────────────────────────────────────────────────────────────────────
+@register("csv", "html", backend="native", family="data", description="csv → html (table)")
+def csv_to_html(input_path: Path, output_path: Path, **options) -> ConversionResult:
+    df = _read_csv(input_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_html(output_path, index=False)
+    return ConversionResult(output=output_path, rows=len(df))
+
+@register("html", "csv", backend="native", family="data", description="html (first table) → csv")
+def html_to_csv(input_path: Path, output_path: Path, **options) -> ConversionResult:
+    dfs = pd.read_html(input_path)
+    if not dfs:
+        raise ValueError("No tables found in HTML")
+    df = dfs[0]
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_csv(output_path, index=False)
+    return ConversionResult(output=output_path, rows=len(df))
+
+# ── SQLite ────────────────────────────────────────────────────────────────────
+_SQLITE_IN_OPTIONS = [
+    OptionSpec("table", ("--table",), "Table name to read from SQLite. Defaults to the first table found."),
+]
+
+@register("sqlite", "csv", backend="native", family="data", description="sqlite → csv", options=_SQLITE_IN_OPTIONS)
+def sqlite_to_csv(input_path: Path, output_path: Path, *, table: str | None = None, **options) -> ConversionResult:
+    engine = create_engine(f"sqlite:///{input_path.absolute()}")
+    
+    if not table:
+        inspector = inspect(engine)
+        tables = inspector.get_table_names()
+        if not tables:
+            raise ValueError(f"No tables found in {input_path}")
+        table = tables[0]
+        
+    df = pd.read_sql_table(table, engine)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_csv(output_path, index=False)
+    return ConversionResult(output=output_path, rows=len(df))
+
+_SQLITE_OUT_OPTIONS = [
+    OptionSpec("table", ("--table",), "Table name to write to SQLite. Defaults to the file stem."),
+]
+
+@register("csv", "sqlite", backend="native", family="data", description="csv → sqlite", options=_SQLITE_OUT_OPTIONS)
+def csv_to_sqlite(input_path: Path, output_path: Path, *, table: str | None = None, **options) -> ConversionResult:
+    df = _read_csv(input_path)
+    if not table:
+        table = input_path.stem
+    
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    engine = create_engine(f"sqlite:///{output_path.absolute()}")
+    df.to_sql(table, engine, index=False, if_exists="replace")
+    return ConversionResult(output=output_path, rows=len(df))

morph/converters/svg.py

@@ -0,0 +1,63 @@
+"""
+converters/svg.py — SVG family, powered by cairosvg.
+
+SVG is output-only in reverse (raster -> vector requires actual tracing,
+which is a fundamentally different, much lossier operation morph doesn't
+attempt) — so this file only registers svg -> {png, jpg, pdf}.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+from ..registry import ConversionResult, OptionSpec, register
+
+_RASTER_OPTIONS = [
+    OptionSpec("width", ("--width",), "Output width in pixels. Default: SVG's intrinsic size.", type=int),
+    OptionSpec("height", ("--height",), "Output height in pixels. Default: SVG's intrinsic size / aspect-correct.", type=int),
+    OptionSpec("background", ("--background",), "Background color for transparent areas, e.g. 'white' or '#fff'. "
+               "Default: transparent (png) / white (jpg)."),
+]
+
+
+def _svg_to_png(input_path: Path, output_path: Path, *, width: Optional[int] = None,
+                 height: Optional[int] = None, background: Optional[str] = None,
+                 **_options) -> ConversionResult:
+    import cairosvg
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    cairosvg.svg2png(url=str(input_path), write_to=str(output_path),
+                      output_width=width, output_height=height, background_color=background)
+    return ConversionResult(output=output_path)
+
+
+def _svg_to_jpg(input_path: Path, output_path: Path, *, width: Optional[int] = None,
+                 height: Optional[int] = None, background: Optional[str] = None,
+                 **_options) -> ConversionResult:
+    # cairosvg has no native JPEG writer — render to PNG in memory, then let
+    # Pillow flatten transparency and encode as JPEG.
+    import io
+    import cairosvg
+    from PIL import Image
+
+    png_bytes = cairosvg.svg2png(url=str(input_path), output_width=width, output_height=height,
+                                  background_color=background or "white")
+    img = Image.open(io.BytesIO(png_bytes)).convert("RGB")
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    img.save(output_path, format="JPEG")
+    return ConversionResult(output=output_path)
+
+
+def _svg_to_pdf(input_path: Path, output_path: Path, **_options) -> ConversionResult:
+    import cairosvg
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    cairosvg.svg2pdf(url=str(input_path), write_to=str(output_path))
+    return ConversionResult(output=output_path)
+
+
+register("svg", "png", backend="cairosvg", family="image",
+          description="svg → png (rasterize)", options=_RASTER_OPTIONS)(_svg_to_png)
+register("svg", "jpg", backend="cairosvg", family="image",
+          description="svg → jpg (rasterize, flattened)", lossy=True, options=_RASTER_OPTIONS)(_svg_to_jpg)
+register("svg", "pdf", backend="cairosvg", family="document",
+          description="svg → pdf (vector-preserving)")(_svg_to_pdf)

morph/converters/video.py

@@ -0,0 +1,153 @@
+"""
+converters/video.py — video family, powered by ffmpeg.
+
+Includes two genuinely useful cross-domain edges beyond video<->video:
+  • video -> audio  (extract the audio track, e.g. mp4 -> mp3)
+  • video -> gif    (short animated clips; palette-generated for quality)
+
+Every hop reports real fractional progress via ffmpeg's -progress stream.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+from ..ffmpeg_utils import ProgressCallback, run_ffmpeg
+from ..registry import ConversionResult, OptionSpec, register
+from .audio import FORMATS as AUDIO_FORMATS
+
+FORMATS = ["mp4", "mkv", "mov", "webm", "avi", "flv", "wmv", "mpeg"]
+
+_COMMON_OPTIONS = [
+    OptionSpec("resolution", ("--resolution",), "Output resolution, e.g. '1280x720'. Default: keep source size."),
+    OptionSpec("fps", ("--fps",), "Output frame rate.", type=int),
+    OptionSpec("crf", ("--crf",), "Quality (lower = better/larger, 0-51). Default: encoder default (~23).", type=int),
+    OptionSpec("video_codec", ("--vcodec",), "Force a video codec, e.g. 'libx264', 'libvpx-vp9'."),
+    OptionSpec("audio_codec", ("--acodec",), "Force an audio codec, e.g. 'aac', 'libopus'."),
+    OptionSpec("no_audio", ("--no-audio",), "Strip the audio track entirely.", default=False, action="store_true"),
+    OptionSpec("start", ("--start",), "Trim start, e.g. '00:00:10' or seconds."),
+    OptionSpec("duration", ("--duration",), "Trim duration, e.g. '00:00:05' or seconds."),
+]
+
+
+def _input_seek_args(start: Optional[str], duration: Optional[str]) -> list[str]:
+    args = []
+    if start:
+        args += ["-ss", str(start)]
+    if duration:
+        args += ["-t", str(duration)]
+    return args
+
+
+def _video_convert(input_path: Path, output_path: Path, *, resolution: Optional[str] = None,
+                    fps: Optional[int] = None, crf: Optional[int] = None,
+                    video_codec: Optional[str] = None, audio_codec: Optional[str] = None,
+                    no_audio: bool = False, start: Optional[str] = None,
+                    duration: Optional[str] = None, _progress: Optional[ProgressCallback] = None,
+                    **_options) -> ConversionResult:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    cmd = ["ffmpeg", "-y", "-loglevel", "error", *_input_seek_args(start, duration), "-i", str(input_path)]
+
+    vf = []
+    if resolution:
+        w, h = resolution.lower().split("x")
+        vf.append(f"scale={w}:{h}")
+    if fps:
+        cmd += ["-r", str(fps)]
+    if vf:
+        cmd += ["-vf", ",".join(vf)]
+    if crf is not None:
+        cmd += ["-crf", str(crf)]
+    if video_codec:
+        cmd += ["-c:v", video_codec]
+    if no_audio:
+        cmd.append("-an")
+    elif audio_codec:
+        cmd += ["-c:a", audio_codec]
+
+    cmd.append(str(output_path))
+    run_ffmpeg(cmd, input_path=input_path, progress=_progress)
+    return ConversionResult(output=output_path)
+
+
+def _extract_audio(input_path: Path, output_path: Path, *, bitrate: Optional[str] = None,
+                    sample_rate: Optional[int] = None, channels: Optional[int] = None,
+                    _progress: Optional[ProgressCallback] = None, **_options) -> ConversionResult:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    cmd = ["ffmpeg", "-y", "-loglevel", "error", "-i", str(input_path), "-vn"]
+    if bitrate:
+        cmd += ["-b:a", bitrate]
+    if sample_rate:
+        cmd += ["-ar", str(sample_rate)]
+    if channels:
+        cmd += ["-ac", str(channels)]
+    cmd.append(str(output_path))
+    run_ffmpeg(cmd, input_path=input_path, progress=_progress)
+    return ConversionResult(output=output_path)
+
+
+_GIF_OPTIONS = [
+    OptionSpec("fps", ("--fps",), "Gif frame rate.", type=int, default=10),
+    OptionSpec("width", ("--width",), "Gif width in pixels (height auto-scales). Default: 480.", type=int, default=480),
+    OptionSpec("start", ("--start",), "Trim start, e.g. '00:00:10' or seconds."),
+    OptionSpec("duration", ("--duration",), "Trim duration, e.g. '00:00:05' or seconds. Recommended for long videos."),
+]
+
+
+def _to_animated(input_path: Path, output_path: Path, *, fps: int = 10, width: int = 480,
+            start: Optional[str] = None, duration: Optional[str] = None,
+            _progress: Optional[ProgressCallback] = None, **_options) -> ConversionResult:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    vf = f"fps={fps},scale={width}:-1:flags=lanczos"
+    cmd = ["ffmpeg", "-y", "-loglevel", "error", *_input_seek_args(start, duration),
+           "-i", str(input_path), "-vf", vf, "-loop", "0", str(output_path)]
+    run_ffmpeg(cmd, input_path=input_path, progress=_progress)
+    return ConversionResult(output=output_path, extra={"note": "single-pass palette; use --fps/--width to tune size"})
+
+
+# video <-> video
+for _src in FORMATS:
+    for _dst in FORMATS:
+        if _dst == _src:
+            continue
+        register(
+            _src, _dst, backend="ffmpeg", requires_binary="ffmpeg", family="video",
+            description=f"{_src} → {_dst} (ffmpeg)", options=_COMMON_OPTIONS, supports_progress=True,
+        )(_video_convert)
+
+# video -> audio (extract track)
+_EXTRACT_AUDIO_OPTIONS = [
+    OptionSpec("bitrate", ("-b", "--bitrate"), "Audio bitrate, e.g. '192k'."),
+    OptionSpec("sample_rate", ("--sample-rate",), "Output sample rate in Hz.", type=int),
+    OptionSpec("channels", ("--channels",), "Output channel count: 1 or 2.", type=int),
+]
+for _src in FORMATS:
+    for _dst in AUDIO_FORMATS:
+        register(
+            _src, _dst, backend="ffmpeg", requires_binary="ffmpeg", family="video",
+            description=f"{_src} → {_dst} (extract audio track)", lossy=True,
+            options=_EXTRACT_AUDIO_OPTIONS, supports_progress=True,
+        )(_extract_audio)
+
+# video -> gif / webp
+for _src in FORMATS:
+    for _dst in ("gif", "webp"):
+        register(
+            _src, _dst, backend="ffmpeg", requires_binary="ffmpeg", family="video",
+            description=f"{_src} → {_dst}", lossy=True, options=_GIF_OPTIONS, supports_progress=True,
+        )(_to_animated)
+
+# video -> subtitles
+def _extract_subs(input_path: Path, output_path: Path, **_options) -> ConversionResult:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    cmd = ["ffmpeg", "-y", "-loglevel", "error", "-i", str(input_path), "-map", "0:s:0", str(output_path)]
+    run_ffmpeg(cmd, input_path=input_path)
+    return ConversionResult(output=output_path)
+
+for _src in FORMATS:
+    for _dst in ("srt", "vtt"):
+        register(
+            _src, _dst, backend="ffmpeg", requires_binary="ffmpeg", family="video",
+            description=f"{_src} → {_dst} (extract subtitles)", lossy=True,
+        )(_extract_subs)

morph/converters/vtracer_converter.py

@@ -0,0 +1,84 @@
+"""
+converters/vtracer_converter.py — raster-to-SVG vectorization wrapper, powered by vtracer.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+from ..registry import ConversionResult, OptionSpec, register
+
+OPTIONS = [
+    OptionSpec("mode", ("--mode",), "Curve fitting mode ('spline' for smooth curves, 'polygon' for sharp shapes).", default="spline"),
+    OptionSpec("colormode", ("--colormode",), "Color mode ('color' or 'binary').", default="color"),
+    OptionSpec("hierarchical", ("--hierarchical",), "Shape layout style ('stacked' for layered shapes, 'cutout' for no overlaps).", default="stacked"),
+    OptionSpec("filter_speckle", ("--filter-speckle",), "Filter speckle noise (pixels, e.g. 4).", default=4, type=int),
+    OptionSpec("color_precision", ("--color-precision",), "Color precision (number of significant bits, 1-8).", default=6, type=int),
+    OptionSpec("layer_difference", ("--layer-difference",), "Color difference threshold for layering (1-255).", default=16, type=int),
+    OptionSpec("corner_threshold", ("--corner-threshold",), "Corner threshold (degrees, 0-180).", default=60, type=int),
+    OptionSpec("length_threshold", ("--length-threshold",), "Length threshold for splines.", default=4.0, type=float),
+    OptionSpec("max_iterations", ("--max-iterations",), "Max iterations for spline fitting.", default=10, type=int),
+    OptionSpec("splice_threshold", ("--splice-threshold",), "Splice threshold (degrees, 0-180).", default=45, type=int),
+    OptionSpec("path_precision", ("--path-precision",), "Path decimal precision (number of decimal places).", default=2, type=int),
+]
+
+
+def _image_to_svg(
+    input_path: Path,
+    output_path: Path,
+    *,
+    mode: str = "spline",
+    colormode: str = "color",
+    hierarchical: str = "stacked",
+    filter_speckle: int = 4,
+    color_precision: int = 6,
+    layer_difference: int = 16,
+    corner_threshold: int = 60,
+    length_threshold: float = 4.0,
+    max_iterations: int = 10,
+    splice_threshold: int = 45,
+    path_precision: int = 2,
+    **_options,
+) -> ConversionResult:
+    import subprocess
+    import sys
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    code = f"""
+import vtracer
+vtracer.convert_image_to_svg_py(
+    {repr(str(input_path))},
+    {repr(str(output_path))},
+    {repr(colormode)},
+    {repr(hierarchical)},
+    {repr(mode)},
+    {filter_speckle},
+    {color_precision},
+    {layer_difference},
+    {corner_threshold},
+    {length_threshold},
+    {max_iterations},
+    {splice_threshold},
+    {path_precision}
+)
+"""
+    result = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"vtracer tracing failed:\n{result.stderr.strip()}")
+        
+    return ConversionResult(output=output_path)
+
+
+# Register all common raster formats to SVG
+for src in ("png", "jpg", "jpeg", "webp", "bmp", "tiff", "gif"):
+    register(
+        src,
+        "svg",
+        backend="vtracer",
+        family="image",
+        description=f"{src} → svg (vectorize via vtracer)",
+        lossy=True,
+        options=OPTIONS,
+    )(_image_to_svg)

morph/converters/web.py

@@ -0,0 +1,92 @@
+"""
+converters/web.py — extract clean documents from URLs.
+
+Powered by `trafilatura`.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import trafilatura
+
+from ..registry import ConversionResult, register
+
+
+def _fetch_static(url: str, output_format: str) -> str:
+    downloaded = trafilatura.fetch_url(url)
+    if not downloaded:
+        raise RuntimeError(f"Failed to fetch {url}")
+        
+    if output_format == "html_raw":
+        return downloaded
+        
+    result = trafilatura.extract(downloaded, output_format=output_format)
+    if not result:
+        raise RuntimeError(f"Failed to extract content from {url} (it might be empty or a captcha)")
+    return result
+
+
+def _fetch_dynamic(url: str, output_format: str) -> str:
+    import asyncio
+    
+    try:
+        from crawl4ai import AsyncWebCrawler
+    except ImportError:
+        raise RuntimeError("crawl4ai is required for --js, but it's not installed.")
+        
+    async def run():
+        async with AsyncWebCrawler() as crawler:
+            return await crawler.arun(url)
+            
+    result = asyncio.run(run())
+    if not result.success:
+        raise RuntimeError(f"Failed to crawl {url} with JS: {result.error_message}")
+        
+    if output_format == "markdown":
+        return result.markdown
+    if output_format == "html_raw":
+        return result.html
+        
+    # for txt and xml, fallback to trafilatura but feed it the JS-rendered HTML
+    content = trafilatura.extract(result.html, output_format=output_format)
+    if not content:
+        raise RuntimeError(f"Failed to extract {output_format} from JS-rendered content.")
+    return content
+
+
+@register("url", "md", backend="trafilatura", family="web", description="url → md (clean article)")
+def url_to_md(input_path: str | Path, output_path: Path, **options) -> ConversionResult:
+    url = str(input_path)
+    content = _fetch_dynamic(url, "markdown") if options.get("js") else _fetch_static(url, "markdown")
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(content, encoding="utf-8")
+    return ConversionResult(output=output_path)
+
+
+@register("url", "txt", backend="trafilatura", family="web", description="url → txt (clean article)")
+def url_to_txt(input_path: str | Path, output_path: Path, **options) -> ConversionResult:
+    url = str(input_path)
+    content = _fetch_dynamic(url, "txt") if options.get("js") else _fetch_static(url, "txt")
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(content, encoding="utf-8")
+    return ConversionResult(output=output_path)
+
+
+@register("url", "xml", backend="trafilatura", family="web", description="url → xml (clean article tree)")
+def url_to_xml(input_path: str | Path, output_path: Path, **options) -> ConversionResult:
+    url = str(input_path)
+    content = _fetch_dynamic(url, "xml") if options.get("js") else _fetch_static(url, "xml")
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(content, encoding="utf-8")
+    return ConversionResult(output=output_path)
+
+
+@register("url", "html", backend="trafilatura", family="web", description="url → html (raw dump)")
+def url_to_html(input_path: str | Path, output_path: Path, **options) -> ConversionResult:
+    url = str(input_path)
+    content = _fetch_dynamic(url, "html_raw") if options.get("js") else _fetch_static(url, "html_raw")
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(content, encoding="utf-8")
+    return ConversionResult(output=output_path)
+