figpack 0.2.17__tar.gz → 0.2.19__tar.gz

{figpack-0.2.17/figpack.egg-info → figpack-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: figpack
-Version: 0.2.17
+Version: 0.2.19
 Summary: A Python package for creating shareable, interactive visualizations in the browser
 Author-email: Jeremy Magland <jmagland@flatironinstitute.org>
 License: Apache-2.0
@@ -69,6 +69,7 @@ Requires-Dist: sphinx-rtd-theme>=2.0; extra == "docs"
 Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "docs"
 Requires-Dist: linkify-it-py>=2.0; extra == "docs"
 Requires-Dist: sphinx-copybutton>=0.5; extra == "docs"
+Requires-Dist: lindi; extra == "docs"
 Dynamic: license-file
 
 # figpack

{figpack-0.2.17 → figpack-0.2.19}/figpack/__init__.py

@@ -2,7 +2,7 @@
 figpack - A Python package for creating shareable, interactive visualizations in the browser
 """
 
-__version__ = "0.2.17"
+__version__ = "0.2.19"
 
 from .cli import view_figure
 from .core import FigpackView, FigpackExtension, ExtensionView

{figpack-0.2.17 → figpack-0.2.19}/figpack/cli.py

@@ -18,6 +18,7 @@ import requests
 from . import __version__
 from .core._server_manager import CORSRequestHandler
 from .core._view_figure import serve_files, view_figure
+from .extensions import ExtensionManager
 
 MAX_WORKERS_FOR_DOWNLOAD = 16
 
@@ -214,6 +215,40 @@ def download_figure(figure_url: str, dest_path: str) -> None:
         print(f"Archive saved to: {dest_path}")
 
 
+def handle_extensions_command(args):
+    """Handle extensions subcommands"""
+    extension_manager = ExtensionManager()
+
+    if args.extensions_command == "list":
+        extension_manager.list_extensions()
+    elif args.extensions_command == "install":
+        if not args.extensions and not args.all:
+            print("Error: No extensions specified. Use extension names or --all flag.")
+            print("Example: figpack extensions install figpack_3d")
+            print("         figpack extensions install --all")
+            sys.exit(1)
+
+        success = extension_manager.install_extensions(
+            extensions=args.extensions, upgrade=args.upgrade, install_all=args.all
+        )
+
+        if not success:
+            sys.exit(1)
+
+    elif args.extensions_command == "uninstall":
+        success = extension_manager.uninstall_extensions(args.extensions)
+
+        if not success:
+            sys.exit(1)
+    else:
+        print("Available extension commands:")
+        print("  list      - List available extensions and their status")
+        print("  install   - Install or upgrade extension packages")
+        print("  uninstall - Uninstall extension packages")
+        print()
+        print("Use 'figpack extensions <command> --help' for more information.")
+
+
 def main():
     """Main CLI entry point"""
     parser = argparse.ArgumentParser(
@@ -240,12 +275,51 @@ def main():
         "--port", type=int, help="Port number to serve on (default: auto-select)"
     )
 
+    # Extensions command
+    extensions_parser = subparsers.add_parser(
+        "extensions", help="Manage figpack extension packages"
+    )
+    extensions_subparsers = extensions_parser.add_subparsers(
+        dest="extensions_command", help="Extension management commands"
+    )
+
+    # Extensions list subcommand
+    extensions_list_parser = extensions_subparsers.add_parser(
+        "list", help="List available extensions and their status"
+    )
+
+    # Extensions install subcommand
+    extensions_install_parser = extensions_subparsers.add_parser(
+        "install", help="Install or upgrade extension packages"
+    )
+    extensions_install_parser.add_argument(
+        "extensions",
+        nargs="*",
+        help="Extension package names to install (e.g., figpack_3d figpack_spike_sorting)",
+    )
+    extensions_install_parser.add_argument(
+        "--all", action="store_true", help="Install all available extensions"
+    )
+    extensions_install_parser.add_argument(
+        "--upgrade", action="store_true", help="Upgrade packages if already installed"
+    )
+
+    # Extensions uninstall subcommand
+    extensions_uninstall_parser = extensions_subparsers.add_parser(
+        "uninstall", help="Uninstall extension packages"
+    )
+    extensions_uninstall_parser.add_argument(
+        "extensions", nargs="+", help="Extension package names to uninstall"
+    )
+
     args = parser.parse_args()
 
     if args.command == "download":
         download_figure(args.figure_url, args.dest)
     elif args.command == "view":
         view_figure(args.archive, port=args.port)
+    elif args.command == "extensions":
+        handle_extensions_command(args)
     else:
         parser.print_help()
 

{figpack-0.2.17 → figpack-0.2.19}/figpack/core/_bundle_utils.py

@@ -73,11 +73,40 @@ def prepare_figure_bundle(
         _write_extension_manifest(required_extensions, tmpdir)
 
         zarr.consolidate_metadata(zarr_group._zarr_group.store)
+
+        # It's important that we remove all the metadata files except for the
+        # consolidated one, because otherwise we may get inconstencies
+        # once we start editing the zarr data from the browser.
+        _remove_metadata_files_except_consolidated(pathlib.Path(tmpdir) / "data.zarr")
     finally:
         if _check_zarr_version() == 3:
             zarr.config.set({"default_zarr_format": old_default_zarr_format})
 
 
+def _remove_metadata_files_except_consolidated(zarr_dir: pathlib.Path) -> None:
+    """
+    Remove all zarr metadata files except for the consolidated one.
+
+    Args:
+        zarr_dir: Path to the zarr directory
+    """
+    if not zarr_dir.is_dir():
+        raise ValueError(f"Expected a directory, got: {zarr_dir}")
+
+    for root, dirs, files in os.walk(zarr_dir):
+        for file in files:
+            if (
+                file.endswith(".zarray")
+                or file.endswith(".zgroup")
+                or file.endswith(".zattrs")
+            ):
+                file_path = pathlib.Path(root) / file
+                try:
+                    file_path.unlink()
+                except Exception as e:
+                    print(f"Warning: could not remove file {file_path}: {e}")
+
+
 def _discover_required_extensions(view: FigpackView) -> Set[str]:
     """
     Recursively discover all extensions required by a view and its children

figpack-0.2.19/figpack/core/_file_handler.py

@@ -0,0 +1,192 @@
+import os
+import pathlib
+import urllib.parse
+from http.server import SimpleHTTPRequestHandler
+from typing import Optional
+
+from ._server_manager import CORSRequestHandler
+
+
+class FileUploadCORSRequestHandler(CORSRequestHandler):
+    """
+    Extended CORS request handler that supports PUT requests for file uploads.
+    Only allows file operations within the served directory.
+    """
+
+    def __init__(
+        self,
+        *args,
+        allow_origin=None,
+        enable_file_upload=False,
+        max_file_size=10 * 1024 * 1024,
+        **kwargs,
+    ):
+        self.enable_file_upload = enable_file_upload
+        self.max_file_size = max_file_size  # Default 10MB
+        super().__init__(*args, allow_origin=allow_origin, **kwargs)
+
+    def end_headers(self):
+        if self.allow_origin is not None:
+            self.send_header("Access-Control-Allow-Origin", self.allow_origin)
+            self.send_header("Vary", "Origin")
+            # Add PUT to allowed methods if file upload is enabled
+            methods = "GET, HEAD, OPTIONS"
+            if self.enable_file_upload:
+                methods += ", PUT"
+            self.send_header("Access-Control-Allow-Methods", methods)
+            self.send_header(
+                "Access-Control-Allow-Headers", "Content-Type, Range, Content-Length"
+            )
+            self.send_header(
+                "Access-Control-Expose-Headers",
+                "Accept-Ranges, Content-Encoding, Content-Length, Content-Range",
+            )
+
+        # Prevent browser caching - important for when we are editing figures in place
+        # This ensures the browser always fetches the latest version of files
+        self.send_header("Cache-Control", "no-cache, no-store, must-revalidate")
+        self.send_header("Pragma", "no-cache")
+        self.send_header("Expires", "0")
+
+        super(SimpleHTTPRequestHandler, self).end_headers()
+
+    def do_PUT(self):
+        """Handle PUT requests for file uploads."""
+        if not self.enable_file_upload:
+            self.send_error(405, "Method Not Allowed")
+            return
+
+        try:
+            # Parse and validate the path
+            file_path = self._get_safe_file_path()
+            if file_path is None:
+                return  # Error already sent
+
+            # Check content length
+            content_length = self._get_content_length()
+            if content_length is None:
+                return  # Error already sent
+
+            # Determine if this will be a create or update
+            is_new_file = not file_path.exists()
+
+            # Read and write the file
+            if self._write_file_content(file_path, content_length):
+                # Send appropriate status code
+                status_code = 201 if is_new_file else 200
+                self.send_response(status_code)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+
+                response_data = f'{{"status": "success", "path": "{file_path.relative_to(pathlib.Path(self.directory))}"}}'
+                self.wfile.write(response_data.encode("utf-8"))
+
+        except Exception as e:
+            self.log_error(f"Error in PUT request: {e}")
+            self.send_error(500, f"Internal Server Error: {str(e)}")
+
+    def _get_safe_file_path(self) -> Optional[pathlib.Path]:
+        """
+        Parse and validate the requested file path.
+        Returns None if the path is invalid or unsafe.
+        """
+        # Parse the URL path
+        parsed_path = urllib.parse.urlparse(self.path).path
+
+        # Remove leading slash and decode URL encoding
+        relative_path = urllib.parse.unquote(parsed_path.lstrip("/"))
+
+        # Prevent empty paths
+        if not relative_path:
+            self.send_error(400, "Bad Request: Empty file path")
+            return None
+
+        # Get the served directory
+        served_dir = pathlib.Path(self.directory).resolve()
+
+        # Construct the target file path
+        target_path = served_dir / relative_path
+
+        try:
+            # Resolve the path to handle any .. or . components
+            resolved_path = target_path.resolve()
+
+            # Ensure the resolved path is within the served directory
+            if not str(resolved_path).startswith(str(served_dir)):
+                self.send_error(403, "Forbidden: Path outside served directory")
+                return None
+
+        except (OSError, ValueError) as e:
+            self.send_error(400, f"Bad Request: Invalid path - {str(e)}")
+            return None
+
+        return resolved_path
+
+    def _get_content_length(self) -> Optional[int]:
+        """
+        Get and validate the content length from headers.
+        Returns None if invalid or too large.
+        """
+        content_length_header = self.headers.get("Content-Length")
+        if not content_length_header:
+            self.send_error(400, "Bad Request: Content-Length header required")
+            return None
+
+        try:
+            content_length = int(content_length_header)
+        except ValueError:
+            self.send_error(400, "Bad Request: Invalid Content-Length")
+            return None
+
+        if content_length < 0:
+            self.send_error(400, "Bad Request: Negative Content-Length")
+            return None
+
+        if content_length > self.max_file_size:
+            self.send_error(
+                413,
+                f"Payload Too Large: Maximum file size is {self.max_file_size} bytes",
+            )
+            return None
+
+        return content_length
+
+    def _write_file_content(self, file_path: pathlib.Path, content_length: int) -> bool:
+        """
+        Write the request body content to the specified file.
+        Returns True on success, False on failure (error already sent).
+        """
+        try:
+            # Create parent directories if they don't exist
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write the file content
+            with open(file_path, "wb") as f:
+                remaining = content_length
+                while remaining > 0:
+                    # Read in chunks to handle large files efficiently
+                    chunk_size = min(8192, remaining)
+                    chunk = self.rfile.read(chunk_size)
+
+                    if not chunk:
+                        # Unexpected end of data
+                        self.send_error(400, "Bad Request: Incomplete data")
+                        return False
+
+                    f.write(chunk)
+                    remaining -= len(chunk)
+
+            return True
+
+        except OSError as e:
+            self.send_error(
+                500, f"Internal Server Error: Could not write file - {str(e)}"
+            )
+            return False
+        except Exception as e:
+            self.send_error(500, f"Internal Server Error: {str(e)}")
+            return False
+
+    def log_message(self, fmt, *args):
+        """Override to suppress default logging (same as parent class)."""
+        pass

{figpack-0.2.17 → figpack-0.2.19}/figpack/core/_server_manager.py

@@ -28,12 +28,23 @@ class CORSRequestHandler(SimpleHTTPRequestHandler):
                 "Access-Control-Expose-Headers",
                 "Accept-Ranges, Content-Encoding, Content-Length, Content-Range",
             )
