figpack 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

figpack/__init__.py

@@ -2,4 +2,8 @@
 figpack - A Python package for creating shareable, interactive visualizations in the browser
 """
 
-__version__ = "0.2.4"
+__version__ = "0.2.6"
+
+from .cli import view_figure
+
+__all__ = ["view_figure"]

figpack/cli.py

@@ -5,21 +5,19 @@ Command-line interface for figpack
 import argparse
 import json
 import pathlib
-import socket
 import sys
 import tarfile
 import tempfile
 import threading
-import webbrowser
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
-from typing import Dict, Tuple, Union
+from typing import Dict, Tuple
 from urllib.parse import urljoin
 
 import requests
 
 from . import __version__
 from .core._server_manager import CORSRequestHandler
+from .core._view_figure import serve_files, view_figure
 
 MAX_WORKERS_FOR_DOWNLOAD = 16
 
@@ -216,120 +214,6 @@ def download_figure(figure_url: str, dest_path: str) -> None:
         print(f"Archive saved to: {dest_path}")
 
 
-def serve_files(
-    tmpdir: str,
-    *,
-    port: Union[int, None],
-    open_in_browser: bool = False,
-    allow_origin: Union[str, None] = None,
-):
-    """
-    Serve files from a directory using a simple HTTP server.
-
-    Args:
-        tmpdir: Directory to serve
-        port: Port number for local server
-        open_in_browser: Whether to open in browser automatically
-        allow_origin: CORS allow origin header
-    """
-    # if port is None, find a free port
-    if port is None:
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            s.bind(("", 0))
-            port = s.getsockname()[1]
-
-    tmpdir = pathlib.Path(tmpdir)
-    tmpdir = tmpdir.resolve()
-    if not tmpdir.exists() or not tmpdir.is_dir():
-        raise SystemExit(f"Directory not found: {tmpdir}")
-
-    # Configure handler with directory and allow_origin
-    def handler_factory(*args, **kwargs):
-        return CORSRequestHandler(
-            *args, directory=str(tmpdir), allow_origin=allow_origin, **kwargs
-        )
-
-    httpd = ThreadingHTTPServer(("0.0.0.0", port), handler_factory)
-    print(f"Serving {tmpdir} at http://localhost:{port} (CORS → {allow_origin})")
-    thread = threading.Thread(target=httpd.serve_forever, daemon=True)
-    thread.start()
-
-    if open_in_browser:
-        webbrowser.open(f"http://localhost:{port}")
-        print(f"Opening http://localhost:{port} in your browser.")
-    else:
-        print(
-            f"Open http://localhost:{port} in your browser to view the visualization."
-        )
-
-    try:
-        input("Press Enter to stop...\n")
-    except (KeyboardInterrupt, EOFError):
-        pass
-    finally:
-        print("Shutting down server...")
-        httpd.shutdown()
-        httpd.server_close()
-        thread.join()
-
-
-def view_figure(archive_path: str, port: Union[int, None] = None) -> None:
-    """
-    Extract and serve a figure archive locally
-
-    Args:
-        archive_path: Path to the tar.gz archive
-        port: Optional port number to serve on
-    """
-    archive_pathlib = pathlib.Path(archive_path)
-
-    if not archive_pathlib.exists():
-        print(f"Error: Archive file not found: {archive_path}")
-        sys.exit(1)
-
-    if not archive_pathlib.suffix.lower() in [".gz", ".tgz"] or not str(
-        archive_pathlib
-    ).endswith(".tar.gz"):
-        print(f"Error: Expected a .tar.gz file, got: {archive_path}")
-        sys.exit(1)
-
-    print(f"Extracting figure archive: {archive_path}")
-
-    # Create temporary directory and extract files
-    with tempfile.TemporaryDirectory(prefix="figpack_view_") as temp_dir:
-        temp_path = pathlib.Path(temp_dir)
-
-        try:
-            with tarfile.open(archive_path, "r:gz") as tar:
-                tar.extractall(temp_path)
-
-            # Count extracted files
-            extracted_files = list(temp_path.rglob("*"))
-            file_count = len([f for f in extracted_files if f.is_file()])
-            print(f"Extracted {file_count} files")
-
-            # Check if index.html exists
-            index_html = temp_path / "index.html"
-            if not index_html.exists():
-                print("Warning: No index.html found in archive")
-                print("Available files:")
-                for f in sorted(extracted_files):
-                    if f.is_file():
-                        print(f"  {f.relative_to(temp_path)}")
-
-            # Serve the files
-            serve_files(
-                str(temp_path),
-                port=port,
-                open_in_browser=True,
-                allow_origin=None,
-            )
-
-        except tarfile.TarError as e:
-            print(f"Error: Failed to extract archive: {e}")
-            sys.exit(1)
-
-
 def main():
     """Main CLI entry point"""
     parser = argparse.ArgumentParser(

figpack/core/_bundle_utils.py

@@ -9,23 +9,23 @@ thisdir = pathlib.Path(__file__).parent.resolve()
 
 
 def prepare_figure_bundle(
-    view: FigpackView, tmpdir: str, *, title: str = None, description: str = None
+    view: FigpackView, tmpdir: str, *, title: str, description: str = None
 ) -> None:
     """
     Prepare a figure bundle in the specified temporary directory.
 
     This function:
