scitex 2.0.0__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

scitex/io/_load_modules/_sqlite3.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-07-15 23:21:31 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/io/_load_modules/_sqlite3.py
+# ----------------------------------------
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from ...db import SQLite3
+
+_load_db_sqlite3 = SQLite3
+
+# EOF

scitex/io/_load_modules/_txt.py

@@ -1,11 +1,10 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-05-03 11:58:11 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex_repo/src/scitex/io/_load_modules/_txt.py
+# Timestamp: "2025-07-15 09:27:36 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/io/_load_modules/_txt.py
 # ----------------------------------------
 import os
-
-__FILE__ = "./src/scitex/io/_load_modules/_txt.py"
+__FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -44,13 +43,47 @@ import warnings
 # Removed duplicate function - see main _load_txt below
 
 
-def _load_txt(lpath, strip=False, as_lines=False):
+# def _load_txt(lpath, strip=False, as_lines=False):
+#     """
+#     Load text file and return its content.
+#     - Warn if extension is unexpected.
+#     - Try UTF-8 first, then default encoding.
+#     - If strip=True, strip whitespace.
+#     - If as_lines=True, return list of lines (backward compatibility).
+#     """
+#     if not lpath.endswith((".txt", ".log", ".event", ".py", ".sh")):
+#         warnings.warn(f"Unexpected extension for file: {lpath}")
+
+#     try:
+#         with open(lpath, "r", encoding="utf-8") as file:
+#             content = file.read()
+#     except UnicodeDecodeError:
+#         # Fallback: try to detect correct encoding
+#         encoding = _check_encoding(lpath)
+#         with open(lpath, "r", encoding=encoding) as file:
+#             content = file.read()
+
+#     # For backward compatibility, check if as_lines parameter or legacy behavior needed
+#     if as_lines:
+#         raw_lines = content.splitlines()
+#         if strip:
+#             return [line.strip() for line in raw_lines if line.strip()]
+#         return [line for line in raw_lines if line.strip()]
+
+#     # Default: return full content (possibly stripped)
+#     if strip:
+#         return content.strip()
+
+#     return content
+
+
+def _load_txt(lpath, strip=True, as_lines=True):
     """
     Load text file and return its content.
     - Warn if extension is unexpected.
     - Try UTF-8 first, then default encoding.
-    - If strip=True, strip whitespace.
-    - If as_lines=True, return list of lines (backward compatibility).
+    - If strip=True, strip whitespace from each line.
+    - If as_lines=True, return list of lines.
     """
     if not lpath.endswith((".txt", ".log", ".event", ".py", ".sh")):
         warnings.warn(f"Unexpected extension for file: {lpath}")
@@ -59,22 +92,18 @@ def _load_txt(lpath, strip=False, as_lines=False):
         with open(lpath, "r", encoding="utf-8") as file:
             content = file.read()
     except UnicodeDecodeError:
-        # Fallback: try to detect correct encoding
         encoding = _check_encoding(lpath)
         with open(lpath, "r", encoding=encoding) as file:
             content = file.read()
 
-    # For backward compatibility, check if as_lines parameter or legacy behavior needed
     if as_lines:
         raw_lines = content.splitlines()
         if strip:
             return [line.strip() for line in raw_lines if line.strip()]
-        return [line for line in raw_lines if line.strip()]
+        return [line for line in raw_lines if line]
 
-    # Default: return full content (possibly stripped)
     if strip:
         return content.strip()
-
     return content
 
 

scitex/io/_load_modules/_yaml.py

@@ -7,10 +7,11 @@ import yaml
 
 
 def _load_yaml(lpath, **kwargs):
-    """Load YAML file with optional key lowercasing."""
-    if not lpath.endswith((".yaml", ".yml")):
-        raise ValueError("File must have .yaml or .yml extension")
+    """Load YAML file with optional key lowercasing.
 
+    Extension validation is handled by load() function, not here.
+    This allows loading files without extensions when ext='yaml' is specified.
+    """
     lower = kwargs.pop("lower", False)
     with open(lpath) as f:
         obj = yaml.safe_load(f, **kwargs)

