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

scitex/io/_save_modules/_canvas.py

@@ -3,7 +3,7 @@
 # Timestamp: 2025-12-08
 # File: /home/ywatanabe/proj/scitex-code/src/scitex/io/_save_modules/_canvas.py
 """
-Save canvas directory (.canvas) for scitex.vis.
+Save canvas directory (.canvas) for scitex.fig.
 
 Canvas directories are portable figure bundles containing:
     - canvas.json: Layout, panels, composition settings
@@ -113,7 +113,7 @@ def _export_canvas_figures(
         formats = ["png", "pdf", "svg"]
 
     try:
-        from scitex.vis.io.export import _compose_and_export
+        from scitex.fig.io.export import _compose_and_export
         import json
 
         # Load canvas.json
@@ -136,7 +136,7 @@ def _export_canvas_figures(
                 transparent=False,
             )
     except ImportError:
-        # scitex.vis not available
+        # scitex.fig not available
         pass
     except Exception as e:
         # Log but don't fail save if export fails

scitex/io/_save_modules/_image.py

@@ -8,11 +8,12 @@ import os
 __FILE__ = __file__
 
 import io as _io
-import logging
 
 import plotly
 from PIL import Image
 
+from scitex import logging
+
 logger = logging.getLogger(__name__)
 
 
@@ -66,9 +67,7 @@ def save_image(
                     fig = obj if hasattr(obj, "savefig") else obj.figure
                     obj = add_qr_to_figure(fig, metadata, position=qr_position)
             except Exception as e:
-                import warnings
-
-                warnings.warn(f"Failed to add QR code: {e}")
+                logger.warning(f"Failed to add QR code: {e}")
 
     # png
     if fmt == 'png':
@@ -216,9 +215,7 @@ def save_image(
             if verbose:
                 logger.debug(f"  • Embedded metadata: {metadata}")
         except Exception as e:
-            import warnings
-
-            warnings.warn(f"Failed to embed metadata: {e}")
+            logger.warning(f"Failed to embed metadata: {e}")
 
 def _save_stats_from_figure(obj, spath, verbose=False):
     """
@@ -297,8 +294,7 @@ def _save_stats_from_figure(obj, spath, verbose=False):
             logger.info(f"  • Auto-saved stats to: {stats_path}")
 
     except Exception as e:
-        import warnings
-        warnings.warn(f"Failed to auto-save stats: {e}")
+        logger.warning(f"Failed to auto-save stats: {e}")
 
 
 # EOF

scitex/io/_save_modules/_tex.py