-    1. Copies all files from the figpack-gui-dist directory to tmpdir
+    1. Copies all files from the figpack-figure-dist directory to tmpdir
     2. Writes the view data to a zarr group
     3. Consolidates zarr metadata
 
     Args:
         view: The figpack view to prepare
         tmpdir: The temporary directory to prepare the bundle in
-        title: Optional title for the figure
+        title: Title for the figure (required)
         description: Optional description for the figure (markdown supported)
     """
-    html_dir = thisdir / ".." / "figpack-gui-dist"
+    html_dir = thisdir / ".." / "figpack-figure-dist"
     if not os.path.exists(html_dir):
         raise SystemExit(f"Error: directory not found: {html_dir}")
 
@@ -50,8 +50,7 @@ def prepare_figure_bundle(
     view._write_to_zarr_group(zarr_group)
 
     # Add title and description as attributes on the top-level zarr group
-    if title is not None:
-        zarr_group.attrs["title"] = title
+    zarr_group.attrs["title"] = title
     if description is not None:
         zarr_group.attrs["description"] = description
 

figpack/core/_save_figure.py

@@ -0,0 +1,31 @@
+import pathlib
+import tempfile
+
+from ._bundle_utils import prepare_figure_bundle
+from .figpack_view import FigpackView
+
+
+def _save_figure(view: FigpackView, output_path: str, *, title: str):
+    """
+    Save the figure to a folder or a .tar.gz file
+
+    Args:
+        view: FigpackView instance to save
+        output_path: Output path (destination folder or .tar.gz file path)
+    """
+    output_path = pathlib.Path(output_path)
+    if (output_path.suffix == ".gz" and output_path.suffixes[-2] == ".tar") or (
+        output_path.suffix == ".tgz"
+    ):
+        # It's a .tar.gz file
+        with tempfile.TemporaryDirectory(prefix="figpack_save_") as tmpdir:
+            prepare_figure_bundle(view, tmpdir, title=title)
+            # Create tar.gz file
+            import tarfile
+
+            with tarfile.open(output_path, "w:gz") as tar:
+                tar.add(tmpdir, arcname=".")
+    else:
+        # It's a folder
+        output_path.mkdir(parents=True, exist_ok=True)
+        prepare_figure_bundle(view, str(output_path), title=title)

figpack/core/_server_manager.py

@@ -206,8 +206,6 @@ class ProcessServerManager:
         # Start directory monitoring thread
         self._start_directory_monitor()
 
-        print(f"Started figpack server at http://localhost:{port} serving {temp_dir}")
-
         return f"http://localhost:{port}", port
 
     def _stop_server(self):

figpack/core/_show_view.py

@@ -84,23 +84,18 @@ thisdir = pathlib.Path(__file__).parent.resolve()
 def _show_view(
     view: FigpackView,
     *,
-    open_in_browser: bool = False,
-    port: Union[int, None] = None,
-    allow_origin: Union[str, None] = None,
-    upload: bool = False,
-    ephemeral: bool = False,
-    title: Union[str, None] = None,
-    description: Union[str, None] = None,
-    inline: Union[bool, None] = None,
-    inline_height: int = 600,
-    _local_figure_name: Union[str, None] = None,
+    open_in_browser: bool,
+    port: Union[int, None],
+    allow_origin: Union[str, None],
+    upload: bool,
+    ephemeral: bool,
+    title: str,
+    description: Union[str, None],
+    inline: bool,
+    inline_height: int,
+    wait_for_input: bool,
+    _local_figure_name: Union[str, None],
 ):
-    # Determine if we should use inline display
-    use_inline = inline
-    if inline is None:
-        # Auto-detect: use inline if we're in a notebook
-        use_inline = _is_in_notebook()
-
     if upload:
         # Upload behavior: create temporary directory for this upload only
         with tempfile.TemporaryDirectory(prefix="figpack_upload_") as tmpdir:
@@ -115,10 +110,14 @@ def _show_view(
 
             # Upload the bundle
             figure_url = _upload_bundle(
-                tmpdir, api_key, title=title, ephemeral=ephemeral
+                tmpdir,
+                api_key,
+                title=title,
+                ephemeral=ephemeral,
+                use_consolidated_metadata_only=True,
             )
 
-            if use_inline:
+            if inline:
                 # For uploaded figures, display the remote URL inline and continue
                 _display_inline_iframe(figure_url, inline_height)
             else:
@@ -129,8 +128,9 @@ def _show_view(
                 else:
                     print(f"View the figure at: {figure_url}")
                 # Wait until user presses Enter
-                input("Press Enter to continue...")
 
+            if wait_for_input:
+                input("Press Enter to continue...")
             return figure_url
     else:
         # Local server behavior: use process-level server manager
@@ -155,7 +155,7 @@ def _show_view(
         figure_subdir_name = figure_dir.name
         figure_url = f"{base_url}/{figure_subdir_name}"
 
-        if use_inline:
+        if inline:
             # Display inline and continue (don't block)
             _display_inline_iframe(figure_url, inline_height)
         else:
@@ -165,7 +165,7 @@ def _show_view(
                 print(f"Opening {figure_url} in browser.")
             else:
                 print(f"Open {figure_url} in your browser to view the visualization.")
-            # Wait until user presses Enter
-            input("Press Enter to continue...")
 
+        if wait_for_input:
+            input("Press Enter to continue...")
         return figure_url

figpack/core/_upload_bundle.py

@@ -69,27 +69,54 @@ def _get_batch_signed_urls(figure_url: str, files_batch: list, api_key: str) ->
 
 
 def _upload_single_file_with_signed_url(
-    relative_path: str, file_path: pathlib.Path, signed_url: str
+    relative_path: str, file_path: pathlib.Path, signed_url: str, num_retries: int = 4
 ) -> str:
     """