scitex/io/_load_modules/_zarr.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-07-11 15:44:42 (ywatanabe)"
+# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/io/_load_modules/_zarr.py
+# ----------------------------------------
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+import pickle
+from typing import Any, Optional
+
+import zarr
+
+
+def _load_zarr(lpath: str, key: Optional[str] = None, **kwargs) -> Any:
+    """
+    Load data from Zarr store.
+
+    Parameters:
+    -----------
+    lpath : str
+        Path to Zarr store (directory, .zarr.zip, or consolidated)
+    key : str, optional
+        Key/group path within Zarr store
+
+    Returns:
+    --------
+    Any : Loaded data
+    """
+    from pathlib import Path
+    
+    lpath_obj = Path(lpath)
+    
+    try:
+        # Check if it's a zip store
+        if lpath.endswith('.zip') or lpath.endswith('.zarr.zip'):
+            store = zarr.ZipStore(lpath, mode='r')
+            root = zarr.open(store, mode='r')
+        # Check if it's consolidated
+        elif lpath_obj.joinpath('.zmetadata').exists():
+            root = zarr.open_consolidated(lpath, mode='r')
+        else:
+            # Regular directory store
+            root = zarr.open(lpath, mode="r")
+    except ValueError as e:
+        raise FileNotFoundError(f"Cannot open Zarr store: {lpath}")
+
+    # Navigate to target
+    if key:
+        if key not in root:
+            raise KeyError(f"Key '{key}' not found in Zarr store")
+        target = root[key]
+    else:
+        target = root
+
+    # Load data
+    if hasattr(target, "keys"):  # Group
+        result = {}
+
+        for item_key in target.keys():
+            item = target[item_key]
+
+            if hasattr(item, "keys"):  # Nested group
+                result[item_key] = _load_zarr_group(item)
+            else:  # Dataset
+                result[item_key] = _load_zarr_dataset(item)
+
+        # Load attributes
+        if hasattr(target, "attrs"):
+            for attr_key, attr_value in target.attrs.items():
+                result[f"_attr_{attr_key}"] = attr_value
+
+        return result
+
+    else:  # Dataset
+        return _load_zarr_dataset(target)
+
+
+def _load_zarr_group(group):
+    """Recursively load Zarr group."""
+    result = {}
+
+    for key in group.keys():
+        item = group[key]
+        if hasattr(item, "keys"):  # Nested group
+            result[key] = _load_zarr_group(item)
+        else:  # Dataset
+            result[key] = _load_zarr_dataset(item)
+
+    # Load attributes
+    if hasattr(group, "attrs"):
+        for attr_key, attr_value in group.attrs.items():
+            result[f"_attr_{attr_key}"] = attr_value
+
+    return result
+
+
+def _load_zarr_dataset(dataset):
+    """Load individual Zarr dataset."""
+    # Check if it's pickled data
+    if hasattr(dataset, "attrs") and dataset.attrs.get("_type") == "pickled":
+        pickled_bytes = dataset[:]
+        return pickle.loads(pickled_bytes.tobytes())
+    
+    # Check if it's a string
+    if hasattr(dataset, "attrs") and dataset.attrs.get("_type") == "string":
+        data = dataset[:]
+        return data.decode('utf-8') if hasattr(data, 'decode') else str(data)
+
+    # Regular data
+    # Handle 0-d arrays (scalars) differently
+    if dataset.ndim == 0:
+        data = dataset[()]
+    else:
+        data = dataset[:]
+
+    # Handle string data
+    if dataset.dtype.kind == "U":  # Unicode string
+        return str(data) if dataset.ndim == 0 else data
+    elif dataset.dtype.kind == "S":  # Byte string
+        return data.decode('utf-8') if hasattr(data, 'decode') else str(data)
+
+    return data
+
+# EOF