figquilt 0.1.1__tar.gz → 0.1.3__tar.gz

{figquilt-0.1.1 → figquilt-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: figquilt
-Version: 0.1.1
+Version: 0.1.3
 Summary: figquilt is a small, language-agnostic CLI tool that composes multiple figures (PDF/SVG/PNG) into a single publication-ready figure, based on a simple layout file (YAML/JSON). The key function is creating a PDF by composing multiple PDFs and adding subfigure labels and minimal annotations.
 Author: YY Ahn
 Author-email: YY Ahn <yongyeol@gmail.com>
@@ -16,6 +16,7 @@ Requires-Dist: pydantic>=2.12.5
 Requires-Dist: pymupdf>=1.26.6
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: seaborn>=0.13.2
+Requires-Dist: watchfiles>=1.0.0
 Requires-Python: >=3.12
 Project-URL: Homepage, https://github.com/yy/figquilt
 Project-URL: Repository, https://github.com/yy/figquilt
@@ -23,9 +24,16 @@ Description-Content-Type: text/markdown
 
 # figquilt
 
-**Figure quilter**: A CLI tool to compositing multiple figures (PDF, SVG, PNG) into a publication-ready figure layout.
+**Figure quilter**: A declarative CLI tool for compositing multiple figures (PDF, SVG, PNG) into publication-ready layouts.
 
-`figquilt` takes a simple layout file (YAML) describing panels and their positions, composed of various inputs (plots from R/Python, diagrams, photos), and stitches them into a single output file (PDF, SVG) with precise dimension control and automatic labeling.
+`figquilt` takes a simple layout file (YAML) describing panels and their structure, composed of various inputs (plots from R/Python, diagrams, photos), and stitches them into a single output file (PDF, SVG) with automatic labeling and precise dimension control.
+
+## Philosophy
+
+- **Declarative over imperative**: Describe *what* your figure should look like, not *how* to construct it. Layouts are data, not scripts.
+- **Structural composition first**: Prefer high-level layout (rows, columns, ratios) over manual coordinate placement. Let the tool handle positioning.
+- **Fine control when needed**: Override with explicit coordinates and dimensions when precision matters.
+- **Automation-friendly**: Designed to fit into reproducible workflows (Snakemake, Make, CI pipelines). No GUI, no manual steps.
 
 ## Features
 
@@ -81,4 +89,14 @@ Run `figquilt` to generate the figure:
 
 ```bash
 figquilt figure1.yaml figure1.pdf
-```
+```
+
+### Watch Mode
+
+Use `--watch` to automatically rebuild when the layout file or any panel source files change:
+
+```bash
+figquilt --watch figure1.yaml figure1.pdf
+```
+
+This is useful during layout iteration - edit your YAML or regenerate a panel, and the output updates automatically.

{figquilt-0.1.1 → figquilt-0.1.3}/README.md

@@ -1,8 +1,15 @@
 # figquilt
 
-**Figure quilter**: A CLI tool to compositing multiple figures (PDF, SVG, PNG) into a publication-ready figure layout.
+**Figure quilter**: A declarative CLI tool for compositing multiple figures (PDF, SVG, PNG) into publication-ready layouts.
 
-`figquilt` takes a simple layout file (YAML) describing panels and their positions, composed of various inputs (plots from R/Python, diagrams, photos), and stitches them into a single output file (PDF, SVG) with precise dimension control and automatic labeling.
+`figquilt` takes a simple layout file (YAML) describing panels and their structure, composed of various inputs (plots from R/Python, diagrams, photos), and stitches them into a single output file (PDF, SVG) with automatic labeling and precise dimension control.
+
+## Philosophy
+
+- **Declarative over imperative**: Describe *what* your figure should look like, not *how* to construct it. Layouts are data, not scripts.
+- **Structural composition first**: Prefer high-level layout (rows, columns, ratios) over manual coordinate placement. Let the tool handle positioning.
+- **Fine control when needed**: Override with explicit coordinates and dimensions when precision matters.
+- **Automation-friendly**: Designed to fit into reproducible workflows (Snakemake, Make, CI pipelines). No GUI, no manual steps.
 
 ## Features
 
@@ -58,4 +65,14 @@ Run `figquilt` to generate the figure:
 
 ```bash
 figquilt figure1.yaml figure1.pdf
-```
+```
+
+### Watch Mode
+
+Use `--watch` to automatically rebuild when the layout file or any panel source files change:
+
+```bash
+figquilt --watch figure1.yaml figure1.pdf
+```
+
+This is useful during layout iteration - edit your YAML or regenerate a panel, and the output updates automatically.

{figquilt-0.1.1 → figquilt-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "figquilt"
-version = "0.1.1"
+version = "0.1.3"
 description = "figquilt is a small, language-agnostic CLI tool that composes multiple figures (PDF/SVG/PNG) into a single publication-ready figure, based on a simple layout file (YAML/JSON). The key function is creating a PDF by composing multiple PDFs and adding subfigure labels and minimal annotations."
 readme = "README.md"
 authors = [
@@ -22,6 +22,7 @@ dependencies = [
     "pymupdf>=1.26.6",
     "pyyaml>=6.0.3",
     "seaborn>=0.13.2",
+    "watchfiles>=1.0.0",
 ]
 
 [project.scripts]

figquilt-0.1.3/src/figquilt/cli.py

@@ -0,0 +1,217 @@
+import argparse
+import sys
+from pathlib import Path
+from typing import Optional, Set, Tuple
+import threading
+
+from .parser import parse_layout
+from .errors import FigQuiltError
+from .layout import Layout
+
+
+def get_watched_paths(layout_path: Path, layout: Layout) -> Tuple[Set[Path], Set[Path]]:
+    """
+    Return the set of files and directories to watch.
+
+    Returns:
+        Tuple of (watched_files, watched_dirs)
+    """
+    layout_path = layout_path.resolve()
+    files = {layout_path}
+    for panel in layout.panels:
+        files.add(panel.file.resolve())
+    dirs = {f.parent for f in files}
+    return files, dirs
+
+
+def compose_figure(
+    layout_path: Path, output_path: Path, fmt: str, verbose: bool
+) -> bool:
+    """
+    Compose a figure from a layout file.
+
+    Returns True on success, False on error.
+    """
+    try:
+        layout = parse_layout(layout_path)
+        if verbose:
+            print(f"Layout parsed: {layout_path}")
+            print(
+                f"Page size: {layout.page.width}x{layout.page.height} {layout.page.units}"
+            )
+            print(f"Panels: {len(layout.panels)}")
+
+        if fmt == "pdf":
+            from .compose_pdf import PDFComposer
+
+            composer = PDFComposer(layout)
+            composer.compose(output_path)
+
+        elif fmt == "svg":
+            from .compose_svg import SVGComposer
+
+            composer = SVGComposer(layout)
+            composer.compose(output_path)
+
+        elif fmt == "png":
+            from .compose_pdf import PDFComposer
+
+            composer = PDFComposer(layout)
+            doc = composer.build()
+            page = doc[0]
+            pix = page.get_pixmap(dpi=layout.page.dpi)
+            pix.save(str(output_path))
+            doc.close()
+
+        else:
+            print(f"Unsupported format: {fmt}", file=sys.stderr)
+            return False
+
+        return True
+
+    except FigQuiltError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return False
+    except Exception as e:
+        print(f"Unexpected error: {e}", file=sys.stderr)
+        return False
+
+
+def run_watch_mode(
+    layout_path: Path,
+    output_path: Path,
+    fmt: str,
+    verbose: bool,
+    stop_event: Optional[threading.Event] = None,
+) -> None:
+    """
+    Watch layout and panel files for changes and rebuild on each change.
+
+    Args:
+        layout_path: Path to the layout YAML file
+        output_path: Path to the output file
+        fmt: Output format (pdf, svg, png)
+        verbose: Whether to print verbose output
+        stop_event: Optional threading event to stop watching (for testing)
+    """
+    from watchfiles import watch
+
+    print("Watching for changes... (Ctrl+C to stop)")
+
+    # Initial build
+    if compose_figure(layout_path, output_path, fmt, verbose):
+        print(f"Created: {output_path}")
+    else:
+        print("Initial build failed, watching for changes...")
+
+    # Get initial set of watched files and directories
+    try:
+        layout = parse_layout(layout_path)
+        watched_files, watch_dirs = get_watched_paths(layout_path, layout)
+    except FigQuiltError:
+        # If layout is invalid, just watch the layout file itself
+        layout_path_resolved = layout_path.resolve()
+        watched_files = {layout_path_resolved}
+        watch_dirs = {layout_path_resolved.parent}
+
+    while True:
+        restart_watcher = False
+
+        for changes in watch(*watch_dirs, stop_event=stop_event):
+            if stop_event and stop_event.is_set():
+                return
+
+            # Check if any changed file is in our watched set
+            changed_paths = {Path(change[1]).resolve() for change in changes}
+            relevant_changes = changed_paths & watched_files
+
+            if relevant_changes:
+                if verbose:
+                    for p in relevant_changes:
+                        print(f"Changed: {p}")
+
+                print("Rebuilding...", end=" ", flush=True)
+                if compose_figure(layout_path, output_path, fmt, verbose):
+                    print(f"done: {output_path}")
+                else:
+                    print("failed")
+
+                # Re-parse layout to update watched files (panels might have changed)
+                try:
+                    layout = parse_layout(layout_path)
+                    new_files, new_dirs = get_watched_paths(layout_path, layout)
+                    if new_dirs != watch_dirs:
+                        # Directories changed, need to restart the watcher
+                        watched_files = new_files
+                        watch_dirs = new_dirs
+                        restart_watcher = True
+                        if verbose:
+                            print("Watch directories changed, restarting watcher...")
+                        break
+                    watched_files = new_files
+                except FigQuiltError:
+                    pass  # Keep watching existing files if layout is invalid
+
+        if stop_event and stop_event.is_set():
+            return
+        if not restart_watcher:
+            break
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="FigQuilt: Compose figures from multiple panels."
+    )
+    parser.add_argument("layout", type=Path, help="Path to layout YAML file")
+    parser.add_argument("output", type=Path, help="Path to output file (PDF/SVG/PNG)")
+    parser.add_argument(
+        "--format", choices=["pdf", "svg", "png"], help="Override output format"
+    )
+    parser.add_argument("--check", action="store_true", help="Validate layout only")
+    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
+    parser.add_argument(
+        "--watch", action="store_true", help="Watch for changes and rebuild"
+    )
+
+    args = parser.parse_args()
+
+    # Determine output format
+    suffix = args.output.suffix.lower()
+    fmt = args.format or suffix.lstrip(".")
+
+    if fmt not in ("pdf", "svg", "png"):
+        print(f"Unsupported format: {fmt}", file=sys.stderr)
+        sys.exit(1)
+
+    # Check-only mode
+    if args.check:
+        try:
+            layout = parse_layout(args.layout)
+            print(f"Layout parsed successfully: {args.layout}")
+            print(
+                f"Page size: {layout.page.width}x{layout.page.height} {layout.page.units}"
+            )
+            print(f"Panels: {len(layout.panels)}")
+            sys.exit(0)
+        except FigQuiltError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+
+    # Watch mode
+    if args.watch:
+        try:
+            run_watch_mode(args.layout, args.output, fmt, args.verbose)
+        except KeyboardInterrupt:
+            print("\nStopped watching.")
+            sys.exit(0)
+        return
+
+    # Single build mode
+    if compose_figure(args.layout, args.output, fmt, args.verbose):
+        print(f"Successfully created: {args.output}")
+    else:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

{figquilt-0.1.1 → figquilt-0.1.3}/src/figquilt/compose_pdf.py

@@ -1,14 +1,16 @@
 import fitz
 from pathlib import Path
 from .layout import Layout, Panel
-from .units import mm_to_pt
+from .units import mm_to_pt, to_pt
 from .errors import FigQuiltError
 
+
 class PDFComposer:
     def __init__(self, layout: Layout):
         self.layout = layout
-        self.width_pt = mm_to_pt(layout.page.width)
-        self.height_pt = mm_to_pt(layout.page.height)
+        self.units = layout.page.units
+        self.width_pt = to_pt(layout.page.width, self.units)
+        self.height_pt = to_pt(layout.page.height, self.units)
 
     def compose(self, output_path: Path):
         doc = self.build()
@@ -29,20 +31,20 @@ class PDFComposer:
             # Minimal hex parser:
             col = self._parse_color(self.layout.page.background)
             if col:
-                 page.draw_rect(page.rect, color=col, fill=col)
+                page.draw_rect(page.rect, color=col, fill=col)
 
         # Draw panels
         for i, panel in enumerate(self.layout.panels):
             self._place_panel(doc, page, panel, index=i)
-        
+
         return doc
-    
+
     def _parse_color(self, color_str: str):
         # Very basic hex support
         if color_str.startswith("#"):
-            h = color_str.lstrip('#')
+            h = color_str.lstrip("#")
             try:
-                rgb = tuple(int(h[i:i+2], 16)/255.0 for i in (0, 2, 4))
+                rgb = tuple(int(h[i : i + 2], 16) / 255.0 for i in (0, 2, 4))
                 return rgb
             except:
                 return None
@@ -52,17 +54,20 @@ class PDFComposer:
         # We process images, so PIL is available.
         try:
             from PIL import ImageColor
+
             rgb = ImageColor.getrgb(color_str)
-            return tuple(c/255.0 for c in rgb)
+            return tuple(c / 255.0 for c in rgb)
         except:
-             return None
+            return None
 
-    def _place_panel(self, doc: fitz.Document, page: fitz.Page, panel: Panel, index: int):
+    def _place_panel(
+        self, doc: fitz.Document, page: fitz.Page, panel: Panel, index: int
+    ):
         # Calculate position and size first
-        x = mm_to_pt(panel.x)
-        y = mm_to_pt(panel.y)
-        w = mm_to_pt(panel.width)
-        
+        x = to_pt(panel.x, self.units)
+        y = to_pt(panel.y, self.units)
+        w = to_pt(panel.width, self.units)
+
         # Determine height from aspect ratio if needed
         # We need to open the source to get aspect ratio
         try:
@@ -71,35 +76,41 @@ class PDFComposer:
         except Exception as e:
             raise FigQuiltError(f"Failed to open panel file {panel.file}: {e}")
 
-        # Get source dimension
-        if src_doc.is_pdf:
-            src_page = src_doc[0]
-            src_rect = src_page.rect
-        else:
-            # For images/SVG, fitz doc acts like a list of pages too?
-            # Yes, usually page[0] is the image/svg content.
-            src_page = src_doc[0]
-            src_rect = src_page.rect
-
-        aspect = src_rect.height / src_rect.width
-        
-        if panel.height is not None:
-             h = mm_to_pt(panel.height)
-        else:
-            h = w * aspect
-
-        rect = fitz.Rect(x, y, x + w, y + h)
-
-        if src_doc.is_pdf:
-             page.show_pdf_page(rect, src_doc, 0)
-        elif panel.file.suffix.lower() == ".svg":
-             # Convert SVG to PDF in memory to allow vector embedding
-             pdf_bytes = src_doc.convert_to_pdf()
-             src_pdf = fitz.open("pdf", pdf_bytes)
-             page.show_pdf_page(rect, src_pdf, 0)
-        else:
-            # Insert as image (works for PNG/JPEG)
-            page.insert_image(rect, filename=panel.file)
+        try:
+            # Get source dimension
+            if src_doc.is_pdf:
+                src_page = src_doc[0]
+                src_rect = src_page.rect
+            else:
+                # For images/SVG, fitz doc acts like a list of pages too?
+                # Yes, usually page[0] is the image/svg content.
+                src_page = src_doc[0]
+                src_rect = src_page.rect
+
+            aspect = src_rect.height / src_rect.width
+
+            if panel.height is not None:
+                h = to_pt(panel.height, self.units)
+            else:
+                h = w * aspect
+
+            rect = fitz.Rect(x, y, x + w, y + h)
+
+            if src_doc.is_pdf:
+                page.show_pdf_page(rect, src_doc, 0)
+            elif panel.file.suffix.lower() == ".svg":
+                # Convert SVG to PDF in memory to allow vector embedding
+                pdf_bytes = src_doc.convert_to_pdf()
+                src_pdf = fitz.open("pdf", pdf_bytes)
+                try:
+                    page.show_pdf_page(rect, src_pdf, 0)
+                finally:
+                    src_pdf.close()
+            else:
+                # Insert as image (works for PNG/JPEG)
+                page.insert_image(rect, filename=panel.file)
+        finally:
+            src_doc.close()
 
         # Labels
         self._draw_label(page, panel, rect, index)
@@ -107,14 +118,14 @@ class PDFComposer:
     def _draw_label(self, page: fitz.Page, panel: Panel, rect: fitz.Rect, index: int):
         # Determine effective label settings
         style = panel.label_style if panel.label_style else self.layout.page.label
-        
+
         if not style.enabled:
             return
 
         text = panel.label
         if text is None and style.auto_sequence:
             text = chr(65 + index)  # A, B, C...
-        
+
         if not text:
             return
 
@@ -126,10 +137,10 @@ class PDFComposer:
         # SVG implementation uses 'hanging' baseline, so (0,0) is top-left of text char.
         # PyMuPDF insert_text uses 'baseline', so (0,0) is bottom-left of text char.
         # We need to shift Y down by approximately the font sizing to match SVG visual.
-        
+
         pos_x = rect.x0 + mm_to_pt(style.offset_x_mm)
         raw_y = rect.y0 + mm_to_pt(style.offset_y_mm)
-        
+
         # Approximate baseline shift: font_size
         # (A more precise way uses font.ascender, but for basic standard fonts, size is decent proxy for visual top->baseline)
         pos_y = raw_y + style.font_size_pt
@@ -137,7 +148,9 @@ class PDFComposer:
         # Font - PyMuPDF supports base 14 fonts by name
         fontname = "helv"  # default mapping for Helvetica
         if style.bold:
-            fontname = "HeBo" # Helvetica-Bold
-        
+            fontname = "HeBo"  # Helvetica-Bold
+
         # Insert text
-        page.insert_text((pos_x, pos_y), text, fontsize=style.font_size_pt, fontname=fontname)
+        page.insert_text(
+            (pos_x, pos_y), text, fontsize=style.font_size_pt, fontname=fontname
+        )

figquilt-0.1.3/src/figquilt/compose_svg.py

@@ -0,0 +1,164 @@
+from pathlib import Path
+import base64
+from lxml import etree
+from .layout import Layout, Panel
+from .units import mm_to_pt, to_pt
+from .errors import FigQuiltError
+import fitz
+
+
+class SVGComposer:
+    def __init__(self, layout: Layout):
+        self.layout = layout
+        self.units = layout.page.units
+        self.width_pt = to_pt(layout.page.width, self.units)
+        self.height_pt = to_pt(layout.page.height, self.units)
+
+    def compose(self, output_path: Path):
+        # Create root SVG element
+        nsmap = {
+            None: "http://www.w3.org/2000/svg",
+            "xlink": "http://www.w3.org/1999/xlink",
+        }
+        root = etree.Element("svg", nsmap=nsmap)
+        # SVG uses "in" for inches, "pt" for points, "mm" for millimeters
+        svg_unit = "in" if self.units == "inches" else self.units
+        root.set("width", f"{self.layout.page.width}{svg_unit}")
+        root.set("height", f"{self.layout.page.height}{svg_unit}")
+        root.set("viewBox", f"0 0 {self.width_pt} {self.height_pt}")
+        root.set("version", "1.1")
+
+        if self.layout.page.background:
+            # Draw background
+            bg = etree.SubElement(root, "rect")
+            bg.set("width", "100%")
+            bg.set("height", "100%")
+            bg.set("fill", self.layout.page.background)
+
+        # Draw panels
+        for i, panel in enumerate(self.layout.panels):
+            self._place_panel(root, panel, i)
+
+        # Write to file
+        tree = etree.ElementTree(root)
+        with open(output_path, "wb") as f:
+            tree.write(f, pretty_print=True, xml_declaration=True, encoding="utf-8")
+
+    def _place_panel(self, root: etree.Element, panel: Panel, index: int):
+        x = to_pt(panel.x, self.units)
+        y = to_pt(panel.y, self.units)
+        w = to_pt(panel.width, self.units)
+
+        # Determine content sizing
+        # For simplicity in V0, relying on fitz for aspect ratio of all inputs (robust)
+        try:
+            src_doc = fitz.open(panel.file)
+        except Exception as e:
+            raise FigQuiltError(f"Failed to inspect panel {panel.file}: {e}")
+
+        try:
+            src_page = src_doc[0]
+            src_rect = src_page.rect
+            aspect = src_rect.height / src_rect.width
+
+            if panel.height is not None:
+                h = to_pt(panel.height, self.units)
+            else:
+                h = w * aspect
+
+            # Group for the panel
+            g = etree.SubElement(root, "g")
+            g.set("transform", f"translate({x}, {y})")
+
+            # Insert content
+            # Check if SVG
+            suffix = panel.file.suffix.lower()
+            if suffix == ".svg":
+                # Embed SVG by creating an <image> tag with data URI to avoid DOM conflicts
+                # This is safer than merging trees for V0.
+                # Merging trees requires stripping root, handling viewbox/transform matching.
+                # <image> handles scaling automatically.
+                data_uri = self._get_data_uri(panel.file, "image/svg+xml")
+                img = etree.SubElement(g, "image")
+                img.set("width", str(w))
+                img.set("height", str(h))
+                img.set("{http://www.w3.org/1999/xlink}href", data_uri)
+            else:
+                # PDF or Raster Image
+                # For PDF, we rasterize to PNG (easiest for SVG compatibility without huge libs)
+                # Browsers don't support image/pdf in SVG.
+                # If PNG/JPG, embed directly.
+
+                mime = "image/png"
+                if suffix in [".jpg", ".jpeg"]:
+                    mime = "image/jpeg"
+                    data_path = panel.file
+                elif suffix == ".png":
+                    mime = "image/png"
+                    data_path = panel.file
+                elif suffix == ".pdf":
+                    # Rasterize page to PNG
+                    pix = src_page.get_pixmap(dpi=300)
+                    data = pix.tobytes("png")
+                    b64 = base64.b64encode(data).decode("utf-8")
+                    data_uri = f"data:image/png;base64,{b64}"
+                    data_path = None  # signal that we have URI
+                else:
+                    # Fallback
+                    mime = "application/octet-stream"
+                    data_path = panel.file
+
+                if data_path:
+                    data_uri = self._get_data_uri(data_path, mime)
+
+                img = etree.SubElement(g, "image")
+                img.set("width", str(w))
+                img.set("height", str(h))
+                img.set("{http://www.w3.org/1999/xlink}href", data_uri)
+
+            # Label
+            self._draw_label(g, panel, w, h, index)
+        finally:
+            src_doc.close()
+
+    def _get_data_uri(self, path: Path, mime: str) -> str:
+        with open(path, "rb") as f:
+            data = f.read()
+        b64 = base64.b64encode(data).decode("utf-8")
+        return f"data:{mime};base64,{b64}"
+
+    def _draw_label(
+        self, parent: etree.Element, panel: Panel, w: float, h: float, index: int
+    ):
+        style = panel.label_style if panel.label_style else self.layout.page.label
+        if not style.enabled:
+            return
+
+        text_str = panel.label
+        if text_str is None and style.auto_sequence:
+            text_str = chr(65 + index)
+        if not text_str:
+            return
+        if style.uppercase:
+            text_str = text_str.upper()
+
+        # Offset (relative to panel top-left, which is 0,0 inside the group)
+        x = mm_to_pt(style.offset_x_mm)
+        y = mm_to_pt(style.offset_y_mm)
+
+        # Create text element
+        txt = etree.SubElement(parent, "text")
+        txt.text = text_str
+        txt.set("x", str(x))
+        txt.set("y", str(y))
+
+        # Style
+        # Font family is tricky in SVG (system fonts).
+        txt.set("font-family", style.font_family)
+        txt.set("font-size", f"{style.font_size_pt}pt")
+        if style.bold:
+            txt.set("font-weight", "bold")
+
+        # Baseline alignment? SVG text y is usually baseline.
+        # If we want top-left of text at (x,y), we should adjust or use dominant-baseline.
+        txt.set("dominant-baseline", "hanging")  # Matches top-down coordinate logic

figquilt-0.1.3/src/figquilt/units.py

@@ -0,0 +1,25 @@
+def mm_to_pt(mm: float) -> float:
+    """Converts millimeters to points (1 inch = 25.4 mm = 72 pts)."""
+    return mm * 72 / 25.4
+
+
+def pt_to_mm(pt: float) -> float:
+    """Converts points to millimeters."""
+    return pt * 25.4 / 72
+
+
+def inches_to_pt(inches: float) -> float:
+    """Converts inches to points (1 inch = 72 pts)."""
+    return inches * 72
+
+
+def to_pt(value: float, units: str) -> float:
+    """Convert a value from the given units to points."""
+    if units == "mm":
+        return mm_to_pt(value)
+    elif units == "inches":
+        return inches_to_pt(value)
+    elif units == "pt":
+        return value
+    else:
+        raise ValueError(f"Unknown unit: {units}")

figquilt-0.1.1/src/figquilt/cli.py

@@ -1,65 +0,0 @@
-import argparse
-import sys
-from pathlib import Path
-from .parser import parse_layout
-from .errors import FigQuiltError
-
-def main():
-    parser = argparse.ArgumentParser(description="FigQuilt: Compose figures from multiple panels.")
-    parser.add_argument("layout", type=Path, help="Path to layout YAML file")
-    parser.add_argument("output", type=Path, help="Path to output file (PDF/SVG/PNG)")
-    parser.add_argument("--format", choices=["pdf", "svg", "png"], help="Override output format")
-    parser.add_argument("--check", action="store_true", help="Validate layout only")
-    parser.add_argument("--verbose", action="store_true", help="Enable verbose output")
-    
-    args = parser.parse_args()
-
-    try:
-        layout = parse_layout(args.layout)
-        print(f"Layout parsed successfully: {args.layout}")
-        print(f"Page size: {layout.page.width}x{layout.page.height} {layout.page.units}")
-        print(f"Panels: {len(layout.panels)}")
-        
-        if args.check:
-            sys.exit(0)
-
-        # Determine output format
-        suffix = args.output.suffix.lower()
-        fmt = args.format or suffix.lstrip('.')
-        
-        if fmt == 'pdf':
-            from .compose_pdf import PDFComposer
-            composer = PDFComposer(layout)
-            composer.compose(args.output)
-            print(f"Successfully created: {args.output}")
-        
-        elif fmt == 'svg':
-            from .compose_svg import SVGComposer
-            composer = SVGComposer(layout)
-            composer.compose(args.output)
-            print(f"Successfully created: {args.output}")
-            
-        elif fmt == 'png':
-            from .compose_pdf import PDFComposer
-            composer = PDFComposer(layout)
-            doc = composer.build()
-            # Rasterize first page
-            page = doc[0]
-            pix = page.get_pixmap(dpi=layout.page.dpi)
-            pix.save(str(args.output))
-            doc.close()
-            print(f"Successfully created: {args.output}")
-            
-        else:
-            print(f"Unsupported format: {fmt}", file=sys.stderr)
-            sys.exit(1)
-
-    except FigQuiltError as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-    except Exception as e:
-        print(f"Unexpected error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()

figquilt-0.1.1/src/figquilt/compose_svg.py

@@ -1,153 +0,0 @@
-from pathlib import Path
-import base64
-from lxml import etree
-from .layout import Layout, Panel
-from .units import mm_to_pt
-from .errors import FigQuiltError
-import fitz
-
-class SVGComposer:
-    def __init__(self, layout: Layout):
-        self.layout = layout
-        self.width_pt = mm_to_pt(layout.page.width)
-        self.height_pt = mm_to_pt(layout.page.height)
-
-    def compose(self, output_path: Path):
-        # Create root SVG element
-        nsmap = {None: "http://www.w3.org/2000/svg", "xlink": "http://www.w3.org/1999/xlink"}
-        root = etree.Element("svg", nsmap=nsmap)
-        root.set("width", f"{self.layout.page.width}mm")
-        root.set("height", f"{self.layout.page.height}mm")
-        root.set("viewBox", f"0 0 {self.width_pt} {self.height_pt}")
-        root.set("version", "1.1")
-        
-        if self.layout.page.background:
-            # Draw background
-            bg = etree.SubElement(root, "rect")
-            bg.set("width", "100%")
-            bg.set("height", "100%")
-            bg.set("fill", self.layout.page.background)
-
-        # Draw panels
-        for i, panel in enumerate(self.layout.panels):
-            self._place_panel(root, panel, i)
-
-        # Write to file
-        tree = etree.ElementTree(root)
-        with open(output_path, "wb") as f:
-            tree.write(f, pretty_print=True, xml_declaration=True, encoding="utf-8")
-
-    def _place_panel(self, root: etree.Element, panel: Panel, index: int):
-        x = mm_to_pt(panel.x)
-        y = mm_to_pt(panel.y)
-        w = mm_to_pt(panel.width)
-        
-        # Determine content sizing
-        # For simplicity in V0, relying on fitz for aspect ratio of all inputs (robust)
-        try:
-             src_doc = fitz.open(panel.file)
-             src_page = src_doc[0]
-             src_rect = src_page.rect
-             aspect = src_rect.height / src_rect.width
-        except Exception as e:
-            raise FigQuiltError(f"Failed to inspect panel {panel.file}: {e}")
-
-        if panel.height is not None:
-            h = mm_to_pt(panel.height)
-        else:
-            h = w * aspect
-
-        # Group for the panel
-        g = etree.SubElement(root, "g")
-        g.set("transform", f"translate({x}, {y})")
-        
-        # Insert content
-        # Check if SVG
-        suffix = panel.file.suffix.lower()
-        if suffix == ".svg":
-            # Embed SVG by creating an <image> tag with data URI to avoid DOM conflicts
-            # This is safer than merging trees for V0.
-            # Merging trees requires stripping root, handling viewbox/transform matching.
-            # <image> handles scaling automatically.
-            data_uri = self._get_data_uri(panel.file, "image/svg+xml")
-            img = etree.SubElement(g, "image")
-            img.set("width", str(w))
-            img.set("height", str(h))
-            img.set("{http://www.w3.org/1999/xlink}href", data_uri)
-        else:
-            # PDF or Raster Image
-            # For PDF, we rasterize to PNG (easiest for SVG compatibility without huge libs) or embed as image/pdf?
-            # Browsers don't support image/pdf in SVG.
-            # So if PDF, convert to PNG.
-            # If PNG/JPG, embed directly.
-            
-            mime = "image/png"
-            if suffix in [".jpg", ".jpeg"]:
-                mime = "image/jpeg"
-                data_path = panel.file
-            elif suffix == ".png":
-                 mime = "image/png"
-                 data_path = panel.file
-            elif suffix == ".pdf":
-                 # Rasterize page to PNG
-                 pix = src_page.get_pixmap(dpi=300) # Use decent DPI
-                 data = pix.tobytes("png")
-                 # We can't use _get_data_uri directly on file, we have bytes
-                 b64 = base64.b64encode(data).decode("utf-8")
-                 data_uri = f"data:image/png;base64,{b64}"
-                 data_path = None # signal that we have URI
-            else:
-                 # Fallback
-                 mime = "application/octet-stream"
-                 data_path = panel.file
-
-            if data_path:
-                data_uri = self._get_data_uri(data_path, mime)
-            
-            img = etree.SubElement(g, "image")
-            img.set("width", str(w))
-            img.set("height", str(h))
-            img.set("{http://www.w3.org/1999/xlink}href", data_uri)
-
-        # Label
-        self._draw_label(g, panel, w, h, index)
-
-    def _get_data_uri(self, path: Path, mime: str) -> str:
-        with open(path, "rb") as f:
-            data = f.read()
-        b64 = base64.b64encode(data).decode("utf-8")
-        return f"data:{mime};base64,{b64}"
-
-    def _draw_label(self, parent: etree.Element, panel: Panel, w: float, h: float, index: int):
-        style = panel.label_style if panel.label_style else self.layout.page.label
-        if not style.enabled:
-            return
-
-        text_str = panel.label
-        if text_str is None and style.auto_sequence:
-            text_str = chr(65 + index)
-        if not text_str:
-            return
-        if style.uppercase:
-            text_str = text_str.upper()
-
-        # Offset (relative to panel top-left, which is 0,0 inside the group)
-        x = mm_to_pt(style.offset_x_mm)
-        y = mm_to_pt(style.offset_y_mm)
-        
-        # Create text element
-        txt = etree.SubElement(parent, "text")
-        txt.text = text_str
-        txt.set("x", str(x))
-        txt.set("y", str(y))
-        
-        # Style
-        # Font family is tricky in SVG (system fonts).
-        txt.set("font-family", style.font_family)
-        txt.set("font-size", f"{style.font_size_pt}pt")
-        if style.bold:
-            txt.set("font-weight", "bold")
-        
-        # Baseline alignment? SVG text y is usually baseline.
-        # If we want top-left of text at (x,y), we should adjust or use dominant-baseline.
-        txt.set("dominant-baseline", "hanging") # Matches top-down coordinate logic

figquilt-0.1.1/src/figquilt/units.py

@@ -1,7 +0,0 @@
-def mm_to_pt(mm: float) -> float:
-    """Converts millimeters to points (1 inch = 25.4 mm = 72 pts)."""
-    return mm * 72 / 25.4
-
-def pt_to_mm(pt: float) -> float:
-    """Converts points to millimeters."""
-    return pt * 25.4 / 72