@@ -20,7 +20,10 @@ Supports multiple input types:
 """
 
 from typing import Union, Optional, Any
-import warnings
+
+from scitex import logging
+
+logger = logging.getLogger(__name__)
 
 
 def save_tex(
@@ -121,21 +124,21 @@ def save_tex(
                 tex_content = _wrap_with_table_env(tex_content, caption, label)
 
         except ImportError:
-            warnings.warn(
+            logger.warning(
                 "Cannot convert dict/list to LaTeX: "
                 "scitex.stats.utils.convert_results not available. "
                 "Converting to string instead."
             )
             tex_content = str(obj)
         except Exception as e:
-            warnings.warn(
+            logger.warning(
                 f"Failed to convert object to LaTeX: {e}. Converting to string instead."
             )
             tex_content = str(obj)
 
     else:
         # Fallback: convert to string
-        warnings.warn(
+        logger.warning(
             f"Unsupported type {type(obj)} for LaTeX export. Converting to string."
         )
         tex_content = str(obj)

scitex/io/_zip_bundle.py

@@ -0,0 +1,439 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-14 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/io/_zip_bundle.py
+
+"""
+SciTeX ZipBundle - In-memory zip archive handler with atomic writes.
+
+Provides efficient access to .figz, .pltz, .statsz bundles without extracting
+to disk. Supports:
+    - In-memory file reading
+    - Atomic writes using temp files
+    - Context manager protocol
+    - Dict-like access to files
+"""
+
+import io
+import json
+import os
+import shutil
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Any, BinaryIO, Dict, Iterator, List, Optional, Union
+
+import pandas as pd
+
+__all__ = [
+    "ZipBundle",
+    "open_bundle",
+    "create_bundle",
+]
+
+
+class ZipBundle:
+    """In-memory zip bundle handler.
+
+    Provides efficient read/write access to zip archives without extracting
+    to disk. Files are read into memory on demand and writes are atomic.
+
+    Usage:
+        # Reading
+        with ZipBundle("figure.figz") as bundle:
+            spec = bundle.read_json("spec.json")
+            csv_data = bundle.read_csv("data.csv")
+            png_bytes = bundle.read_bytes("exports/figure.png")
+
+        # Writing
+        with ZipBundle("output.pltz", mode="w") as bundle:
+            bundle.write_json("spec.json", spec_dict)
+            bundle.write_csv("data.csv", dataframe)
+            bundle.write_bytes("exports/plot.png", png_bytes)
+
+        # Modifying (read then write atomically)
+        with ZipBundle("figure.figz", mode="a") as bundle:
+            spec = bundle.read_json("spec.json")
+            spec["title"] = "Updated"
+            bundle.write_json("spec.json", spec)
+    """
+
+    def __init__(
+        self,
+        path: Union[str, Path],
+        mode: str = "r",
+        compression: int = zipfile.ZIP_DEFLATED,
+    ):
+        """Initialize ZipBundle.
+
+        Args:
+            path: Path to zip file (.figz, .pltz, .statsz)
+            mode: 'r' for read, 'w' for write, 'a' for append/modify
+            compression: ZIP compression method (default: ZIP_DEFLATED)
+        """
+        self.path = Path(path)
+        self.mode = mode
+        self.compression = compression
+        self._zipfile: Optional[zipfile.ZipFile] = None
+        self._cache: Dict[str, bytes] = {}  # Cache for read files
+        self._pending_writes: Dict[str, bytes] = {}  # Pending writes for atomic commit
+        self._temp_path: Optional[Path] = None
+        self._closed = False
+
+    def __enter__(self) -> "ZipBundle":
+        """Enter context manager."""
+        self.open()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Exit context manager with atomic commit on success."""
+        if exc_type is None and self.mode in ("w", "a"):
+            self._atomic_commit()
+        self.close()
+
+    def open(self) -> None:
+        """Open the zip bundle."""
+        if self.mode == "r":
+            if not self.path.exists():
+                raise FileNotFoundError(f"Bundle not found: {self.path}")
+            self._zipfile = zipfile.ZipFile(self.path, "r")
+        elif self.mode == "w":
+            # Create new archive (write to temp, commit on close)
+            self._temp_path = Path(tempfile.mktemp(suffix=self.path.suffix))
+            self._zipfile = zipfile.ZipFile(
+                self._temp_path, "w", self.compression
+            )
+        elif self.mode == "a":
+            # Append mode: read existing, write to temp, commit atomically
+            if self.path.exists():
+                # Load existing contents into cache
+                with zipfile.ZipFile(self.path, "r") as zf:
+                    for name in zf.namelist():
+                        self._cache[name] = zf.read(name)
+            self._temp_path = Path(tempfile.mktemp(suffix=self.path.suffix))
+            self._zipfile = zipfile.ZipFile(
+                self._temp_path, "w", self.compression
+            )
+        else:
+            raise ValueError(f"Invalid mode: {self.mode}")
+
+    def close(self) -> None:
+        """Close the zip bundle."""
+        if self._zipfile and not self._closed:
+            self._zipfile.close()
+            self._closed = True
+            # Clean up temp file if not committed (error case)
+            if self._temp_path and self._temp_path.exists():
+                if self.mode in ("w", "a") and not self.path.exists():
+                    # Commit wasn't called, clean up
+                    self._temp_path.unlink()
+
+    def _atomic_commit(self) -> None:
+        """Atomically commit writes by renaming temp file.
+
+        This ensures the bundle is never in an inconsistent state.
+        Either the old file exists completely, or the new one does.
+        """
+        if self._temp_path is None:
+            return
+
+        # Write all pending and cached content to the temp zip
+        self._zipfile.close()
+        self._closed = True
+
+        # Atomic rename (works on same filesystem)
+        # On Windows, we need to remove target first
+        if os.name == "nt" and self.path.exists():
+            backup_path = self.path.with_suffix(self.path.suffix + ".bak")
+            self.path.rename(backup_path)
+            try:
+                self._temp_path.rename(self.path)
+                backup_path.unlink()
+            except Exception:
+                # Restore backup on failure
+                backup_path.rename(self.path)
+                raise
+        else:
+            # Unix: atomic rename
+            self._temp_path.rename(self.path)
+
+    # =========================================================================
+    # File listing
+    # =========================================================================
+
+    def namelist(self) -> List[str]:
+        """List all files in the bundle."""
+        if self.mode == "r":
+            return self._zipfile.namelist()
+        else:
+            # Include both cached and pending writes
+            names = set(self._cache.keys())
+            names.update(self._pending_writes.keys())
+            return sorted(names)
+
+    def __contains__(self, name: str) -> bool:
+        """Check if file exists in bundle."""
+        return name in self.namelist()
+
+    def __iter__(self) -> Iterator[str]:
+        """Iterate over file names in bundle."""
+        return iter(self.namelist())
+
+    # =========================================================================
+    # Reading
+    # =========================================================================
+
+    def read_bytes(self, name: str) -> bytes:
+        """Read file as bytes.
+
+        Args:
+            name: File path within the zip (e.g., "spec.json", "exports/plot.png")
+
+        Returns:
+            File contents as bytes.
+        """
+        # Check cache first (for append mode)
+        if name in self._pending_writes:
+            return self._pending_writes[name]
+        if name in self._cache:
+            return self._cache[name]
+
+        # Read from zip
+        if self._zipfile is None:
+            raise RuntimeError("Bundle not opened")
+
+        # Handle files inside .d directory structure
+        # Try direct name first, then with .d prefix
+        try:
+            data = self._zipfile.read(name)
+            self._cache[name] = data
+            return data
+        except KeyError:
+            # Try with directory prefix (e.g., "bundle.pltz.d/spec.json")
+            # The path.name includes extension, so "foo.pltz" -> "foo.pltz.d"
+            dir_name = self.path.name + ".d"
+            full_name = f"{dir_name}/{name}"
+            try:
+                data = self._zipfile.read(full_name)
+                self._cache[name] = data
+                return data
+            except KeyError:
+                # Try to find the .d directory dynamically
+                # (handles case where pltz was renamed, e.g., panel_A.pltz -> A.pltz
+                # but internal structure is still panel_A.pltz.d/)
+                for arc_name in self._zipfile.namelist():
+                    if arc_name.endswith('.d/' + name) or arc_name.endswith('.d/' + name.replace('/', '/')):
+                        data = self._zipfile.read(arc_name)
+                        self._cache[name] = data
+                        return data
+                raise FileNotFoundError(f"File not found in bundle: {name}")
+
+    def read_text(self, name: str, encoding: str = "utf-8") -> str:
+        """Read file as text.
+
+        Args:
+            name: File path within the zip.
+            encoding: Text encoding (default: utf-8).
+
+        Returns:
+            File contents as string.
+        """
+        return self.read_bytes(name).decode(encoding)
+
+    def read_json(self, name: str = "spec.json") -> Dict[str, Any]:
+        """Read and parse JSON file.
+
+        Args:
+            name: JSON file path within the zip.
+
+        Returns:
+            Parsed JSON as dictionary.
+        """
+        return json.loads(self.read_text(name))
+
+    def read_csv(self, name: str = "data.csv", **kwargs) -> pd.DataFrame:
+        """Read CSV file as pandas DataFrame.
+
+        Args:
+            name: CSV file path within the zip.
+            **kwargs: Additional arguments passed to pd.read_csv.
+
+        Returns:
+            DataFrame with CSV contents.
+        """
+        data = self.read_bytes(name)
+        return pd.read_csv(io.BytesIO(data), **kwargs)
+
+    def read_image(self, name: str) -> bytes:
+        """Read image file as bytes.
+
+        Args:
+            name: Image file path (e.g., "exports/figure.png").
+
+        Returns:
+            Image bytes.
+        """
+        return self.read_bytes(name)
+
+    # =========================================================================
+    # Writing
+    # =========================================================================
+
+    def write_bytes(self, name: str, data: bytes) -> None:
+        """Write bytes to file in bundle.
+
+        Args:
+            name: File path within the zip.
+            data: Bytes to write.
+        """
+        if self.mode == "r":
+            raise RuntimeError("Cannot write in read mode")
+
+        self._pending_writes[name] = data
+        self._cache[name] = data  # Update cache
+
+        # Write to zip immediately
+        self._zipfile.writestr(name, data)
+
+    def write_text(self, name: str, text: str, encoding: str = "utf-8") -> None:
+        """Write text to file in bundle.
+
+        Args:
+            name: File path within the zip.
+            text: Text to write.
+            encoding: Text encoding (default: utf-8).
+        """
+        self.write_bytes(name, text.encode(encoding))
+
+    def write_json(
+        self, name: str, data: Dict[str, Any], indent: int = 2
+    ) -> None:
+        """Write dictionary as JSON file.
+
+        Args:
+            name: JSON file path within the zip.
+            data: Dictionary to serialize.
+            indent: JSON indentation (default: 2).
+        """
+        text = json.dumps(data, indent=indent, ensure_ascii=False)
+        self.write_text(name, text)
+
+    def write_csv(
+        self, name: str, df: pd.DataFrame, index: bool = False, **kwargs
+    ) -> None:
+        """Write pandas DataFrame as CSV.
+
+        Args:
+            name: CSV file path within the zip.
+            df: DataFrame to write.
+            index: Include index column (default: False).
+            **kwargs: Additional arguments passed to df.to_csv.
+        """
+        buffer = io.BytesIO()
+        df.to_csv(buffer, index=index, **kwargs)
+        self.write_bytes(name, buffer.getvalue())
+
+    def write_image(self, name: str, data: bytes) -> None:
+        """Write image bytes to bundle.
+
+        Args:
+            name: Image file path (e.g., "exports/figure.png").
+            data: Image bytes.
+        """
+        self.write_bytes(name, data)
+
+    # =========================================================================
+    # Convenience methods
+    # =========================================================================
+
+    @property
+    def spec(self) -> Optional[Dict[str, Any]]:
+        """Get bundle specification (spec.json)."""
+        try:
+            return self.read_json("spec.json")
+        except FileNotFoundError:
+            return None
+
+    @property
+    def style(self) -> Optional[Dict[str, Any]]:
+        """Get bundle style (style.json)."""
+        try:
+            return self.read_json("style.json")
+        except FileNotFoundError:
+            return None
+
+    @property
+    def data(self) -> Optional[pd.DataFrame]:
+        """Get bundle data (data.csv)."""
+        try:
+            return self.read_csv("data.csv")
+        except FileNotFoundError:
+            return None
+
+
+def open_bundle(
+    path: Union[str, Path], mode: str = "r"
+) -> ZipBundle:
+    """Open a bundle for reading or writing.
+
+    Args:
+        path: Path to bundle file.
+        mode: 'r' for read, 'w' for write, 'a' for append.
+
+    Returns:
+        ZipBundle instance (use as context manager).
+
+    Example:
+        with open_bundle("figure.figz") as bundle:
+            spec = bundle.spec
+            data = bundle.data
+    """
+    return ZipBundle(path, mode=mode)
+
+
+def create_bundle(
+    path: Union[str, Path],
+    spec: Dict[str, Any],
+    data: Optional[pd.DataFrame] = None,
+    style: Optional[Dict[str, Any]] = None,
+    exports: Optional[Dict[str, bytes]] = None,
+) -> Path:
+    """Create a new bundle with atomic write.
+
+    Args:
+        path: Output path (.figz, .pltz, or .statsz).
+        spec: Bundle specification dictionary.
+        data: Optional CSV data as DataFrame.
+        style: Optional style dictionary.
+        exports: Optional dict mapping export paths to bytes.
+
+    Returns:
+        Path to created bundle.
+
+    Example:
+        create_bundle(
+            "plot.pltz",
+            spec={"schema": {"name": "scitex.plt", "version": "1.0"}},
+            data=df,
+            exports={"exports/plot.png": png_bytes},
+        )
+    """
+    path = Path(path)
+
+    with ZipBundle(path, mode="w") as bundle:
+        bundle.write_json("spec.json", spec)
+
+        if data is not None:
+            bundle.write_csv("data.csv", data)
+
+        if style is not None:
+            bundle.write_json("style.json", style)
+
+        if exports:
+            for export_path, export_data in exports.items():
+                bundle.write_bytes(export_path, export_data)
+
+    return path
+
+
+# EOF

