figquilt 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

figquilt/cli.py

@@ -1,65 +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 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()
 
+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(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)
+        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)}")
 
-        # Determine output format
-        suffix = args.output.suffix.lower()
-        fmt = args.format or suffix.lstrip('.')
-        
-        if fmt == 'pdf':
+        if fmt == "pdf":
             from .compose_pdf import PDFComposer
+
             composer = PDFComposer(layout)
-            composer.compose(args.output)
-            print(f"Successfully created: {args.output}")
-        
-        elif fmt == 'svg':
+            composer.compose(output_path)
+
+        elif fmt == "svg":
             from .compose_svg import SVGComposer
+
             composer = SVGComposer(layout)
-            composer.compose(args.output)
-            print(f"Successfully created: {args.output}")
-            
-        elif fmt == 'png':
+            composer.compose(output_path)
+
+        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))
+            pix.save(str(output_path))
             doc.close()
-            print(f"Successfully created: {args.output}")
-            
+
         else:
             print(f"Unsupported format: {fmt}", file=sys.stderr)
-            sys.exit(1)
+            return False
+
+        return True
 
     except FigQuiltError as e:
         print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
+        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/compose_pdf.py

@@ -4,6 +4,7 @@ from .layout import Layout, Panel
 from .units import mm_to_pt
 from .errors import FigQuiltError
 
+
 class PDFComposer:
     def __init__(self, layout: Layout):
         self.layout = layout
@@ -29,20 +30,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 +53,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)
-        
+
         # Determine height from aspect ratio if needed
         # We need to open the source to get aspect ratio
         try:
@@ -71,35 +75,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 = 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)
+                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 +117,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 +136,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 +147,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/compose_svg.py

@@ -6,6 +6,7 @@ from .units import mm_to_pt
 from .errors import FigQuiltError
 import fitz
 
+
 class SVGComposer:
     def __init__(self, layout: Layout):
         self.layout = layout
@@ -14,13 +15,16 @@ class SVGComposer:
 
     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"}
+        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")
@@ -41,76 +45,78 @@ class SVGComposer:
         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
+            src_doc = fitz.open(panel.file)
         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
+        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 = mm_to_pt(panel.height)
             else:
-                 # Fallback
-                 mime = "application/octet-stream"
-                 data_path = panel.file
+                h = w * aspect
+
+            # Group for the panel
+            g = etree.SubElement(root, "g")
+            g.set("transform", f"translate({x}, {y})")
 
-            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)
+            # 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.
 
-        # Label
-        self._draw_label(g, panel, w, h, index)
+                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:
@@ -118,7 +124,9 @@ class SVGComposer:
         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):
+    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
@@ -134,20 +142,20 @@ class SVGComposer:
         # 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
+        txt.set("dominant-baseline", "hanging")  # Matches top-down coordinate logic

{figquilt-0.1.1.dist-info → figquilt-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: figquilt
-Version: 0.1.1
+Version: 0.1.2
 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
@@ -81,4 +82,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.dist-info → figquilt-0.1.2.dist-info}/RECORD

@@ -1,13 +1,13 @@
 figquilt/__init__.py,sha256=91447944015cec709e8aa7655f7e9d64e1e4508e7023a57fe3746911c0fc6fed,22
-figquilt/cli.py,sha256=481535c3c2d77a73692d76c1be8dfd02056a2b20edb7e9877edca0edf73d67ab,2352
-figquilt/compose_pdf.py,sha256=4da4d5f9b656cd1da6c1b58e3e92a18955d60aa498bd1720050fc6a5988f0e4c,5385
-figquilt/compose_svg.py,sha256=2a4f01369be6c4acca62f823967bc3027b9b341b339e55391186ed5eb6f0a5fb,5921
+figquilt/cli.py,sha256=d73f2f97ca86b0d932e5a4dac8596e3137017517e2b7017916920bfe8e36a789,6930
+figquilt/compose_pdf.py,sha256=f05dbd491aa0adfc06f2c5f7fd59fd8a9d42e7c61b28da4043cc24822b25adf6,5600
+figquilt/compose_svg.py,sha256=ae102920d4c1d135220cfaee53d9eba925a9543be4552978251cb87cc67504f2,5990
 figquilt/errors.py,sha256=6f4001dcae85d2171f7aa7df4161926771dbe8c21068ccb70a7865298f05cf2b,298
 figquilt/images.py,sha256=c613655fb3a0790fca98182c558c584e632a8822225220a5feb6080c7c68eb9e,815
 figquilt/layout.py,sha256=44514c72f8883afe02f5dd05e674410440dc52c40966a8028f1d9693d4be3364,1159
 figquilt/parser.py,sha256=d33d21178721072bbf681be940312b5fda0275f451fca3be2affad707f80a7fb,1065
 figquilt/units.py,sha256=0c1b6b3f7380fb8ebf51ae81fb093c1830ae4a240b9151191333a3b0af16cd84,233
-figquilt-0.1.1.dist-info/WHEEL,sha256=76443c98c0efcfdd1191eac5fa1d8223dba1c474dbd47676674a255e7ca48770,79
-figquilt-0.1.1.dist-info/entry_points.txt,sha256=8f70ce07f585bed28aca569052c7f0029384ac67c5e738faeb0daeb31695bc85,48
-figquilt-0.1.1.dist-info/METADATA,sha256=b3dedf15af8566eef3e86d23957e9a461136aff2200efd25ff180ea0de8b6428,2466
-figquilt-0.1.1.dist-info/RECORD,,
+figquilt-0.1.2.dist-info/WHEEL,sha256=76443c98c0efcfdd1191eac5fa1d8223dba1c474dbd47676674a255e7ca48770,79
+figquilt-0.1.2.dist-info/entry_points.txt,sha256=8f70ce07f585bed28aca569052c7f0029384ac67c5e738faeb0daeb31695bc85,48
+figquilt-0.1.2.dist-info/METADATA,sha256=78a83d8a0570b4829292a1410d3cf667a8f7508721826ee807f30f513392fd0b,2783
+figquilt-0.1.2.dist-info/RECORD,,