figpack 0.2.15__py3-none-any.whl → 0.2.17__py3-none-any.whl

figpack/__init__.py

@@ -2,15 +2,16 @@
 figpack - A Python package for creating shareable, interactive visualizations in the browser
 """
 
-__version__ = "0.2.15"
+__version__ = "0.2.17"
 
 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/core/__init__.py

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

figpack/core/_bundle_utils.py

@@ -1,12 +1,14 @@
 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
 
 thisdir = pathlib.Path(__file__).parent.resolve()
 
@@ -45,24 +47,35 @@ def prepare_figure_bundle(
                 target_sub = target / subitem.name
                 target_sub.write_bytes(subitem.read_bytes())
 
-    # Write the view data to the Zarr group
-    zarr_group = zarr.open_group(
-        pathlib.Path(tmpdir) / "data.zarr",
-        mode="w",
-        synchronizer=zarr.ThreadSynchronizer(),
-    )
-    view._write_to_zarr_group(zarr_group)
+    # If we are using zarr 3, then we set the default zarr format to 2 temporarily
+    # because we only support version 2 on the frontend right now.
+
+    if _check_zarr_version() == 3:
+        old_default_zarr_format = zarr.config.get("default_zarr_format")
+        zarr.config.set({"default_zarr_format": 2})
+
+    try:
+        # Write the view data to the Zarr group
+        zarr_group = zarr.open_group(pathlib.Path(tmpdir) / "data.zarr", mode="w")
+        zarr_group = Group(zarr_group)
+        view._write_to_zarr_group(zarr_group)
 
-    # Add title and description as attributes on the top-level zarr group
-    zarr_group.attrs["title"] = title
-    if description is not None:
-        zarr_group.attrs["description"] = description
+        # Add title and description as attributes on the top-level zarr group
+        zarr_group.attrs["title"] = title
+        if description is not None:
+            zarr_group.attrs["description"] = description
 
-    # Discover and write extension JavaScript files
-    required_extensions = _discover_required_extensions(view)
-    _write_extension_files(required_extensions, tmpdir)
+        # Discover and write extension JavaScript files
+        required_extensions = _discover_required_extensions(view)
+        _write_extension_files(required_extensions, tmpdir)
 
-    zarr.consolidate_metadata(zarr_group.store)
+        # Generate extension manifest
+        _write_extension_manifest(required_extensions, tmpdir)
+
+        zarr.consolidate_metadata(zarr_group._zarr_group.store)
+    finally:
+        if _check_zarr_version() == 3:
+            zarr.config.set({"default_zarr_format": old_default_zarr_format})
 
 
 def _discover_required_extensions(view: FigpackView) -> Set[str]:
@@ -75,7 +88,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):
@@ -86,7 +100,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):
@@ -121,10 +137,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
 
@@ -132,20 +148,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
 
@@ -155,7 +162,7 @@ def _write_extension_files(extension_names: Set[str], tmpdir: str) -> None:
  * Version: {extension.version}
  * Generated automatically - do not edit
  */
-
+ 
 {extension.javascript_code}
 """
 
@@ -178,3 +185,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/core/_view_figure.py

@@ -109,7 +109,7 @@ def view_figure(figure_path: str, port: Union[int, None] = None) -> None:
 
         try:
             with tarfile.open(figure_path, "r:gz") as tar:
-                tar.extractall(temp_path)
+                tar.extractall(temp_path, filter="data")
 
             # Count extracted files
             extracted_files = list(temp_path.rglob("*"))

figpack/core/extension_view.py

@@ -2,9 +2,9 @@
 Base class for views that use figpack extensions
 """
 
-import zarr
 from .figpack_view import FigpackView
-from .figpack_extension import ExtensionRegistry
+from .figpack_extension import FigpackExtension
+from ..core.zarr import Group
 
 
 class ExtensionView(FigpackView):
@@ -12,7 +12,7 @@ class ExtensionView(FigpackView):
     Base class for views that are rendered by figpack extensions
     """
 
-    def __init__(self, *, extension_name: str):
+    def __init__(self, *, extension: FigpackExtension, view_type: str):
         """
         Initialize an extension-based view
 
@@ -20,19 +20,10 @@ class ExtensionView(FigpackView):
             extension_name: Name of the extension that will render this view
         """
         super().__init__()
-        self.extension_name = extension_name
-
-        # Validate that the extension is registered
-        registry = ExtensionRegistry.get_instance()
-        extension = registry.get_extension(extension_name)
-        if extension is None:
-            raise ValueError(
-                f"Extension '{extension_name}' is not registered. "
-                f"Make sure to register the extension before creating views that use it."
-            )
         self.extension = extension
+        self.view_type = view_type
 
-    def _write_to_zarr_group(self, group: zarr.Group) -> None:
+    def _write_to_zarr_group(self, group: Group) -> None:
         """
         Write the extension view metadata to a Zarr group.
         Subclasses should call super()._write_to_zarr_group(group) first,
@@ -42,18 +33,9 @@ class ExtensionView(FigpackView):
             group: Zarr group to write data into
         """
         # Set the view type to indicate this is an extension view
