figquilt 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

figquilt/cli.py

@@ -7,6 +7,7 @@ import threading
 from .parser import parse_layout
 from .errors import FigQuiltError
 from .layout import Layout
+from .grid import resolve_layout
 
 
 def get_watched_paths(layout_path: Path, layout: Layout) -> Tuple[Set[Path], Set[Path]]:
@@ -18,7 +19,8 @@ def get_watched_paths(layout_path: Path, layout: Layout) -> Tuple[Set[Path], Set
     """
     layout_path = layout_path.resolve()
     files = {layout_path}
-    for panel in layout.panels:
+    panels = resolve_layout(layout)
+    for panel in panels:
         files.add(panel.file.resolve())
     dirs = {f.parent for f in files}
     return files, dirs
@@ -34,12 +36,13 @@ def compose_figure(
     """
     try:
         layout = parse_layout(layout_path)
+        panels = resolve_layout(layout)
         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)}")
+            print(f"Panels: {len(panels)}")
 
         if fmt == "pdf":
             from .compose_pdf import PDFComposer
@@ -187,11 +190,12 @@ def main():
     if args.check:
         try:
             layout = parse_layout(args.layout)
+            panels = resolve_layout(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)}")
+            print(f"Panels: {len(panels)}")
             sys.exit(0)
         except FigQuiltError as e:
             print(f"Error: {e}", file=sys.stderr)

figquilt/compose_pdf.py

@@ -1,7 +1,7 @@
 import fitz
 from pathlib import Path
 from .layout import Layout, Panel
-from .units import mm_to_pt, to_pt
+from .units import to_pt
 from .errors import FigQuiltError
 
 
@@ -11,6 +11,7 @@ class PDFComposer:
         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)
+        self.margin_pt = to_pt(layout.page.margin, self.units)
 
     def compose(self, output_path: Path):
         doc = self.build()
@@ -33,8 +34,11 @@ class PDFComposer:
             if col:
                 page.draw_rect(page.rect, color=col, fill=col)
 
-        # Draw panels
-        for i, panel in enumerate(self.layout.panels):
+        # Get panels (resolves grid layout if needed)
+        from .grid import resolve_layout
+
+        panels = resolve_layout(self.layout)
+        for i, panel in enumerate(panels):
             self._place_panel(doc, page, panel, index=i)
 
         return doc
@@ -63,9 +67,9 @@ class PDFComposer:
     def _place_panel(
         self, doc: fitz.Document, page: fitz.Page, panel: Panel, index: int
     ):
-        # Calculate position and size first
-        x = to_pt(panel.x, self.units)
-        y = to_pt(panel.y, self.units)
+        # Calculate position and size first, offset by page margin
+        x = to_pt(panel.x, self.units) + self.margin_pt
+        y = to_pt(panel.y, self.units) + self.margin_pt
         w = to_pt(panel.width, self.units)
 
         # Determine height from aspect ratio if needed
@@ -151,8 +155,8 @@ class PDFComposer:
         # 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)
+        pos_x = rect.x0 + to_pt(style.offset_x, self.units)
+        raw_y = rect.y0 + to_pt(style.offset_y, self.units)
 
         # 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)

figquilt/compose_svg.py

@@ -2,7 +2,7 @@ from pathlib import Path
 import base64
 from lxml import etree
 from .layout import Layout, Panel
-from .units import mm_to_pt, to_pt
+from .units import to_pt
 from .errors import FigQuiltError
 import fitz
 
@@ -13,6 +13,7 @@ class SVGComposer:
         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)
+        self.margin_pt = to_pt(layout.page.margin, self.units)
 
     def compose(self, output_path: Path):
         # Create root SVG element
@@ -35,8 +36,11 @@ class SVGComposer:
             bg.set("height", "100%")
             bg.set("fill", self.layout.page.background)
 
