scitex 2.7.3__py3-none-any.whl → 2.8.1__py3-none-any.whl

scitex/fig/io/_bundle.py

@@ -333,31 +333,57 @@ def _copy_nested_pltz_bundles(plots: Dict[str, Any], dir_path: Path) -> None:
 
     Args:
         plots: Dict mapping panel IDs to either:
-            - source_path: Path to existing .pltz.d directory
+            - source_path: Path to existing .pltz.d directory or .pltz zip
             - bundle_data: Dict with spec/data (will use save_bundle)
         dir_path: Target figz directory.
     """
     for panel_id, plot_source in plots.items():
-        target_path = dir_path / f"{panel_id}.pltz.d"
-
         if isinstance(plot_source, (str, Path)):
             # Direct copy from source path
             source_path = Path(plot_source)
-            if source_path.exists() and source_path.is_dir():
+
+            if source_path.is_dir() and str(source_path).endswith('.pltz.d'):
+                # Source is .pltz.d directory - copy as directory
+                target_path = dir_path / f"{panel_id}.pltz.d"
                 if target_path.exists():
                     shutil.rmtree(target_path)
                 shutil.copytree(source_path, target_path)
+
+            elif source_path.is_file() and str(source_path).endswith('.pltz'):
+                # Source is .pltz zip file - copy as zip file (preserving zip format)
+                target_path = dir_path / f"{panel_id}.pltz"
+                if target_path.exists():
+                    target_path.unlink()
+                shutil.copy2(source_path, target_path)
+
+            elif source_path.exists():
+                # Unknown format - try to copy as directory
+                target_path = dir_path / f"{panel_id}.pltz.d"
+                if source_path.is_dir():
+                    if target_path.exists():
+                        shutil.rmtree(target_path)
+                    shutil.copytree(source_path, target_path)
+
         elif isinstance(plot_source, dict):
             # Check if it has source_path for direct copy
             if "source_path" in plot_source:
                 source_path = Path(plot_source["source_path"])
-                if source_path.exists() and source_path.is_dir():
+                if source_path.is_file() and str(source_path).endswith('.pltz'):
+                    # .pltz zip file
+                    target_path = dir_path / f"{panel_id}.pltz"
+                    if target_path.exists():
+                        target_path.unlink()
+                    shutil.copy2(source_path, target_path)
+                elif source_path.exists() and source_path.is_dir():
+                    # .pltz.d directory
+                    target_path = dir_path / f"{panel_id}.pltz.d"
                     if target_path.exists():
                         shutil.rmtree(target_path)
                     shutil.copytree(source_path, target_path)
             else:
                 # Fallback to save_bundle (will lose images)
                 from scitex.io._bundle import save_bundle, BundleType
+                target_path = dir_path / f"{panel_id}.pltz.d"
                 save_bundle(plot_source, target_path, bundle_type=BundleType.PLTZ)
 
 
@@ -376,9 +402,33 @@ def _generate_figz_overview(dir_path: Path, spec: Dict, data: Dict, basename: st
     from PIL import Image
     import numpy as np
     import warnings
+    import tempfile
+    import zipfile
+
+    # Find all panel bundles (both .pltz.d directories and .pltz zip files)
+    panel_dirs = []
+    temp_dirs_to_cleanup = []
+
+    for item in dir_path.iterdir():
+        if item.is_dir() and str(item).endswith('.pltz.d'):
+            panel_dirs.append(item)
+        elif item.is_file() and str(item).endswith('.pltz'):
+            # Extract .pltz zip to temp directory for overview generation
+            temp_dir = tempfile.mkdtemp(prefix=f'scitex_overview_{item.stem}_')
+            temp_dirs_to_cleanup.append(temp_dir)
+            with zipfile.ZipFile(item, 'r') as zf:
+                zf.extractall(temp_dir)
+            # Find the extracted .pltz.d directory
+            extracted = Path(temp_dir)
+            for subitem in extracted.iterdir():
+                if subitem.is_dir() and str(subitem).endswith('.pltz.d'):
+                    panel_dirs.append(subitem)
+                    break
+            else:
+                # Use temp dir directly if no .pltz.d subfolder
+                panel_dirs.append(extracted)
 
-    # Find all panel directories
-    panel_dirs = sorted(dir_path.glob("*.pltz.d"))
+    panel_dirs = sorted(panel_dirs, key=lambda x: x.name)
     n_panels = len(panel_dirs)
 
     if n_panels == 0:
@@ -519,6 +569,13 @@ def _generate_figz_overview(dir_path: Path, spec: Dict, data: Dict, basename: st
         fig.savefig(overview_path, dpi=150, bbox_inches="tight", facecolor="white")
     plt.close(fig)
 
+    # Cleanup temp directories
+    for temp_dir in temp_dirs_to_cleanup:
+        try:
+            shutil.rmtree(temp_dir)
+        except Exception:
+            pass
+
 
 def _draw_bboxes_from_geometry(ax, geometry_data: Dict) -> None:
     """Draw bboxes from geometry data on an axes.