scitex/io/utils/h5_to_zarr.py

@@ -33,9 +33,9 @@ import numpy as np
 import os
 from pathlib import Path
 from typing import Optional, Union, Dict, Any, List, Tuple
-import warnings
 from tqdm import tqdm
 
+from scitex import logging
 from scitex.errors import (
     IOError as SciTeXIOError,
     FileFormatError,
@@ -46,6 +46,8 @@ from scitex.errors import (
     warn_performance,
 )
 
+logger = logging.getLogger(__name__)
+
 
 def _get_zarr_compressor(
     compressor: Optional[Union[str, Any]] = "zstd",
@@ -114,7 +116,7 @@ def _copy_h5_attributes(
 
             zarr_obj.attrs[key] = value
         except Exception as e:
-            warnings.warn(f"Could not copy attribute '{key}': {e}")
+            logger.warning(f"Could not copy attribute '{key}': {e}")
 
 
 def _migrate_dataset(
@@ -132,7 +134,7 @@ def _migrate_dataset(
         if hasattr(h5_dataset, "dtype"):
             test_dtype = h5_dataset.dtype
     except Exception as e:
-        warnings.warn(f"Skipping corrupted dataset '{name}': {e}")
+        logger.warning(f"Skipping corrupted dataset '{name}': {e}")
         return None
 
     # Get dataset info
@@ -241,7 +243,7 @@ def _migrate_dataset(
             else:  # Scalar
                 zarr_array[()] = h5_dataset[()]
         except Exception as e:
-            warnings.warn(
+            logger.warning(
                 f"Error copying data for dataset '{name}': {e}. Leaving empty."
             )
             # The array structure is created but data might be zeros/empty
@@ -268,14 +270,14 @@ def _migrate_group(
     try:
         keys = list(h5_group.keys())
     except Exception as e:
-        warnings.warn(f"Cannot access group keys: {e}")
+        logger.warning(f"Cannot access group keys: {e}")
         return
 
     for key in keys:
         try:
             item = h5_group[key]
         except Exception as e:
-            warnings.warn(f"Cannot access item '{key}': {e}")
+            logger.warning(f"Cannot access item '{key}': {e}")
             continue
 
         if isinstance(item, h5py.Dataset):
@@ -297,7 +299,7 @@ def _migrate_group(
             )
 
         else:
-            warnings.warn(f"Unknown HDF5 object type for '{key}': {type(item)}")
+            logger.warning(f"Unknown HDF5 object type for '{key}': {type(item)}")
 
 
 def migrate_h5_to_zarr(
@@ -418,7 +420,7 @@ def migrate_h5_to_zarr(
     except OSError as e:
         if "Unable to open file" in str(e) or "bad symbol table" in str(e):
             # File is corrupted
-            warnings.warn(f"HDF5 file appears to be corrupted: {h5_path}")
+            logger.warning(f"HDF5 file appears to be corrupted: {h5_path}")
             raise FileFormatError(
                 str(h5_path), expected_format="HDF5", actual_format="corrupted HDF5"
             )
@@ -452,7 +454,7 @@ def _validate_migration(
             # Compare dtypes (approximately)
             if h5_item.dtype.kind != "O" and zarr_item.dtype.kind != "O":
                 if h5_item.dtype != zarr_item.dtype:
-                    warnings.warn(
+                    logger.warning(
                         f"Dtype mismatch at {path}: "
                         f"HDF5={h5_item.dtype}, Zarr={zarr_item.dtype}"
                     )