-        # Draw panels
-        for i, panel in enumerate(self.layout.panels):
+        # Get panels (resolves grid layout if needed)
+        from .grid import resolve_layout
+
+        panels = resolve_layout(self.layout)
+        for i, panel in enumerate(panels):
             self._place_panel(root, panel, i)
 
         # Write to file
@@ -45,8 +49,9 @@ class SVGComposer:
             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)
+        # Offset by page margin
+        x = to_pt(panel.x, self.units) + self.margin_pt
+        y = to_pt(panel.y, self.units) + self.margin_pt
         w = to_pt(panel.width, self.units)
 
         # Determine content sizing
@@ -174,8 +179,8 @@ class SVGComposer:
             text_str = text_str.upper()
 
         # Offset relative to the content position
-        x = offset_x + mm_to_pt(style.offset_x_mm)
-        y = offset_y + mm_to_pt(style.offset_y_mm)
+        x = offset_x + to_pt(style.offset_x, self.units)
+        y = offset_y + to_pt(style.offset_y, self.units)
 
         # Create text element
         txt = etree.SubElement(parent, "text")

figquilt/grid.py

@@ -0,0 +1,100 @@
+"""Grid layout resolution: converts layout tree to flat list of positioned panels."""
+
+from typing import List
+from .layout import Layout, LayoutNode, Panel
+
+
+def resolve_layout(layout: Layout) -> List[Panel]:
+    """
+    Resolve a grid-based Layout to a flat list of Panels with computed positions.
+
+    For legacy layouts with explicit panels, returns those directly.
+    For grid layouts, recursively computes panel positions based on
+    container structure, ratios, gaps, and margins.
+    """
+    if layout.panels is not None:
+        return layout.panels
+
+    if layout.layout is None:
+        return []
+
+    # Calculate content area after page margin
+    # Note: x, y are in content coordinate space (0,0 = top-left of content area)
+    # The composer will add the page margin offset when rendering
+    margin = layout.page.margin
+    content_w = layout.page.width - 2 * margin
+    content_h = layout.page.height - 2 * margin
+
+    panels: List[Panel] = []
+    _resolve_node(layout.layout, 0, 0, content_w, content_h, panels)
+    return panels
+
+
+def _resolve_node(
+    node: LayoutNode,
+    x: float,
+    y: float,
+    width: float,
+    height: float,
+    panels: List[Panel],
+) -> None:
+    """
+    Recursively resolve a layout node into panels.
+
+    Args:
+        node: The layout node to resolve
+        x, y: Top-left position of this node's cell
+        width, height: Size of this node's cell
+        panels: List to append resolved panels to
+    """
+    if not node.is_container():
+        # Leaf node: create a panel
+        panels.append(
+            Panel(
+                id=node.id,
+                file=node.file,
+                x=x,
+                y=y,
+                width=width,
+                height=height,
+                fit=node.fit,
+                label=node.label,
+                label_style=node.label_style,
+            )
+        )
+        return
+
+    # Container node: apply margin and distribute children
+    margin = node.margin
+    inner_x = x + margin
+    inner_y = y + margin
+    inner_w = width - 2 * margin
+    inner_h = height - 2 * margin
+
+    children = node.children
+    n = len(children)
+
+    # Calculate ratios (default to equal distribution)
+    ratios = node.ratios if node.ratios else [1.0] * n
+    total_ratio = sum(ratios)
+
+    # Calculate available space after gaps
+    gap = node.gap
+    total_gap = gap * (n - 1) if n > 1 else 0
+
+    if node.type == "row":
+        # Horizontal layout
+        available = inner_w - total_gap
+        cursor = inner_x
+        for i, child in enumerate(children):
+            child_w = (ratios[i] / total_ratio) * available
+            _resolve_node(child, cursor, inner_y, child_w, inner_h, panels)
+            cursor += child_w + gap
+    else:
+        # Vertical layout (col)
+        available = inner_h - total_gap
+        cursor = inner_y
+        for i, child in enumerate(children):
+            child_h = (ratios[i] / total_ratio) * available
+            _resolve_node(child, inner_x, cursor, inner_w, child_h, panels)
+            cursor += child_h + gap