-        group.attrs["view_type"] = "ExtensionView"
+        group.attrs["view_type"] = self.view_type
 
         # Store the extension name so the frontend knows which extension to use
-        group.attrs["extension_name"] = self.extension_name
-
-        # Store additional script names
-        group.attrs["additional_script_names"] = list(
-            self.extension.get_additional_filenames().keys()
-        )
-
-        # Store extension metadata for debugging/compatibility
-        registry = ExtensionRegistry.get_instance()
-        extension = registry.get_extension(self.extension_name)
-        if extension:
-            group.attrs["extension_version"] = extension.version
+        group.attrs["extension_name"] = self.extension.name
+
+        group.attrs["extension_version"] = self.extension.version

figpack/core/figpack_extension.py

@@ -64,74 +64,3 @@ class FigpackExtension:
             original_name: f"extension-{safe_name}-{original_name}"
             for original_name in self.additional_files.keys()
         }
-
-
-class ExtensionRegistry:
-    """
-    Singleton registry for managing figpack extensions
-    """
-
-    _instance: Optional["ExtensionRegistry"] = None
-
-    def __init__(self):
-        self._extensions: Dict[str, FigpackExtension] = {}
-
-    @classmethod
-    def get_instance(cls) -> "ExtensionRegistry":
-        """Get the singleton instance of the extension registry"""
-        if cls._instance is None:
-            cls._instance = cls()
-        return cls._instance
-
-    @classmethod
-    def register(cls, extension: FigpackExtension) -> None:
-        """
-        Register an extension with the global registry
-
-        Args:
-            extension: The extension to register
-        """
-        registry = cls.get_instance()
-        registry._register_extension(extension)
-
-    def _register_extension(self, extension: FigpackExtension) -> None:
-        """
-        Internal method to register an extension
-
-        Args:
-            extension: The extension to register
-        """
-        if extension.name in self._extensions:
-            existing = self._extensions[extension.name]
-            if existing.version != extension.version:
-                print(
-                    f"Warning: Replacing extension '{extension.name}' "
-                    f"version {existing.version} with version {extension.version}"
-                )
-
-        self._extensions[extension.name] = extension
-
-    def get_extension(self, name: str) -> Optional[FigpackExtension]:
-        """
-        Get an extension by name
-
-        Args:
-            name: Name of the extension to retrieve
-
-        Returns:
-            The extension if found, None otherwise
-        """
-        return self._extensions.get(name)
-
-    def get_all_extensions(self) -> Dict[str, FigpackExtension]:
-        """
-        Get all registered extensions
-
-        Returns:
-            Dictionary mapping extension names to extension objects
-        """
-        return self._extensions.copy()
-
-    def clear(self) -> None:
-        """Clear all registered extensions (mainly for testing)"""
-        self._extensions.clear()

figpack/core/figpack_view.py

@@ -7,7 +7,7 @@ import random
 import string
 from typing import Union
 
-import zarr
+from .zarr import Group
 
 
 class FigpackView:
@@ -155,7 +155,7 @@ class FigpackView:
 
         _save_figure(self, output_path, title=title)
 
-    def _write_to_zarr_group(self, group: zarr.Group) -> None:
+    def _write_to_zarr_group(self, group: Group) -> None:
         """
         Write the view data to a Zarr group. Must be implemented by subclasses.
 

figpack/core/zarr.py

@@ -0,0 +1,61 @@
+from typing import Any, Dict
+import zarr
+
+
+_UNSPECIFIED = object()
+
+
+class Group:
+    def __init__(self, zarr_group: zarr.Group):
+        self._zarr_group = zarr_group
+
+    def create_group(self, name: str) -> "Group":
+        return Group(self._zarr_group.create_group(name))
+
+    def create_dataset(
+        self,
+        name: str,
+        *,
+        data=_UNSPECIFIED,
+        dtype=_UNSPECIFIED,
+        chunks=_UNSPECIFIED,
+        compressor=_UNSPECIFIED,
+    ) -> None:
+        kwargs = {}
+        if data is not _UNSPECIFIED:
+            kwargs["data"] = data
+        if dtype is not _UNSPECIFIED:
+            kwargs["dtype"] = dtype
+        if chunks is not _UNSPECIFIED:
+            kwargs["chunks"] = chunks
+        if compressor is not _UNSPECIFIED:
+            kwargs["compressor"] = compressor
+        if _check_zarr_version() == 2:
+            self._zarr_group.create_dataset(name, **kwargs)
+        elif _check_zarr_version() == 3:
+            self._zarr_group.create_array(name, **kwargs)
+        else:
+            raise RuntimeError("Unsupported Zarr version")
+
+    @property
+    def attrs(self) -> Dict[str, Any]:
+        return self._zarr_group.attrs
+
+    def __getitem__(self, key: str) -> Any:
+        return self._zarr_group[key]
+
+    # implement in operator
+    def __contains__(self, key: str) -> bool:
+        return key in self._zarr_group
+
+    def __iter__(self):
+        return iter(self._zarr_group)
+
+    def __reversed__(self):
+        return reversed(self._zarr_group)
+
+
+def _check_zarr_version():
+    version = zarr.__version__
+    major_version = int(version.split(".")[0])
+    return major_version