figpack 0.2.3__py3-none-any.whl → 0.2.5__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.3"
+__version__ = "0.2.5"
+
+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,7 +9,7 @@ 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.
@@ -22,7 +22,7 @@ def prepare_figure_bundle(
     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"
@@ -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):
+    """
+    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)
+            # 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))

figpack/core/_server_manager.py

@@ -138,11 +138,17 @@ class ProcessServerManager:
             self._create_process_info_file()
         return self._temp_dir
 
-    def create_figure_subdir(self) -> pathlib.Path:
+    def create_figure_subdir(
+        self, *, _local_figure_name: Optional[str] = None
+    ) -> pathlib.Path:
         """Create a unique subdirectory for a figure within the process temp dir."""
         temp_dir = self.get_temp_dir()
-        figure_id = str(uuid.uuid4())[:8]  # Short unique ID
-        figure_dir = temp_dir / f"figure_{figure_id}"
+        local_figure_name = (
+            "figure_" + str(uuid.uuid4())[:8]
+            if _local_figure_name is None
+            else _local_figure_name
+        )
+        figure_dir = temp_dir / f"{local_figure_name}"
         figure_dir.mkdir(exist_ok=True)
         return figure_dir
 
@@ -200,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,22 +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,
+    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:
@@ -117,7 +113,7 @@ def _show_view(
                 tmpdir, api_key, title=title, ephemeral=ephemeral
             )
 
-            if use_inline:
+            if inline:
                 # For uploaded figures, display the remote URL inline and continue
                 _display_inline_iframe(figure_url, inline_height)
             else:
@@ -128,15 +124,18 @@ 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
         server_manager = ProcessServerManager.get_instance()
 
         # Create figure subdirectory in process temp directory
-        figure_dir = server_manager.create_figure_subdir()
+        figure_dir = server_manager.create_figure_subdir(
+            _local_figure_name=_local_figure_name
+        )
 
         # Prepare the figure bundle in the subdirectory
         prepare_figure_bundle(
@@ -152,7 +151,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:
@@ -162,7 +161,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

@@ -11,7 +11,7 @@ import requests
 
 from .. import __version__
 
-from .config import FIGPACK_API_BASE_URL
+from .config import FIGPACK_API_BASE_URL, FIGPACK_BUCKET
 
 thisdir = pathlib.Path(__file__).parent.resolve()
 
@@ -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}
+                )
 
-    return relative_path
+            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
+
+    raise last_exception
 
 
 MAX_WORKERS_FOR_UPLOAD = 16
@@ -156,6 +183,7 @@ def _create_or_get_figure(
     payload = {
         "figureHash": figure_hash,
         "figpackVersion": __version__,
+        "bucket": FIGPACK_BUCKET,
     }
 
     # API key is optional for ephemeral figures
@@ -363,17 +391,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)

figpack/core/config.py

@@ -3,3 +3,5 @@ import os
 FIGPACK_API_BASE_URL = os.getenv(
     "FIGPACK_API_BASE_URL", "https://figpack-api.vercel.app"
 )
+
+FIGPACK_BUCKET = os.getenv("FIGPACK_BUCKET", "figpack-figures")