figpack 0.2.16__tar.gz → 0.2.18__tar.gz

{figpack-0.2.16/figpack.egg-info → figpack-0.2.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: figpack
-Version: 0.2.16
+Version: 0.2.18
 Summary: A Python package for creating shareable, interactive visualizations in the browser
 Author-email: Jeremy Magland <jmagland@flatironinstitute.org>
 License: Apache-2.0

{figpack-0.2.16 → figpack-0.2.18}/figpack/__init__.py

@@ -2,17 +2,16 @@
 figpack - A Python package for creating shareable, interactive visualizations in the browser
 """
 
-__version__ = "0.2.16"
+__version__ = "0.2.18"
 
 from .cli import view_figure
-from .core import FigpackView, FigpackExtension, ExtensionRegistry, ExtensionView
+from .core import FigpackView, FigpackExtension, ExtensionView
 from .core.zarr import Group
 
 __all__ = [
     "view_figure",
     "FigpackView",
     "FigpackExtension",
-    "ExtensionRegistry",
     "ExtensionView",
     "Group",
 ]

{figpack-0.2.16 → figpack-0.2.18}/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.18/figpack/core/__init__.py

@@ -0,0 +1,5 @@
+from .figpack_view import FigpackView
+from .figpack_extension import FigpackExtension
+from .extension_view import ExtensionView
+
+__all__ = ["FigpackView", "FigpackExtension", "ExtensionView"]

{figpack-0.2.16 → figpack-0.2.18}/figpack/core/_bundle_utils.py

@@ -1,11 +1,12 @@
 import os
 import pathlib
+import json
 from typing import Set
 
 import zarr
 
 from .figpack_view import FigpackView
-from .figpack_extension import ExtensionRegistry
+from .figpack_extension import FigpackExtension
 from .extension_view import ExtensionView
 from .zarr import Group, _check_zarr_version
 
@@ -68,12 +69,44 @@ def prepare_figure_bundle(
         required_extensions = _discover_required_extensions(view)
         _write_extension_files(required_extensions, tmpdir)
 
+        # Generate extension manifest
+        _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
@@ -84,7 +117,8 @@ def _discover_required_extensions(view: FigpackView) -> Set[str]:
     Returns:
         Set of extension names required by this view hierarchy
     """
-    extensions = set()
+    extension_names_discovered = set()
+    extensions_discovered = []
     visited = set()  # Prevent infinite recursion
 
     def _collect_extensions(v: FigpackView):
@@ -95,7 +129,9 @@ def _discover_required_extensions(view: FigpackView) -> Set[str]:
 
         # Check if this view is an extension view
         if isinstance(v, ExtensionView):
-            extensions.add(v.extension_name)
+            if v.extension.name not in extension_names_discovered:
+                extension_names_discovered.add(v.extension.name)
+                extensions_discovered.append(v.extension)
 
         # Recursively check all attributes that might contain child views
         for attr_name in dir(v):
@@ -130,10 +166,10 @@ def _discover_required_extensions(view: FigpackView) -> Set[str]:
                 continue
 
     _collect_extensions(view)
-    return extensions
+    return extensions_discovered
 
 
-def _write_extension_files(extension_names: Set[str], tmpdir: str) -> None:
+def _write_extension_files(extensions, tmpdir: str) -> None:
     """
     Write JavaScript files for the required extensions
 
@@ -141,20 +177,11 @@ def _write_extension_files(extension_names: Set[str], tmpdir: str) -> None:
         extension_names: Set of extension names to write
         tmpdir: Directory to write extension files to
     """
-    if not extension_names:
-        return
-
-    registry = ExtensionRegistry.get_instance()
     tmpdir_path = pathlib.Path(tmpdir)
 
-    for extension_name in extension_names:
-        extension = registry.get_extension(extension_name)
-        if extension is None:
-            raise RuntimeError(
-                f"Extension '{extension_name}' is required but not registered"
-            )
-
-        # Write the main JavaScript file
+    for extension in extensions:
+        if not isinstance(extension, FigpackExtension):
+            raise ValueError("Expected a FigpackExtension instance")
         js_filename = extension.get_javascript_filename()
         js_path = tmpdir_path / js_filename
 
@@ -164,7 +191,7 @@ def _write_extension_files(extension_names: Set[str], tmpdir: str) -> None:
  * Version: {extension.version}
  * Generated automatically - do not edit
  */
-
+ 
 {extension.javascript_code}
 """
 
@@ -187,3 +214,43 @@ def _write_extension_files(extension_names: Set[str], tmpdir: str) -> None:
 """
 
             additional_path.write_text(additional_js_content, encoding="utf-8")
+
+
+def _write_extension_manifest(extensions, tmpdir: str) -> None:
+    """
+    Write the extension manifest file that lists all extensions and their files
+
+    Args:
+        extensions: List of FigpackExtension instances
+        tmpdir: Directory to write the manifest file to
+    """
+    tmpdir_path = pathlib.Path(tmpdir)
+    manifest_path = tmpdir_path / "extension_manifest.json"
+
+    # Build the manifest data
+    manifest_data = {"extensions": []}
+
+    for extension in extensions:
+        if not isinstance(extension, FigpackExtension):
+            raise ValueError("Expected a FigpackExtension instance")
+
+        # Get the main script filename
+        main_script = extension.get_javascript_filename()
+
+        # Get additional script filenames
+        additional_filenames = extension.get_additional_filenames()
+        additional_scripts = list(additional_filenames.values())
+
+        extension_entry = {
+            "name": extension.name,
+            "mainScript": main_script,
+            "additionalScripts": additional_scripts,
+            "version": extension.version,
+        }
+
+        manifest_data["extensions"].append(extension_entry)
+
+    # Write the manifest file
+    manifest_path.write_text(
+        json.dumps(manifest_data, indent=2, ensure_ascii=False), encoding="utf-8"
+    )

figpack-0.2.18/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.16 → figpack-0.2.18}/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.16 → figpack-0.2.18}/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.16 → figpack-0.2.18}/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()