-    Upload a single file using a pre-obtained signed URL
+    Upload a single file using a pre-obtained signed URL with exponential backoff retries
+
+    Args:
+        relative_path: The relative path of the file
+        file_path: The path to the file to upload
+        signed_url: The signed URL to upload to
+        num_retries: Number of retries on failure with exponential backoff (default: 4)
 
     Returns:
         str: The relative path of the uploaded file
+
+    Raises:
+        Exception: If upload fails after all retries are exhausted
     """
-    # Upload file to signed URL
     content_type = _determine_content_type(relative_path)
-    with open(file_path, "rb") as f:
-        upload_response = requests.put(
-            signed_url, data=f, headers={"Content-Type": content_type}
-        )
+    retries_remaining = num_retries
+    last_exception = None
 
-    if not upload_response.ok:
-        raise Exception(
-            f"Failed to upload {relative_path} to signed URL: HTTP {upload_response.status_code}"
-        )
+    while retries_remaining >= 0:
+        try:
+            with open(file_path, "rb") as f:
+                upload_response = requests.put(
+                    signed_url, data=f, headers={"Content-Type": content_type}
+                )
+
+            if upload_response.ok:
+                return relative_path
+
+            last_exception = Exception(
+                f"Failed to upload {relative_path} to signed URL: HTTP {upload_response.status_code}"
+            )
+        except Exception as e:
+            last_exception = e
+
+        if retries_remaining > 0:
+            backoff_seconds = 2 ** (num_retries - retries_remaining)
+            print(
+                f"Upload failed for {relative_path}, retrying in {backoff_seconds} seconds..."
+            )
+            time.sleep(backoff_seconds)
+            retries_remaining -= 1
+        else:
+            break
 
-    return relative_path
+    raise last_exception
 
 
 MAX_WORKERS_FOR_UPLOAD = 16
@@ -226,10 +253,22 @@ def _finalize_figure(figure_url: str, api_key: str) -> dict:
 
 
 def _upload_bundle(
-    tmpdir: str, api_key: str, title: str = None, ephemeral: bool = False
+    tmpdir: str,
+    api_key: str,
+    title: str = None,
+    ephemeral: bool = False,
+    use_consolidated_metadata_only: bool = False,
 ) -> str:
     """
     Upload the prepared bundle to the cloud using the new database-driven approach