figquilt/layout.py

@@ -1,49 +1,157 @@
+from __future__ import annotations
 from typing import Literal, Optional, List
 from pathlib import Path
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, field_validator, model_validator
 
 FitMode = Literal["contain", "cover"]
 
 
 class LabelStyle(BaseModel):
-    enabled: bool = True
-    auto_sequence: bool = True
-    font_family: str = "Helvetica"
-    font_size_pt: float = 8.0
-    offset_x_mm: float = 2.0
-    offset_y_mm: float = 2.0
-    bold: bool = True
-    uppercase: bool = True
+    """Styling options for panel labels."""
+
+    enabled: bool = Field(True, description="Whether to show labels")
+    auto_sequence: bool = Field(True, description="Auto-generate labels A, B, C...")
+    font_family: str = Field("Helvetica", description="Font family for labels")
+    font_size_pt: float = Field(8.0, description="Font size in points")
+    offset_x: float = Field(
+        2.0, description="Horizontal offset from panel edge (in page units)"
+    )
+    offset_y: float = Field(
+        2.0, description="Vertical offset from panel edge (in page units)"
+    )
+    bold: bool = Field(True, description="Use bold font")
+    uppercase: bool = Field(True, description="Use uppercase letters")
 
 
 class Panel(BaseModel):
-    id: str
-    file: Path
-    x: float
-    y: float
-    width: float
-    height: Optional[float] = None  # If None, compute from aspect ratio
-    fit: FitMode = "contain"
-    label: Optional[str] = None
-    label_style: Optional[LabelStyle] = None
+    """A figure panel to place on the page (with explicit coordinates)."""
+
+    id: str = Field(..., description="Unique identifier for this panel")
+    file: Path = Field(..., description="Path to source file (PDF, SVG, or PNG)")
+    x: float = Field(..., description="X position from left edge (in page units)")
+    y: float = Field(..., description="Y position from top edge (in page units)")
+    width: float = Field(..., description="Panel width (in page units)")
+    height: Optional[float] = Field(
+        None, description="Panel height; if omitted, computed from aspect ratio"
+    )
+    fit: FitMode = Field(
+        "contain",
+        description="How to fit the figure: contain (preserve aspect) or cover (fill and clip)",
+    )
+    label: Optional[str] = Field(
+        None, description="Override the auto-generated label text"
+    )
+    label_style: Optional[LabelStyle] = Field(
+        None, description="Override default label styling for this panel"
+    )
 
     @field_validator("file")
     @classmethod
     def validate_file(cls, v: Path) -> Path:
-        # We don't check existence here to allow validation without side effects,
-        # but we could add it if desired. The parser/logic will check it.
         return v
 
 