@@ -745,6 +802,8 @@ def _generate_figz_geometry_cache(dir_path: Path, spec: Dict, basename: str) ->
         basename: Base filename for bundle files.
     """
     from datetime import datetime
+    import tempfile
+    import zipfile
 
     cache_dir = dir_path / "cache"
     cache_dir.mkdir(parents=True, exist_ok=True)
@@ -756,11 +815,30 @@ def _generate_figz_geometry_cache(dir_path: Path, spec: Dict, basename: str) ->
         "generated_at": datetime.now().isoformat(),
     }
 
-    # Find all panel directories
-    panel_dirs = sorted(dir_path.glob("*.pltz.d"))
+    # Find all panel bundles (both .pltz.d directories and .pltz zip files)
+    panel_sources = []
+    temp_dirs_to_cleanup = []
+
+    for item in dir_path.iterdir():
+        if item.is_dir() and str(item).endswith('.pltz.d'):
+            panel_sources.append((item.stem.replace('.pltz', ''), item))
+        elif item.is_file() and str(item).endswith('.pltz'):
+            # Extract .pltz zip to temp directory
+            temp_dir = tempfile.mkdtemp(prefix=f'scitex_geom_{item.stem}_')
+            temp_dirs_to_cleanup.append(temp_dir)
+            with zipfile.ZipFile(item, 'r') as zf:
+                zf.extractall(temp_dir)
+            extracted = Path(temp_dir)
+            for subitem in extracted.iterdir():
+                if subitem.is_dir() and str(subitem).endswith('.pltz.d'):
+                    panel_sources.append((item.stem, subitem))
+                    break
+            else:
+                panel_sources.append((item.stem, extracted))
 
-    for panel_dir in panel_dirs:
-        panel_id = panel_dir.stem.replace(".pltz", "")
+    panel_sources = sorted(panel_sources, key=lambda x: x[0])
+
+    for panel_id, panel_dir in panel_sources:
 
         # Load panel geometry
         panel_geometry_path = panel_dir / "cache" / "geometry_px.json"
@@ -790,7 +868,7 @@ def _generate_figz_geometry_cache(dir_path: Path, spec: Dict, basename: str) ->
         "figure_id": basename,
         "generated_at": datetime.now().isoformat(),
         "size_mm": [size.get("width_mm", 0), size.get("height_mm", 0)],
-        "panels_count": len(panel_dirs),
+        "panels_count": len(panel_sources),
         "schema": spec.get("schema", {}),
     }
 
@@ -798,6 +876,13 @@ def _generate_figz_geometry_cache(dir_path: Path, spec: Dict, basename: str) ->
     with open(manifest_path, "w") as f:
         json.dump(manifest, f, indent=2)
 
+    # Cleanup temp directories
+    for temp_dir in temp_dirs_to_cleanup:
+        try:
+            shutil.rmtree(temp_dir)
+        except Exception:
+            pass
+
 
 def _embed_metadata_in_export(
     file_path: Path, spec: Dict[str, Any], fmt: str

scitex/io/__init__.py

@@ -85,6 +85,14 @@ except ImportError:
     embed_metadata = None
     has_metadata = None
 
+# Import ZipBundle for in-memory zip access
+try:
+    from ._zip_bundle import ZipBundle, open_bundle, create_bundle
+except ImportError:
+    ZipBundle = None
+    open_bundle = None
+    create_bundle = None
+
 __all__ = [
     # Primary I/O
     "save",
@@ -96,6 +104,10 @@ __all__ = [
     "reload",
     "flush",
     "cache",
+    # Zip bundle access
+    "ZipBundle",
+    "open_bundle",
+    "create_bundle",
 ]
 
 # EOF

scitex/io/_bundle.py

@@ -307,11 +307,13 @@ def validate_bundle(
     return result
 
 
-def load_bundle(path: Union[str, Path]) -> Dict[str, Any]:
+def load_bundle(path: Union[str, Path], in_memory: bool = True) -> Dict[str, Any]:
     """Load bundle from directory or ZIP transparently.
 
     Args:
         path: Path to bundle (directory or ZIP).