+
+        # Prevent browser caching - important for when we are editing figures in place
+        # This ensures the browser always fetches the latest version of files
+        self.send_header("Cache-Control", "no-cache, no-store, must-revalidate")
+        self.send_header("Pragma", "no-cache")
+        self.send_header("Expires", "0")
+
         super().end_headers()
 
     def do_OPTIONS(self):
         self.send_response(204, "No Content")
         self.end_headers()
 
+    def do_PUT(self):
+        """Reject PUT requests when file upload is not enabled."""
+        self.send_error(405, "Method Not Allowed")
+
     def log_message(self, fmt, *args):
         pass
 
@@ -153,11 +164,21 @@ class ProcessServerManager:
         return figure_dir
 
     def start_server(
-        self, port: Optional[int] = None, allow_origin: Optional[str] = None
+        self,
+        port: Optional[int] = None,
+        allow_origin: Optional[str] = None,
+        enable_file_upload: bool = False,
+        max_file_size: int = 10 * 1024 * 1024,
     ) -> tuple[str, int]:
         """
         Start the server if not already running, or return existing server info.
 
+        Args:
+            port: Port to bind to (auto-selected if None)
+            allow_origin: CORS origin to allow (None for no CORS)
+            enable_file_upload: Whether to enable PUT requests for file uploads
+            max_file_size: Maximum file size in bytes for uploads (default 10MB)
+
         Returns:
             tuple: (base_url, port)
         """