+# Grid layout system
+
+
+class LayoutNode(BaseModel):
+    """A node in the layout tree - either a container or a leaf panel."""
+
+    # Container fields (used when type is "row" or "col")
+    type: Optional[Literal["row", "col"]] = Field(
+        None, description="Container type: row (horizontal) or col (vertical)"
+    )
+    children: Optional[List[LayoutNode]] = Field(
+        None, description="Child nodes (containers or leaves)"
+    )
+    ratios: Optional[List[float]] = Field(
+        None, description="Relative sizing of children (e.g., [3, 2] = 60%/40%)"
+    )
+    gap: float = Field(0.0, description="Gap between children (in page units)")
+    margin: float = Field(0.0, description="Inner margin of this container")
+
+    # Leaf fields (used when type is None)
+    id: Optional[str] = Field(None, description="Unique identifier for this panel")
+    file: Optional[Path] = Field(
+        None, description="Path to source file (PDF, SVG, or PNG)"
+    )
+    fit: FitMode = Field("contain", description="How to fit the figure in its cell")
+    label: Optional[str] = Field(
+        None, description="Override the auto-generated label text"
+    )
+    label_style: Optional[LabelStyle] = Field(
+        None, description="Override default label styling for this panel"
+    )
+
+    @field_validator("file")
+    @classmethod
+    def validate_file(cls, v: Optional[Path]) -> Optional[Path]:
+        return v
+
+    @model_validator(mode="after")
+    def validate_node(self) -> LayoutNode:
+        is_container = self.type is not None
+        is_leaf = self.id is not None or self.file is not None
+
+        if is_container and is_leaf:
+            raise ValueError("Node cannot be both container and leaf")
+
+        if is_container:
+            if not self.children:
+                raise ValueError("Container must have children")
+            if self.ratios is not None and len(self.ratios) != len(self.children):
+                raise ValueError(
+                    f"ratios length ({len(self.ratios)}) must match children length ({len(self.children)})"
+                )
+        elif is_leaf:
+            if not self.id:
+                raise ValueError("Leaf node must have id")
+            if not self.file:
+                raise ValueError("Leaf node must have file")
+        else:
+            raise ValueError("Node must be either container (type) or leaf (id, file)")
+
+        return self
+
+    def is_container(self) -> bool:
+        return self.type is not None
+
+
 class Page(BaseModel):
-    width: float
-    height: float
-    units: str = "mm"
-    dpi: int = 300
-    background: Optional[str] = "white"
-    label: LabelStyle = Field(default_factory=LabelStyle)
+    """Page dimensions and default settings."""
+
+    width: float = Field(..., description="Page width (in specified units)")
+    height: float = Field(..., description="Page height (in specified units)")
+    units: Literal["mm", "inches", "pt"] = Field(
+        "mm", description="Units for dimensions"
+    )
+    dpi: int = Field(300, description="Resolution for rasterized output")
+    background: Optional[str] = Field(
+        "white", description="Background color (name or hex)"
+    )
+    margin: float = Field(
+        0.0, description="Page margin; panel coordinates are offset by this"
+    )
+    label: LabelStyle = Field(
+        default_factory=LabelStyle, description="Default label style"
+    )
 
 
 class Layout(BaseModel):
-    page: Page
-    panels: List[Panel]
+    """Root layout object for figquilt."""
+
+    page: Page = Field(..., description="Page dimensions and settings")
+    panels: Optional[List[Panel]] = Field(
+        None, description="List of panels with explicit coordinates (legacy mode)"
+    )
+    layout: Optional[LayoutNode] = Field(
+        None, description="Root layout node for grid-based layout"
+    )
+
+    @model_validator(mode="after")
+    def validate_layout_or_panels(self) -> Layout:
+        if self.panels is None and self.layout is None:
+            raise ValueError("Must specify either 'panels' or 'layout'")
+        if self.panels is not None and self.layout is not None:
+            raise ValueError("Cannot specify both 'panels' and 'layout'")
+        return self

figquilt/parser.py

@@ -1,32 +1,112 @@
 from pathlib import Path
+from typing import Any
 import yaml
+from pydantic import ValidationError
 from .layout import Layout
 from .errors import LayoutError, AssetMissingError
 
