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

scitex/io/_load.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -47,6 +48,98 @@ from ._load_modules._zarr import _load_zarr
 from ._load_modules._canvas import _load_canvas
 
 
+def _load_bundle(lpath, verbose=False, **kwargs):
+    """Load a .pltz, .figz, or .statsz bundle.
+
+    Parameters
+    ----------
+    lpath : str or Path
+        Path to the bundle (directory or ZIP).
+    verbose : bool
+        If True, print verbose output.
+    **kwargs
+        Additional arguments.
+
+    Returns
+    -------
+    For .pltz bundles:
+        tuple: (fig, ax, data) where fig is reconstructed figure,
+               ax is the axes, data is DataFrame or None.
+    For .figz bundles:
+        dict: Figure data with 'spec' and 'panels'.
+    For .statsz bundles:
+        dict: Stats data with 'spec' and 'comparisons'.
+    """
+    from ._bundle import load_bundle, BundleType
+
+    bundle = load_bundle(lpath)
+    bundle_type = bundle.get('type')
+
+    if bundle_type == BundleType.PLTZ:
+        # Return (fig, ax, data) tuple for .pltz bundles
+        # Note: We return the spec and data, not a reconstructed figure
+        # as matplotlib figures cannot be perfectly serialized/deserialized
+        import matplotlib.pyplot as plt
+        from pathlib import Path
+
+        p = Path(lpath)
+        bundle_dir = p
+
+        # Handle ZIP extraction
+        if not p.is_dir():
+            import tempfile
+            import zipfile
+            temp_dir = Path(tempfile.mkdtemp())
+            with zipfile.ZipFile(p, 'r') as zf:
+                zf.extractall(temp_dir)
+            bundle_dir = temp_dir
+
+        # Find PNG file - layered format stores in exports/
+        basename = bundle.get('basename', 'plot')
+        png_path = bundle_dir / "exports" / f"{basename}.png"
+        if not png_path.exists():
+            # Fallback to root level (legacy format)
+            png_path = bundle_dir / f"{basename}.png"
+
+        # Load the PNG as a figure
+        if png_path.exists():
+            img = plt.imread(str(png_path))
+            fig, ax = plt.subplots()
+            ax.imshow(img)
+            ax.axis('off')
+
+            # Attach metadata from spec
+            spec = bundle.get('spec', {})
+            if spec:
+                # Handle both layered and legacy spec formats
+                axes_list = spec.get('axes', [])
+                if axes_list and isinstance(axes_list, list):
+                    for key, val in axes_list[0].items():
+                        setattr(ax, f'_scitex_{key}', val)
+                # Theme from style (layered) or spec (legacy)
+                style = bundle.get('style', {})
+                theme = style.get('theme', {}) if style else spec.get('theme', {})
+                if theme:
+                    fig._scitex_theme = theme.get('mode')
+
+            # Data from bundle (merged in load_layered_pltz_bundle)
+            data = bundle.get('data')
+            return fig, ax, data
+        else:
+            # No PNG, return spec and data
+            return bundle.get('spec'), None, bundle.get('data')
+
+    elif bundle_type == BundleType.FIGZ:
+        # Return figure dict for .figz bundles
+        return bundle
+
+    elif bundle_type == BundleType.STATSZ:
+        # Return stats dict for .statsz bundles
+        return bundle
+
+    return bundle
+
+
 def load(
     lpath: Union[str, Path],
     ext: str = None,
@@ -156,20 +249,22 @@ def load(
     if lpath.endswith(".canvas"):
         return _load_canvas(lpath, verbose=verbose, **kwargs)
 
+    # Handle bundle formats (.pltz, .figz, .statsz and their .d variants)
+    bundle_extensions = (".figz", ".pltz", ".statsz")
+    for bext in bundle_extensions:
+        if lpath.endswith(bext) or lpath.endswith(f"{bext}.d"):
+            return _load_bundle(lpath, verbose=verbose, **kwargs)
+
     # Check if it's a glob pattern
     if "*" in lpath or "?" in lpath or "[" in lpath:
         # Handle glob pattern
         matched_files = sorted(glob.glob(lpath))
         if not matched_files:
-            raise FileNotFoundError(
-                f"No files found matching pattern: {lpath}"
-            )
+            raise FileNotFoundError(f"No files found matching pattern: {lpath}")
         # Load all matched files
         results = []
         for file_path in matched_files:
-            results.append(
-                load(file_path, show=show, verbose=verbose, **kwargs)
-            )
+            results.append(load(file_path, show=show, verbose=verbose, **kwargs))
         return results
 
     # Handle broken symlinks - os.path.exists() returns False for broken symlinks
@@ -180,7 +275,7 @@ def load(
             target = os.readlink(lpath)
             resolved_target = os.path.join(symlink_dir, target)
             resolved_target = os.path.abspath(resolved_target)
-            
+
             if os.path.exists(resolved_target):
                 lpath = resolved_target
             else:
@@ -268,7 +363,7 @@ def load(
     # Determine extension: use explicit ext parameter or detect from filename
     if ext is not None:
         # Use explicitly provided extension (strip leading dot if present)
-        detected_ext = ext.lstrip('.')
+        detected_ext = ext.lstrip(".")
     else:
         # Auto-detect from filename
         detected_ext = lpath.split(".")[-1] if "." in lpath else ""
@@ -307,4 +402,5 @@ def load(
     except (ValueError, FileNotFoundError) as e:
         raise ValueError(f"Error loading file {lpath}: {str(e)}")
 
+
 # EOF

scitex/io/_load_cache.py

@@ -22,29 +22,25 @@ _file_metadata_cache: Dict[str, Tuple[float, int, str]] = {}
 _file_data_cache = weakref.WeakValueDictionary()
 
 # Cache statistics
-_cache_stats = {
-    'hits': 0,
-    'misses': 0,
-    'evictions': 0
-}
+_cache_stats = {"hits": 0, "misses": 0, "evictions": 0}
 
 # Configuration
 _cache_config = {
-    'enabled': True,
-    'max_size': 32,  # Maximum number of files to track
-    'verbose': False
+    "enabled": True,
+    "max_size": 32,  # Maximum number of files to track
+    "verbose": False,
 }
 
 
 def get_file_key(file_path: str) -> Tuple[str, float, int]:
     """
     Get cache key based on file path, modification time, and size.
-    
+
     Parameters
     ----------
     file_path : str
         Path to the file
-        
+
     Returns
     -------
     Tuple[str, float, int]
@@ -58,12 +54,12 @@ def get_file_key(file_path: str) -> Tuple[str, float, int]:
 def get_file_hash(file_path: str) -> str:
     """
     Get a hash based on file metadata.
-    
+
     Parameters
     ----------
     file_path : str
         Path to the file
-        
+
     Returns
     -------
     str
@@ -77,30 +73,29 @@ def get_file_hash(file_path: str) -> str:
 def is_cache_valid(file_path: str) -> bool:
     """
     Check if cached data for a file is still valid.
-    
+
     Parameters
     ----------
     file_path : str
         Path to the file
-        
+
     Returns
     -------
     bool
         True if cache is valid, False otherwise
     """
     abs_path = os.path.abspath(file_path)
-    
+
     if abs_path not in _file_metadata_cache:
         return False
-    
+
     # Get current file metadata
     try:
         current_key = get_file_key(file_path)
         cached_mtime, cached_size, cached_hash = _file_metadata_cache[abs_path]
-        
+
         # Check if file has been modified
-        return (current_key[1] == cached_mtime and 
-                current_key[2] == cached_size)
+        return current_key[1] == cached_mtime and current_key[2] == cached_size
     except (OSError, KeyError):
         return False
 
@@ -108,42 +103,42 @@ def is_cache_valid(file_path: str) -> bool:
 def get_cached_data(file_path: str) -> Optional[Any]:
     """
     Retrieve cached data if available and valid.
-    
+
     Parameters
     ----------
     file_path : str
         Path to the file
-        
+
     Returns
     -------
     Optional[Any]
         Cached data if available, None otherwise
     """
-    if not _cache_config['enabled']:
+    if not _cache_config["enabled"]:
         return None
-    
+
     abs_path = os.path.abspath(file_path)
-    
+
     # Check if cache is valid
     if not is_cache_valid(file_path):
-        _cache_stats['misses'] += 1
+        _cache_stats["misses"] += 1
         return None
-    
+
     # Try to get data from weak reference cache
     if abs_path in _file_data_cache:
-        _cache_stats['hits'] += 1
-        if _cache_config['verbose']:
+        _cache_stats["hits"] += 1
+        if _cache_config["verbose"]:
             logging.info(f"[Cache HIT] {file_path}")
         return _file_data_cache[abs_path]
-    
-    _cache_stats['misses'] += 1
+
+    _cache_stats["misses"] += 1
     return None
 
 
 def cache_data(file_path: str, data: Any) -> None:
     """
     Cache data for a file.
-    
+
     Parameters
     ----------
     file_path : str
@@ -151,19 +146,19 @@ def cache_data(file_path: str, data: Any) -> None:
     data : Any
         Data to cache
     """
-    if not _cache_config['enabled']:
+    if not _cache_config["enabled"]:
         return
-    
+
     abs_path = os.path.abspath(file_path)
-    
+
     # Update metadata cache
     key = get_file_key(file_path)
     _file_metadata_cache[abs_path] = (key[1], key[2], get_file_hash(file_path))
-    
+
     # Try to cache the data (may fail for non-weakref-able types)
     try:
         # For numpy arrays and other special types, we need to wrap them
-        if hasattr(data, '__array__'):
+        if hasattr(data, "__array__"):
             # Numpy arrays can't be weakly referenced directly
             # We'll skip caching for now (could implement a wrapper)
             pass
@@ -171,15 +166,15 @@ def cache_data(file_path: str, data: Any) -> None:
             _file_data_cache[abs_path] = data
     except TypeError:
         # Some objects can't be weakly referenced
-        if _cache_config['verbose']:
+        if _cache_config["verbose"]:
             logging.debug(f"Cannot cache {type(data).__name__} objects")
-    
+
     # Implement cache size limit
-    if len(_file_metadata_cache) > _cache_config['max_size']:
+    if len(_file_metadata_cache) > _cache_config["max_size"]:
         # Remove oldest entries (simple FIFO for metadata)
         oldest = list(_file_metadata_cache.keys())[0]
         del _file_metadata_cache[oldest]
-        _cache_stats['evictions'] += 1
+        _cache_stats["evictions"] += 1
 
 
 def clear_cache() -> None:
@@ -188,34 +183,36 @@ def clear_cache() -> None:
     _file_data_cache.clear()
     _numpy_cache_keys.clear()
     _cached_load_npy.cache_clear()  # Clear LRU cache
-    _cache_stats['hits'] = 0
-    _cache_stats['misses'] = 0
-    _cache_stats['evictions'] = 0
+    _cache_stats["hits"] = 0
+    _cache_stats["misses"] = 0
+    _cache_stats["evictions"] = 0
 
 
 def get_cache_info() -> Dict[str, Any]:
     """
     Get cache statistics and configuration.
-    
+
     Returns
     -------
     Dict[str, Any]
         Cache information including stats and config
     """
     return {
-        'stats': _cache_stats.copy(),
-        'config': _cache_config.copy(),
-        'metadata_size': len(_file_metadata_cache),
-        'data_size': len(_file_data_cache)
+        "stats": _cache_stats.copy(),
+        "config": _cache_config.copy(),
+        "metadata_size": len(_file_metadata_cache),
+        "data_size": len(_file_data_cache),
     }
 
 
-def configure_cache(enabled: Optional[bool] = None,
-                   max_size: Optional[int] = None,
-                   verbose: Optional[bool] = None) -> None:
+def configure_cache(
+    enabled: Optional[bool] = None,
+    max_size: Optional[int] = None,
+    verbose: Optional[bool] = None,
+) -> None:
     """
     Configure cache settings.
-    
+
     Parameters
     ----------
     enabled : Optional[bool]
@@ -226,27 +223,28 @@ def configure_cache(enabled: Optional[bool] = None,
         Enable verbose logging
     """
     if enabled is not None:
-        _cache_config['enabled'] = enabled
+        _cache_config["enabled"] = enabled
     if max_size is not None:
-        _cache_config['max_size'] = max_size
+        _cache_config["max_size"] = max_size
     if verbose is not None:
-        _cache_config['verbose'] = verbose
+        _cache_config["verbose"] = verbose
 
 
-# Track numpy cache separately  
+# Track numpy cache separately
 _numpy_cache_keys = set()
 
+
 # Specialized cache for numpy arrays (using LRU cache)
 @lru_cache(maxsize=16)
 def _cached_load_npy(file_key: Tuple[str, float, int]) -> Any:
     """
     Cached numpy loader using LRU cache.
-    
+
     Parameters
     ----------
     file_key : Tuple[str, float, int]
         Cache key (path, mtime, size)
-        
+
     Returns
     -------
     Any
@@ -255,49 +253,51 @@ def _cached_load_npy(file_key: Tuple[str, float, int]) -> Any:
     file_path = file_key[0]
     # Import here to avoid circular imports
     from ._load_modules._numpy import _load_npy
+
     result = _load_npy(file_path)
-    
+
     # Track that we've cached this key
     _numpy_cache_keys.add(file_key)
-    
+
     return result
 
 
 def load_npy_cached(file_path: str, **kwargs) -> Any:
     """
     Load numpy file with caching.
-    
+
     Parameters
     ----------
     file_path : str
         Path to numpy file
     **kwargs
         Additional arguments for numpy.load
-        
+
     Returns
     -------
     Any
         Loaded numpy array
     """
-    if not _cache_config['enabled']:
+    if not _cache_config["enabled"]:
         from ._load_modules._numpy import _load_npy
+
         return _load_npy(file_path, **kwargs)
-    
+
     # Check if we have a cache hit
     file_key = get_file_key(file_path)
-    
+
     # Check if this key is already cached
     if file_key in _numpy_cache_keys:
-        _cache_stats['hits'] += 1
-        if _cache_config['verbose']:
+        _cache_stats["hits"] += 1
+        if _cache_config["verbose"]:
             print(f"[Cache HIT] Loaded from cache: {file_path}")
     else:
-        _cache_stats['misses'] += 1
-        if _cache_config['verbose']:
+        _cache_stats["misses"] += 1
+        if _cache_config["verbose"]:
             print(f"[Cache MISS] Loading from disk: {file_path}")
-    
+
     # Use LRU cache for numpy files
     return _cached_load_npy(file_key)
 
 
-# EOF
+# EOF

scitex/io/_load_configs.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/io/_load_configs.py"
-)
+
+__FILE__ = "./src/scitex/io/_load_configs.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 

scitex/io/_load_modules/_H5Explorer.py

@@ -4,13 +4,13 @@
 # File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/io/_H5Explorer.py
 # ----------------------------------------
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
 import random
 import time
-import warnings
 
 # Time-stamp: "2025-06-13 21:00:00 (ywatanabe)"
 
@@ -21,6 +21,10 @@ from typing import Any, Dict, List, Optional
 import h5py
 import numpy as np
 
+from scitex import logging
+
+logger = logging.getLogger(__name__)
+
 
 class H5Explorer:
     """Interactive HDF5 file explorer.
@@ -59,9 +63,7 @@ class H5Explorer:
         if hasattr(self, "file") and self.file:
             self.file.close()
 
-    def explore(
-        self, path: str = "/", max_depth: Optional[int] = None
-    ) -> None:
+    def explore(self, path: str = "/", max_depth: Optional[int] = None) -> None:
         """Explore HDF5 file structure interactively."""
         self.show(path, max_depth)
 
@@ -90,9 +92,7 @@ class H5Explorer:
                 print(f"{indent}[{path.split('/')[-1]}]")
             for key in sorted(item.keys()):
                 subpath = f"{path}/{key}".replace("//", "/")
-                self.show(
-                    subpath, max_depth, indent + "  ", _current_depth + 1
-                )
+                self.show(subpath, max_depth, indent + "  ", _current_depth + 1)
         elif isinstance(item, h5py.Dataset):
             name = path.split("/")[-1]
             shape = item.shape
@@ -208,9 +208,7 @@ class H5Explorer:
         matches = []
 
         def _search(current_path):
-            item = (
-                self.file[current_path] if current_path != "/" else self.file
-            )
+            item = self.file[current_path] if current_path != "/" else self.file
 
             if isinstance(item, h5py.Group):
                 for key in item.keys():
@@ -267,7 +265,7 @@ def explore_h5(filepath: str) -> None:
         explorer.explore()
         explorer.close()
     else:
-        warnings.warn(f"Warning: File does not exist: {filepath}")
+        logger.warning(f"File does not exist: {filepath}")
 
 
 def has_h5_key(h5_path, key, max_retries=3, action_on_corrupted="delete"):
@@ -327,9 +325,7 @@ def has_h5_key(h5_path, key, max_retries=3, action_on_corrupted="delete"):
                 else:
                     return False
 
-            elif any(
-                indicator in error_msg for indicator in corruption_indicators
-            ):
+            elif any(indicator in error_msg for indicator in corruption_indicators):
                 if action_on_corrupted == "delete":
                     if _delete_corrupted_entry(h5_path, key):
                         return False
@@ -352,4 +348,5 @@ def _delete_corrupted_entry(h5_path, key):
         pass
     return False
 
+
 # EOF

scitex/io/_load_modules/_ZarrExplorer.py

@@ -4,6 +4,7 @@
 # File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/io/_ZarrExplorer.py
 # ----------------------------------------
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -54,9 +55,7 @@ class ZarrExplorer:
 
             for key in sorted(target.keys()):
                 subpath = f"{path}/{key}".replace("//", "/")
-                self.show(
-                    subpath, max_depth, indent + "  ", _current_depth + 1
-                )
+                self.show(subpath, max_depth, indent + "  ", _current_depth + 1)
 
         else:  # Array
             name = path.split("/")[-1]
@@ -111,4 +110,5 @@ def has_zarr_key(zarr_path: str, key: str) -> bool:
     except (KeyError, ValueError):
         return False
 
+
 # EOF