+
+    Args:
+        tmpdir: Path to the temporary directory containing the bundle
+        api_key: API key for authentication
+        title: Optional title for the figure
+        ephemeral: Whether to create an ephemeral figure
+        use_consolidated_metadata_only: If True, excludes individual zarr metadata files
+            (.zgroup, .zarray, .zattrs) since they are included in .zmetadata
     """
     tmpdir_path = pathlib.Path(tmpdir)
 
@@ -241,6 +280,10 @@ def _upload_bundle(
     for file_path in tmpdir_path.rglob("*"):
         if file_path.is_file():
             relative_path = file_path.relative_to(tmpdir_path)
+            # Skip individual zarr metadata files if using consolidated metadata only
+            if use_consolidated_metadata_only:
+                if str(relative_path).endswith((".zgroup", ".zarray", ".zattrs")):
+                    continue
             all_files.append((str(relative_path), file_path))
 
     # Calculate total files and size for metadata
@@ -364,17 +407,13 @@ def _upload_bundle(
         if "manifest.json" not in signed_urls_map:
             raise Exception("No signed URL returned for manifest.json")
 
-        # Upload manifest using signed URL
-        upload_response = requests.put(
+        # Upload manifest using the same retry function
+        _upload_single_file_with_signed_url(
+            "manifest.json",
+            temp_file_path,
             signed_urls_map["manifest.json"],
-            data=manifest_content,
-            headers={"Content-Type": "application/json"},
+            num_retries=4,
         )
-
-        if not upload_response.ok:
-            raise Exception(
-                f"Failed to upload manifest.json to signed URL: HTTP {upload_response.status_code}"
-            )
     finally:
         # Clean up temporary file
         temp_file_path.unlink(missing_ok=True)

figpack/core/_view_figure.py

@@ -0,0 +1,138 @@
+"""
+Core functionality for viewing figures locally
+"""
+
+import pathlib
+import socket
+import sys
+import tarfile
+import tempfile
+import threading
+import webbrowser
+from typing import Union
+
+from ._server_manager import CORSRequestHandler, ThreadingHTTPServer
+
+
+def serve_files(
+    tmpdir: str,
+    *,
+    port: Union[int, None],
+    open_in_browser: bool = False,
+    allow_origin: Union[str, None] = None,
+):
+    """
+    Serve files from a directory using a simple HTTP server.
+
+    Args:
+        tmpdir: Directory to serve
+        port: Port number for local server
+        open_in_browser: Whether to open in browser automatically
+        allow_origin: CORS allow origin header
+    """
+    # if port is None, find a free port
+    if port is None:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("", 0))
+            port = s.getsockname()[1]
+
+    tmpdir = pathlib.Path(tmpdir)
+    tmpdir = tmpdir.resolve()
+    if not tmpdir.exists() or not tmpdir.is_dir():
+        raise SystemExit(f"Directory not found: {tmpdir}")
+
+    # Configure handler with directory and allow_origin
+    def handler_factory(*args, **kwargs):
+        return CORSRequestHandler(
+            *args, directory=str(tmpdir), allow_origin=allow_origin, **kwargs
+        )
+
+    httpd = ThreadingHTTPServer(("0.0.0.0", port), handler_factory)
+    print(f"Serving {tmpdir} at http://localhost:{port} (CORS → {allow_origin})")
+    thread = threading.Thread(target=httpd.serve_forever, daemon=True)
+    thread.start()
+
+    if open_in_browser:
+        webbrowser.open(f"http://localhost:{port}")
+        print(f"Opening http://localhost:{port} in your browser.")
+    else:
+        print(
+            f"Open http://localhost:{port} in your browser to view the visualization."
+        )
+
+    try:
+        input("Press Enter to stop...\n")
+    except (KeyboardInterrupt, EOFError):
+        pass
+    finally:
+        print("Shutting down server...")
+        httpd.shutdown()
+        httpd.server_close()
+        thread.join()
+
+
+def view_figure(figure_path: str, port: Union[int, None] = None) -> None:
+    """
+    Extract and serve a figure archive locally
+
+    Args:
+        figure_path: Path to a .tar.gz archive file or a directory
+        port: Optional port number to serve on
+    """
+    figure_pathlib = pathlib.Path(figure_path)
+
+    if not figure_pathlib.exists():
+        print(f"Error: Archive file not found: {figure_path}")
+        sys.exit(1)
+
+    if figure_pathlib.is_dir():
+        # We assume it's a directory
+        serve_files(
+            str(figure_pathlib),
+            port=port,
+            open_in_browser=True,
+            allow_origin=None,
+        )
+        return
+
+    if not figure_pathlib.suffix.lower() in [".gz", ".tgz"] or not str(
+        figure_pathlib
+    ).endswith(".tar.gz"):
+        print(f"Error: Archive file must be a .tar.gz file: {figure_path}")
+        sys.exit(1)
+
+    print(f"Extracting figure archive: {figure_path}")
+
+    # Create temporary directory and extract files
+    with tempfile.TemporaryDirectory(prefix="figpack_view_") as temp_dir:
+        temp_path = pathlib.Path(temp_dir)
+
+        try:
+            with tarfile.open(figure_path, "r:gz") as tar:
+                tar.extractall(temp_path)
+
+            # Count extracted files
+            extracted_files = list(temp_path.rglob("*"))
+            file_count = len([f for f in extracted_files if f.is_file()])
+            print(f"Extracted {file_count} files")
+
+            # Check if index.html exists
+            index_html = temp_path / "index.html"
+            if not index_html.exists():
+                print("Warning: No index.html found in archive")
+                print("Available files:")
+                for f in sorted(extracted_files):
+                    if f.is_file():
+                        print(f"  {f.relative_to(temp_path)}")
+
+            # Serve the files
+            serve_files(
+                str(temp_path),
+                port=port,
+                open_in_browser=True,
+                allow_origin=None,
+            )
+
+        except tarfile.TarError as e:
+            print(f"Error: Failed to extract archive: {e}")
+            sys.exit(1)