+
+def _parse_yaml_with_lines(content: str) -> tuple[Any, dict[tuple, int]]:
+    """Parse YAML and return data along with a mapping of paths to line numbers."""
+    line_map: dict[tuple, int] = {}
+
+    def build_line_map(node: yaml.Node, path: tuple = ()) -> Any:
+        if isinstance(node, yaml.MappingNode):
+            result = {}
+            for key_node, value_node in node.value:
+                key = key_node.value
+                line_map[(*path, key)] = value_node.start_mark.line + 1
+                result[key] = build_line_map(value_node, (*path, key))
+            return result
+        elif isinstance(node, yaml.SequenceNode):
+            result = []
+            for i, item_node in enumerate(node.value):
+                line_map[(*path, i)] = item_node.start_mark.line + 1
+                result.append(build_line_map(item_node, (*path, i)))
+            return result
+        else:
+            return yaml.safe_load(yaml.serialize(node))
+
+    loader = yaml.SafeLoader(content)
+    try:
+        root = loader.get_single_node()
+        if root is None:
+            return None, {}
+        data = build_line_map(root)
+        return data, line_map
+    finally:
+        loader.dispose()
+
+
+def _get_line_for_path(line_map: dict[tuple, int], path_str: str) -> int | None:
+    """Convert a Pydantic error path like 'panels.0.y' to a line number."""
+    parts: list[str | int] = []
+    for part in path_str.split("."):
+        if part.isdigit():
+            parts.append(int(part))
+        else:
+            parts.append(part)
+
+    return line_map.get(tuple(parts))
+
+
 def parse_layout(layout_path: Path) -> Layout:
     """Parses a YAML layout file and returns a Layout object."""
     if not layout_path.exists():
         raise LayoutError(f"Layout file not found: {layout_path}")
 
     try:
-        with open(layout_path, 'r') as f:
-            data = yaml.safe_load(f)
+        content = layout_path.read_text()
+        data, line_map = _parse_yaml_with_lines(content)
     except yaml.YAMLError as e:
         raise LayoutError(f"Failed to parse YAML: {e}")
 
     try:
         layout = Layout(**data)
+    except ValidationError as e:
+        # Try to add line numbers to validation errors
+        errors_with_lines = []
+        for error in e.errors():
+            loc = ".".join(str(p) for p in error["loc"])
+            line = _get_line_for_path(line_map, loc)
+            msg = error["msg"]
+            if line:
+                errors_with_lines.append(f"  {loc} (line {line}): {msg}")
+            else:
+                errors_with_lines.append(f"  {loc}: {msg}")
+        raise LayoutError("Layout validation failed:\n" + "\n".join(errors_with_lines))
     except Exception as e:
         raise LayoutError(f"Layout validation failed: {e}")
 
     # Validate assets exist relative to the layout file
     base_dir = layout_path.parent
-    for panel in layout.panels:
-        # Resolve path relative to layout file if not absolute
-        if not panel.file.is_absolute():
-            panel.file = base_dir / panel.file
-        
-        if not panel.file.exists():
-            raise AssetMissingError(f"Asset for panel '{panel.id}' not found: {panel.file}")
+
+    if layout.panels:
+        # Legacy mode: iterate over explicit panels
+        for panel in layout.panels:
+            if not panel.file.is_absolute():
+                panel.file = base_dir / panel.file
+            if not panel.file.exists():
+                raise AssetMissingError(
+                    f"Asset for panel '{panel.id}' not found: {panel.file}"
+                )
+    elif layout.layout:
+        # Grid mode: recursively validate assets in the layout tree
+        _validate_layout_assets(layout.layout, base_dir)
 
     return layout
+
+
+def _validate_layout_assets(node, base_dir: Path) -> None:
+    """Recursively validate and resolve asset paths in a layout tree."""
+    if node.is_container():
+        for child in node.children:
+            _validate_layout_assets(child, base_dir)
+    else:
+        # Leaf node: validate file exists
+        if not node.file.is_absolute():
+            node.file = base_dir / node.file
+        if not node.file.exists():
+            raise AssetMissingError(
+                f"Asset for panel '{node.id}' not found: {node.file}"
+            )

figquilt/units.py

@@ -3,11 +3,6 @@ def mm_to_pt(mm: float) -> float:
     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