@@ -184,11 +205,26 @@ class ProcessServerManager:
 
         temp_dir = self.get_temp_dir()
 
-        # Configure handler with directory and allow_origin
-        def handler_factory(*args, **kwargs):
-            return CORSRequestHandler(
-                *args, directory=str(temp_dir), allow_origin=allow_origin, **kwargs
-            )
+        # Choose handler based on file upload requirement
+        if enable_file_upload:
+            from ._file_handler import FileUploadCORSRequestHandler
+
+            def handler_factory(*args, **kwargs):
+                return FileUploadCORSRequestHandler(
+                    *args,
+                    directory=str(temp_dir),
+                    allow_origin=allow_origin,
+                    enable_file_upload=True,
+                    max_file_size=max_file_size,
+                    **kwargs,
+                )
+
+        else:
+
+            def handler_factory(*args, **kwargs):
+                return CORSRequestHandler(
+                    *args, directory=str(temp_dir), allow_origin=allow_origin, **kwargs
+                )
 
         self._server = ThreadingHTTPServer(("0.0.0.0", port), handler_factory)
         self._port = port

{figpack-0.2.17 → figpack-0.2.19}/figpack/core/_show_view.py

@@ -148,7 +148,7 @@ def _show_view(
 
         # Start or get existing server
         base_url, server_port = server_manager.start_server(
-            port=port, allow_origin=allow_origin
+            port=port, allow_origin=allow_origin, enable_file_upload=True
         )
 
         # Construct URL to the specific figure subdirectory

{figpack-0.2.17 → figpack-0.2.19}/figpack/core/_view_figure.py

@@ -11,7 +11,7 @@ import threading
 import webbrowser
 from typing import Union
 
-from ._server_manager import CORSRequestHandler, ThreadingHTTPServer
+from ._server_manager import ProcessServerManager
 
 
 def serve_files(
@@ -20,35 +20,66 @@ def serve_files(
     port: Union[int, None],
     open_in_browser: bool = False,
     allow_origin: Union[str, None] = None,
+    enable_file_upload: bool = False,
+    max_file_size: int = 10 * 1024 * 1024,
 ):
     """
-    Serve files from a directory using a simple HTTP server.
+    Serve files from a directory using the ProcessServerManager.
 
     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
+        enable_file_upload: Whether to enable PUT requests for file uploads
+        max_file_size: Maximum file size in bytes for uploads (default 10MB)
     """
+    tmpdir = pathlib.Path(tmpdir)
+    tmpdir = tmpdir.resolve()
+    if not tmpdir.exists() or not tmpdir.is_dir():
+        raise SystemExit(f"Directory not found: {tmpdir}")
+
+    # Create a temporary server manager instance for this specific directory
+    # Note: We can't use the singleton ProcessServerManager here because it serves
+    # from its own temp directory, but we need to serve from the specified tmpdir
+
+    # Import the required classes for direct server creation
+    from ._server_manager import CORSRequestHandler, ThreadingHTTPServer
+    from ._file_handler import FileUploadCORSRequestHandler
+
     # 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}")
+    # Choose handler based on file upload requirement
+    if enable_file_upload:
+
+        def handler_factory(*args, **kwargs):
+            return FileUploadCORSRequestHandler(
+                *args,
+                directory=str(tmpdir),
+                allow_origin=allow_origin,
+                enable_file_upload=True,
+                max_file_size=max_file_size,
+                **kwargs,
+            )
 
-    # Configure handler with directory and allow_origin
-    def handler_factory(*args, **kwargs):
-        return CORSRequestHandler(
-            *args, directory=str(tmpdir), allow_origin=allow_origin, **kwargs
-        )
+        upload_status = " (file upload enabled)" if enable_file_upload else ""
+    else:
+
+        def handler_factory(*args, **kwargs):
+            return CORSRequestHandler(
+                *args, directory=str(tmpdir), allow_origin=allow_origin, **kwargs
+            )
+
+        upload_status = ""
 
     httpd = ThreadingHTTPServer(("0.0.0.0", port), handler_factory)
-    print(f"Serving {tmpdir} at http://localhost:{port} (CORS → {allow_origin})")
+    print(
+        f"Serving {tmpdir} at http://localhost:{port} (CORS → {allow_origin}){upload_status}"
+    )
     thread = threading.Thread(target=httpd.serve_forever, daemon=True)
     thread.start()