+        in_memory: If True, load ZIP contents in-memory without extracting.
+                   If False, extract to temp directory (legacy behavior).
 
     Returns:
         Bundle data as dictionary with:
@@ -335,17 +337,42 @@ def load_bundle(path: Union[str, Path]) -> Dict[str, Any]:
 
     # Handle ZIP vs directory
     if p.is_file() and p.suffix in BUNDLE_EXTENSIONS:
-        # ZIP archive - extract to temp and load
         result["is_zip"] = True
-        import tempfile
-        temp_dir = Path(tempfile.mkdtemp())
-        with zipfile.ZipFile(p, "r") as zf:
-            zf.extractall(temp_dir)
-        bundle_dir = temp_dir
+
+        if in_memory:
+            # In-memory loading using ZipBundle
+            from ._zip_bundle import ZipBundle
+            with ZipBundle(p, mode="r") as zb:
+                result["_zip_bundle"] = zb
+                # Load common files in-memory
+                try:
+                    result["spec"] = zb.read_json("spec.json")
+                except FileNotFoundError:
+                    result["spec"] = None
+                try:
+                    result["style"] = zb.read_json("style.json")
+                except FileNotFoundError:
+                    result["style"] = None
+                try:
+                    result["data"] = zb.read_csv("data.csv")
+                except FileNotFoundError:
+                    result["data"] = None
+
+                # Get file list
+                result["files"] = zb.namelist()
+
+            return result
+        else:
+            # Legacy: extract to temp and load
+            import tempfile
+            temp_dir = Path(tempfile.mkdtemp())
+            with zipfile.ZipFile(p, "r") as zf:
+                zf.extractall(temp_dir)
+            bundle_dir = temp_dir
     else:
         bundle_dir = p
 
-    # Delegate to domain-specific loaders
+    # Delegate to domain-specific loaders (for directory bundles or legacy mode)
     if bundle_type == BundleType.FIGZ:
         from scitex.fig.io._bundle import load_figz_bundle
         result.update(load_figz_bundle(bundle_dir))
@@ -364,6 +391,7 @@ def save_bundle(
     path: Union[str, Path],
     bundle_type: Optional[str] = None,
     as_zip: bool = False,
+    atomic: bool = True,
 ) -> Path:
     """Save data as a bundle.
 
@@ -372,6 +400,7 @@ def save_bundle(
         path: Output path (with or without .d suffix).
         bundle_type: Bundle type ('figz', 'pltz', 'statsz'). Auto-detected if None.
         as_zip: If True, save as ZIP archive.
+        atomic: If True, use atomic write (temp file + rename) for ZIP.
 
     Returns:
         Path to saved bundle.
@@ -399,7 +428,37 @@ def save_bundle(
         else:
             dir_path = p
 
-    # Create directory
+    # For direct ZIP saving with atomic writes, use ZipBundle
+    # Note: figz bundles need special handling for nested pltz panels,
+    # so they go through the directory-based save_figz_bundle path
+    if save_as_zip and atomic and bundle_type != BundleType.FIGZ:
+        from ._zip_bundle import ZipBundle
+
+        with ZipBundle(zip_path, mode="w") as zb:
+            # Write spec
+            if "spec" in data:
+                zb.write_json("spec.json", data["spec"])
+
+            # Write style
+            if "style" in data:
+                zb.write_json("style.json", data["style"])
+
+            # Write CSV data
+            if "data" in data and data["data"] is not None:
+                import pandas as pd
+                if isinstance(data["data"], pd.DataFrame):
+                    zb.write_csv("data.csv", data["data"])
+
+            # Write exports (PNG, SVG, etc.)
+            for key in ["png", "svg", "pdf"]:
+                if key in data and data[key] is not None:
+                    export_data = data[key]
+                    if isinstance(export_data, bytes):
+                        zb.write_bytes(f"exports/figure.{key}", export_data)
+
+        return zip_path
+
+    # Create directory for non-ZIP or non-atomic saves
     dir_path.mkdir(parents=True, exist_ok=True)
 
     # Delegate to domain-specific savers
@@ -417,7 +476,7 @@ def save_bundle(
     else:
         raise ValueError(f"Unknown bundle type: {bundle_type}")
 
-    # Pack to ZIP if requested
+    # Pack to ZIP if requested (non-atomic path)
     if save_as_zip:
         pack_bundle(dir_path, zip_path)
         shutil.rmtree(dir_path)  # Remove temp directory