{figquilt-0.1.4.dist-info → figquilt-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: figquilt
-Version: 0.1.4
+Version: 0.1.6
 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>
@@ -99,4 +99,121 @@ Use `--watch` to automatically rebuild when the layout file or any panel source
 figquilt --watch figure1.yaml figure1.pdf
 ```
 
-This is useful during layout iteration - edit your YAML or regenerate a panel, and the output updates automatically.
+This is useful during layout iteration - edit your YAML or regenerate a panel, and the output updates automatically.
+
+### Fit Modes
+
+When specifying both `width` and `height` for a panel, use `fit` to control how the source image scales:
+
+- **`contain`** (default): Scale to fit within the cell, preserving aspect ratio. May leave empty space (letterbox/pillarbox).
+- **`cover`**: Scale to cover the entire cell, preserving aspect ratio. May crop overflow.
+
+```yaml
+panels:
+  - id: A
+    file: "photo.png"
+    x: 0
+    y: 0
+    width: 80
+    height: 60
+    fit: cover  # Fill the cell, cropping if needed
+```
+
+If `height` is omitted, the panel automatically sizes to preserve the source aspect ratio.
+
+### Page Margins
+
+Add consistent margins around your content with the `margin` property on the page:
+
+```yaml
+page:
+  width: 180
+  height: 120
+  margin: 10  # 10mm margin on all sides
+
+panels:
+  - id: A
+    file: "plots/scatter.pdf"
+    width: 70
+    x: 0   # Positioned relative to margin, not page edge
+    y: 0
+```
+
+Panel coordinates are relative to the margin edge. A panel at `x: 0, y: 0` with a 10mm margin will appear at position (10mm, 10mm) on the page.
+
+### Grid Layout
+
+Instead of manually specifying x/y coordinates for each panel, use the grid layout system to define structure with rows and columns:
+
+```yaml
+page:
+  width: 180
+  height: 100
+  units: mm
+
+layout:
+  type: row
+  ratios: [3, 2]  # Left panel is 60%, right is 40%
+  gap: 5
+  children:
+    - id: A
+      file: "plot1.pdf"
+    - id: B
+      file: "plot2.pdf"
+```
+
+#### Container Types
+
+- **`row`**: Arranges children horizontally (left to right)
+- **`col`**: Arranges children vertically (top to bottom)
+
+#### Container Properties
+
+| Property | Default | Description |
+|----------|---------|-------------|
+| `ratios` | Equal | Relative sizing of children (e.g., `[3, 2]` = 60%/40%) |
+| `gap` | 0 | Space between children (in page units) |
+| `margin` | 0 | Inner padding of the container |
+
+#### Nested Layouts
+
+Containers can be nested for complex layouts:
+
+```yaml
+layout:
+  type: col
+  ratios: [1, 2]  # Top row 1/3 height, bottom row 2/3
+  children:
+    - id: A
+      file: "header.pdf"
+    - type: row
+      ratios: [1, 1]
+      gap: 5
+      children:
+        - id: B
+          file: "left.pdf"
+        - id: C
+          file: "right.pdf"
+```
+
+This creates:
+- Panel A spanning the full width in the top third
+- Panels B and C side-by-side in the bottom two-thirds
+
+### Editor Autocomplete (JSON Schema)
+
+For autocomplete and validation in your editor, reference the JSON schema in your layout file:
+
+```yaml
+# yaml-language-server: $schema=https://raw.githubusercontent.com/yy/figquilt/main/schema/layout.schema.json
+page:
+  width: 180
+  height: 120
+
+panels:
+  - id: A
+    file: "plots/scatter.pdf"
+    # ... your editor will now provide autocomplete for all fields
+```
+
+This works with [YAML Language Server](https://github.com/redhat-developer/yaml-language-server) in VS Code (via the YAML extension) and other editors.

figquilt-0.1.6.dist-info/RECORD

@@ -0,0 +1,14 @@
+figquilt/__init__.py,sha256=91447944015cec709e8aa7655f7e9d64e1e4508e7023a57fe3746911c0fc6fed,22
+figquilt/cli.py,sha256=04af949a9e93cc7fdc2ded5c892cf06356d44903c1c4fbfdea2a4a10429616de,7062
+figquilt/compose_pdf.py,sha256=20ac74b06df83f7db019a3686e8a5318c8744599c16100fd818177c60c2597e8,6401
+figquilt/compose_svg.py,sha256=8e8b65725ef37e6a66cff625ac34be0c3e87d263f9e03ce6b1fb1456f99d0754,7656
+figquilt/errors.py,sha256=6f4001dcae85d2171f7aa7df4161926771dbe8c21068ccb70a7865298f05cf2b,298
+figquilt/grid.py,sha256=b56aa9fabe023e9c9447d4d13c573a7ad64a60a1de38435fceb4429ecfaed00f,3050
+figquilt/images.py,sha256=c613655fb3a0790fca98182c558c584e632a8822225220a5feb6080c7c68eb9e,815
+figquilt/layout.py,sha256=c7c65eeacf1179ee25dcbac05d729ea0a1102ed6abffa7ee401f63099958aa61,6028
+figquilt/parser.py,sha256=9658c73e9964f2060afd01da4123aa0063c8062d382443c1e1caac79e7ebf648,4029
+figquilt/units.py,sha256=9f87b73643e39b54f1bd1011a8118d570ebab03c1bb4526169bbf6457e5a2b43,2020
+figquilt-0.1.6.dist-info/WHEEL,sha256=76443c98c0efcfdd1191eac5fa1d8223dba1c474dbd47676674a255e7ca48770,79
+figquilt-0.1.6.dist-info/entry_points.txt,sha256=8f70ce07f585bed28aca569052c7f0029384ac67c5e738faeb0daeb31695bc85,48
+figquilt-0.1.6.dist-info/METADATA,sha256=6f99e38c83ed059062ef8c3e79ab5ff233273930dd4d376ca01bb2e1668047d7,6217
+figquilt-0.1.6.dist-info/RECORD,,

figquilt-0.1.4.dist-info/RECORD

@@ -1,13 +0,0 @@
-figquilt/__init__.py,sha256=91447944015cec709e8aa7655f7e9d64e1e4508e7023a57fe3746911c0fc6fed,22
-figquilt/cli.py,sha256=d73f2f97ca86b0d932e5a4dac8596e3137017517e2b7017916920bfe8e36a789,6930
-figquilt/compose_pdf.py,sha256=b9418a415eb52da82b3126501cdded8048083418ba69cb6e9c281f0ecc0ebe0f,6172
-figquilt/compose_svg.py,sha256=3a3499c9805508c38906568e984d46cd391f1432ab2fea21b3fe2be783816c81,7418
-figquilt/errors.py,sha256=6f4001dcae85d2171f7aa7df4161926771dbe8c21068ccb70a7865298f05cf2b,298
-figquilt/images.py,sha256=c613655fb3a0790fca98182c558c584e632a8822225220a5feb6080c7c68eb9e,815
-figquilt/layout.py,sha256=12a1169f05630ba97b3b29f2d269708b38da697357e5d511e12fad5e484fbfbe,1226
-figquilt/parser.py,sha256=d33d21178721072bbf681be940312b5fda0275f451fca3be2affad707f80a7fb,1065
-figquilt/units.py,sha256=25098b6d7559cb78214fe1a9889fd38ce88633993d0c92819cc609510654275d,2124
-figquilt-0.1.4.dist-info/WHEEL,sha256=76443c98c0efcfdd1191eac5fa1d8223dba1c474dbd47676674a255e7ca48770,79
-figquilt-0.1.4.dist-info/entry_points.txt,sha256=8f70ce07f585bed28aca569052c7f0029384ac67c5e738faeb0daeb31695bc85,48
-figquilt-0.1.4.dist-info/METADATA,sha256=a21301d1e2a2d00ae70e43531d0e2145f79cc0cffa93eac07be19fadc39a4463,3330
-figquilt-0.1.4.dist-info/RECORD,,