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

scitex/decorators/_auto_order.py

@@ -4,7 +4,7 @@
 # File: ./scitex_repo/src/scitex/decorators/_auto_order.py
 
 """
-Auto-ordering decorator system that enforces predefined order regardless of 
+Auto-ordering decorator system that enforces predefined order regardless of
 how decorators are written in code.
 
 The enforced order is:
@@ -18,13 +18,13 @@ Example
 -------
 >>> from scitex.decorators import enable_auto_order
 >>> enable_auto_order()
->>> 
+>>>
 >>> # These will all work identically:
 >>> @batch_fn
 >>> @torch_fn
 >>> def func1(x):
 ...     return x.mean()
->>> 
+>>>
 >>> @torch_fn
 >>> @batch_fn  # Order doesn't matter!
 >>> def func2(x):
@@ -46,89 +46,89 @@ from ._batch_fn import batch_fn as _orig_batch_fn
 
 # Decorator priority (higher = inner/applied first)
 DECORATOR_PRIORITY = {
-    'torch_fn': 100,
-    'numpy_fn': 100,
-    'pandas_fn': 100,
-    'batch_fn': 10,
+    "torch_fn": 100,
+    "numpy_fn": 100,
+    "pandas_fn": 100,
+    "batch_fn": 10,
 }
 
 # Original decorator mapping
 ORIGINAL_DECORATORS = {
-    'torch_fn': _orig_torch_fn,
-    'numpy_fn': _orig_numpy_fn,
-    'pandas_fn': _orig_pandas_fn,
-    'batch_fn': _orig_batch_fn,
+    "torch_fn": _orig_torch_fn,
+    "numpy_fn": _orig_numpy_fn,
+    "pandas_fn": _orig_pandas_fn,
+    "batch_fn": _orig_batch_fn,
 }
 
 
 class AutoOrderDecorator:
     """Decorator that collects and applies decorators in predefined order."""
-    
+
     def __init__(self, name: str):
         self.name = name
         self.priority = DECORATOR_PRIORITY[name]
         self.original = ORIGINAL_DECORATORS[name]
-    
+
     def __call__(self, func: Callable) -> Callable:
         # Initialize or get pending decorators list
-        if not hasattr(func, '_pending_decorators'):
+        if not hasattr(func, "_pending_decorators"):
             # First decorator - create the wrapper
             original_func = func
-            
+
             @wraps(func)
             def auto_ordered_wrapper(*args, **kwargs):
                 # On first call, apply decorators in correct order
-                if hasattr(auto_ordered_wrapper, '_pending_decorators'):
+                if hasattr(auto_ordered_wrapper, "_pending_decorators"):
                     # Sort by priority (descending = innermost first)
                     decorators = sorted(
                         auto_ordered_wrapper._pending_decorators,
                         key=lambda x: x[1],
-                        reverse=True
+                        reverse=True,
                     )
-                    
+
                     # Apply decorators in order
                     final_func = original_func
                     for dec_name, _, dec_func in decorators:
                         final_func = dec_func(final_func)
-                    
+
                     # Replace this wrapper with the final decorated function
                     auto_ordered_wrapper._final_func = final_func
-                    delattr(auto_ordered_wrapper, '_pending_decorators')
-                
+                    delattr(auto_ordered_wrapper, "_pending_decorators")
+
                 # Call the final decorated function
-                if hasattr(auto_ordered_wrapper, '_final_func'):
+                if hasattr(auto_ordered_wrapper, "_final_func"):
                     return auto_ordered_wrapper._final_func(*args, **kwargs)
                 else:
                     return original_func(*args, **kwargs)
-            
+
             auto_ordered_wrapper._pending_decorators = []
             func = auto_ordered_wrapper
-        
+
         # Add this decorator to pending list
         func._pending_decorators.append((self.name, self.priority, self.original))
-        
+
         return func
 
 
 # Create auto-ordering versions
-torch_fn = AutoOrderDecorator('torch_fn')
-numpy_fn = AutoOrderDecorator('numpy_fn')
-pandas_fn = AutoOrderDecorator('pandas_fn')
-batch_fn = AutoOrderDecorator('batch_fn')
+torch_fn = AutoOrderDecorator("torch_fn")
+numpy_fn = AutoOrderDecorator("numpy_fn")
+pandas_fn = AutoOrderDecorator("pandas_fn")
+batch_fn = AutoOrderDecorator("batch_fn")
 
 
 # Enable auto-ordering globally
 def enable_auto_order():
     """
     Enable auto-ordering for all decorators in the scitex.decorators module.
-    
+
     This replaces the standard decorators with auto-ordering versions.
-    
+
     Example
     -------
     >>> import scitex
     >>> scitex.decorators.enable_auto_order()
-    >>> 
+    >>>
     >>> # Now decorators will auto-order regardless of how they're written
     >>> @scitex.decorators.batch_fn
     >>> @scitex.decorators.torch_fn
@@ -136,13 +136,13 @@ def enable_auto_order():
     ...     return x.mean()
     """
     import scitex.decorators as decorators_module
-    
+
     # Replace with auto-ordering versions
     decorators_module.torch_fn = torch_fn
     decorators_module.numpy_fn = numpy_fn
     decorators_module.pandas_fn = pandas_fn
     decorators_module.batch_fn = batch_fn
-    
+
     print("Auto-ordering enabled for scitex decorators!")
     print("Decorators will now apply in predefined order:")
     print("  1. Type conversion (torch_fn, numpy_fn, pandas_fn)")
@@ -152,21 +152,21 @@ def enable_auto_order():
 def disable_auto_order():
     """Disable auto-ordering and restore original decorators."""
     import scitex.decorators as decorators_module
-    
+
     # Restore original decorators
     decorators_module.torch_fn = _orig_torch_fn
     decorators_module.numpy_fn = _orig_numpy_fn
     decorators_module.pandas_fn = _orig_pandas_fn
     decorators_module.batch_fn = _orig_batch_fn
-    
+
     print("Auto-ordering disabled. Using original decorators.")
 
 
 __all__ = [
-    'torch_fn',
-    'numpy_fn',
-    'pandas_fn',
-    'batch_fn',
-    'enable_auto_order',
-    'disable_auto_order',
-]
+    "torch_fn",
+    "numpy_fn",
+    "pandas_fn",
+    "batch_fn",
+    "enable_auto_order",
+    "disable_auto_order",
+]

scitex/decorators/_batch_fn.py

@@ -28,19 +28,20 @@ def batch_fn(func: Callable) -> Callable:
 
         # Set the current decorator context
         wrapper._current_decorator = "batch_fn"
-        
+
         # Mark that batch_fn has been applied
-        if not hasattr(wrapper, '_decorator_order'):
+        if not hasattr(wrapper, "_decorator_order"):
             wrapper._decorator_order = []
-        wrapper._decorator_order.append('batch_fn')
+        wrapper._decorator_order.append("batch_fn")
 
         batch_size = int(kwargs.pop("batch_size", 4))
         if len(x) <= batch_size:
             # Only pass batch_size if the function accepts it
             import inspect
+
             try:
                 sig = inspect.signature(func)
-                if 'batch_size' in sig.parameters:
+                if "batch_size" in sig.parameters:
                     return func(x, *args, **kwargs, batch_size=batch_size)
                 else:
                     return func(x, *args, **kwargs)
@@ -57,10 +58,13 @@ def batch_fn(func: Callable) -> Callable:
 
             # Only pass batch_size if the function accepts it
             import inspect
+
             try:
                 sig = inspect.signature(func)
-                if 'batch_size' in sig.parameters:
-                    batch_result = func(x[start:end], *args, **kwargs, batch_size=batch_size)
+                if "batch_size" in sig.parameters:
+                    batch_result = func(
+                        x[start:end], *args, **kwargs, batch_size=batch_size
+                    )
                 else:
                     batch_result = func(x[start:end], *args, **kwargs)
             except:
@@ -68,6 +72,7 @@ def batch_fn(func: Callable) -> Callable:
                 batch_result = func(x[start:end], *args, **kwargs)
 
             import torch
+
             if isinstance(batch_result, torch.Tensor):
                 batch_result = batch_result.cpu()
             elif isinstance(batch_result, tuple):
@@ -79,6 +84,7 @@ def batch_fn(func: Callable) -> Callable:
             results.append(batch_result)
 
         import torch
+
         if isinstance(results[0], tuple):
             n_vars = len(results[0])
             combined_results = []

scitex/decorators/_cache_disk.py

@@ -1,22 +1,21 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-10-11 20:31:13 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex_repo/src/scitex/decorators/_cache_disk.py
+# Timestamp: "2025-12-09 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/decorators/_cache_disk.py
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/decorators/_cache_disk.py"
-)
+
+__FILE__ = "./src/scitex/decorators/_cache_disk.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
-# Time-stamp: "2024-11-07 06:08:45 (ywatanabe)"
-
 import functools
 
 from joblib import Memory as _Memory
 
+from scitex.config import get_paths
+
 
 def cache_disk(func):
     """Disk caching decorator that uses joblib.Memory.
@@ -26,8 +25,7 @@ def cache_disk(func):
         def expensive_function(x):
             return x ** 2
     """
-    scitex_dir = os.getenv("SCITEX_DIR", "~/.scitex")
-    cache_dir = os.path.join(scitex_dir, "cache", "functions")
+    cache_dir = str(get_paths().function_cache)
     memory = _Memory(cache_dir, verbose=0)
 
     @functools.wraps(func)
@@ -37,4 +35,5 @@ def cache_disk(func):
 
     return wrapper
 
+
 # EOF

scitex/decorators/_cache_disk_async.py

@@ -1,13 +1,12 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-10-11 20:30:56 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex_repo/src/scitex/decorators/_cache_disk_async.py
+# Timestamp: "2025-12-09 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/decorators/_cache_disk_async.py
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/decorators/_cache_disk_async.py"
-)
+
+__FILE__ = "./src/scitex/decorators/_cache_disk_async.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 """Async disk caching decorator using joblib.Memory."""
@@ -17,6 +16,8 @@ import functools
 
 from joblib import Memory as _Memory
 
+from scitex.config import get_paths
+
 
 def cache_disk_async(func):
     """Disk caching decorator for async functions.
@@ -27,8 +28,7 @@ def cache_disk_async(func):
             await asyncio.sleep(1)
             return x ** 2
     """
-    scitex_dir = os.getenv("SCITEX_DIR", os.path.expanduser("~/.scitex"))
-    cache_dir = os.path.join(scitex_dir, "cache", "functions")
+    cache_dir = str(get_paths().function_cache)
     memory = _Memory(cache_dir, verbose=0)
 
     # Create sync wrapper for joblib
@@ -46,4 +46,5 @@ def cache_disk_async(func):
 
     return async_wrapper
 
+
 # EOF

scitex/decorators/_combined.py

@@ -22,63 +22,69 @@ from ._pandas_fn import pandas_fn
 def torch_batch_fn(func: Callable) -> Callable:
     """
     Combined decorator: torch_fn → batch_fn.
-    
+
     Converts inputs to torch tensors, then processes in batches.
     This is the recommended order for PyTorch operations.
-    
+
     Example
     -------
     >>> @torch_batch_fn
     ... def process_data(x, dim=None):
     ...     return x.mean(dim=dim)
     """
+
     @wraps(func)
     @torch_fn
     @batch_fn
     def wrapper(*args, **kwargs):
         return func(*args, **kwargs)
+
     return wrapper
 
 
 def numpy_batch_fn(func: Callable) -> Callable:
     """
     Combined decorator: numpy_fn → batch_fn.
-    
+
     Converts inputs to numpy arrays, then processes in batches.
     This is the recommended order for NumPy operations.
-    
+
     Example
     -------
     >>> @numpy_batch_fn
     ... def process_data(x, axis=None):
     ...     return np.mean(x, axis=axis)
     """
+
     @wraps(func)
     @numpy_fn
     @batch_fn
     def wrapper(*args, **kwargs):
         return func(*args, **kwargs)
+
     return wrapper
 
 
 def pandas_batch_fn(func: Callable) -> Callable:
     """
     Combined decorator: pandas_fn → batch_fn.
-    
+
     Converts inputs to pandas DataFrames, then processes in batches.
     This is the recommended order for Pandas operations.
-    
+
     Example
     -------
     >>> @pandas_batch_fn
     ... def process_data(df):
     ...     return df.describe()
     """
+
     @wraps(func)
     @pandas_fn
     @batch_fn
     def wrapper(*args, **kwargs):
         return func(*args, **kwargs)
+
     return wrapper
 
 
@@ -89,10 +95,10 @@ batch_pandas_fn = pandas_batch_fn  # Alternative name
 
 
 __all__ = [
-    'torch_batch_fn',
-    'numpy_batch_fn', 
-    'pandas_batch_fn',
-    'batch_torch_fn',
-    'batch_numpy_fn',
-    'batch_pandas_fn',
-]
+    "torch_batch_fn",
+    "numpy_batch_fn",
+    "pandas_batch_fn",
+    "batch_torch_fn",
+    "batch_numpy_fn",
+    "batch_pandas_fn",
+]

scitex/decorators/_converters.py

@@ -48,6 +48,7 @@ def _conversion_warning(old: _Any, new) -> None:
 def _try_device(tensor, device: str):
     """Try to move tensor to specified device with graceful fallback."""
     import torch
+
     if not isinstance(tensor, torch.Tensor):
         return tensor
 
@@ -66,6 +67,7 @@ def _try_device(tensor, device: str):
 def is_torch(*args: _Any, **kwargs: _Any) -> bool:
     """Check if any input is a PyTorch tensor."""
     import torch
+
     return any(isinstance(arg, torch.Tensor) for arg in args) or any(
         isinstance(val, torch.Tensor) for val in kwargs.values()
     )
@@ -74,6 +76,7 @@ def is_torch(*args: _Any, **kwargs: _Any) -> bool:
 def is_cuda(*args: _Any, **kwargs: _Any) -> bool:
     """Check if any input is a CUDA tensor."""
     import torch
+
     return any((isinstance(arg, torch.Tensor) and arg.is_cuda) for arg in args) or any(
         (isinstance(val, torch.Tensor) and val.is_cuda) for val in kwargs.values()
     )
@@ -104,6 +107,7 @@ def to_torch(
 ) -> _Any:
     """Convert various data types to PyTorch tensors."""
     import torch
+
     if device is None:
         device = kwargs.get("device", "cuda" if torch.cuda.is_available() else "cpu")
 
@@ -138,7 +142,9 @@ def to_torch(
                 # If conversion fails, process items individually and return as tensor if possible
                 converted_items = [_to_torch(item) for item in data if item is not None]
                 # Try to stack if all items are tensors
-                if converted_items and all(isinstance(item, torch.Tensor) for item in converted_items):
+                if converted_items and all(
+                    isinstance(item, torch.Tensor) for item in converted_items
+                ):
                     try:
                         # Stack tensors along a new dimension
                         return torch.stack(converted_items)
@@ -165,7 +171,12 @@ def to_torch(
 
         # Handle xarray
         import xarray
-        if hasattr(data, '__class__') and data.__class__.__module__ == 'xarray.core.dataarray' and data.__class__.__name__ == 'DataArray':
+
+        if (
+            hasattr(data, "__class__")
+            and data.__class__.__module__ == "xarray.core.dataarray"
+            and data.__class__.__name__ == "DataArray"
+        ):
             new_data = torch.tensor(np.array(data)).float()
             new_data = _try_device(new_data, device)
             if device == "cuda":
@@ -228,7 +239,9 @@ def to_numpy(*args: _Any, return_fn: Callable = _return_if, **kwargs: _Any) -> _
                 # If conversion fails, process items individually
                 converted_items = [_to_numpy(item) for item in data if item is not None]
                 # Try to stack if all items are numpy arrays
-                if converted_items and all(isinstance(item, np.ndarray) for item in converted_items):
+                if converted_items and all(
+                    isinstance(item, np.ndarray) for item in converted_items
+                ):
                     try:
                         # Stack arrays along a new dimension
                         return np.stack(converted_items)

scitex/decorators/_deprecated.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -37,34 +38,38 @@ def deprecated(reason=None, forward_to=None):
                 )
                 # Dynamic import and call forwarding
                 module_path, function_name = forward_to.rsplit(".", 1)
-                
+
                 # Handle relative imports
                 if module_path.startswith(".."):
                     # Get the module where the function was defined (not the calling module)
                     func_module = func.__module__
-                    
+
                     if func_module:
                         # Convert relative import to absolute based on the function's module
-                        package_parts = func_module.split('.')
+                        package_parts = func_module.split(".")
                         # Count the number of dots to determine how many levels to go up
                         level_count = 0
                         for char in module_path:
-                            if char == '.':
+                            if char == ".":
                                 level_count += 1
                             else:
                                 break
-                        
+
                         # Remove the relative part and create absolute path
                         if level_count > 0:
                             base_package_parts = package_parts[:-level_count]
                             if base_package_parts:
-                                base_package = '.'.join(base_package_parts)
-                                relative_part = module_path.lstrip('.')
-                                module_path = base_package + '.' + relative_part if relative_part else base_package
+                                base_package = ".".join(base_package_parts)
+                                relative_part = module_path.lstrip(".")
+                                module_path = (
+                                    base_package + "." + relative_part
+                                    if relative_part
+                                    else base_package
+                                )
                             else:
                                 # Can't go up that many levels, fallback to absolute
-                                module_path = module_path.lstrip('.')
-                
+                                module_path = module_path.lstrip(".")
+
                 try:
                     target_module = importlib.import_module(module_path)
                     target_function = getattr(target_module, function_name)
@@ -78,45 +83,49 @@ def deprecated(reason=None, forward_to=None):
                         stacklevel=2,
                     )
                     return func(*args, **kwargs)
-            
+
             # Auto-generate docstring for forwarding wrapper with target function's docstring
             original_name = func.__name__
             new_location = forward_to.replace("..", "scitex.").lstrip(".")
-            
+
             # Try to get the target function's docstring
             target_docstring = ""
             try:
                 # Get the same target we'll forward to
                 target_module_path, target_function_name = forward_to.rsplit(".", 1)
-                
+
                 # Handle relative imports for docstring retrieval
                 if target_module_path.startswith(".."):
                     func_module = func.__module__
                     if func_module:
-                        package_parts = func_module.split('.')
+                        package_parts = func_module.split(".")
                         level_count = 0
                         for char in target_module_path:
-                            if char == '.':
+                            if char == ".":
                                 level_count += 1
                             else:
                                 break
-                        
+
                         if level_count > 0:
                             base_package_parts = package_parts[:-level_count]
                             if base_package_parts:
-                                base_package = '.'.join(base_package_parts)
-                                relative_part = target_module_path.lstrip('.')
-                                target_module_path = base_package + '.' + relative_part if relative_part else base_package
+                                base_package = ".".join(base_package_parts)
+                                relative_part = target_module_path.lstrip(".")
+                                target_module_path = (
+                                    base_package + "." + relative_part
+                                    if relative_part
+                                    else base_package
+                                )
                             else:
-                                target_module_path = target_module_path.lstrip('.')
-                
+                                target_module_path = target_module_path.lstrip(".")
+
                 target_module = importlib.import_module(target_module_path)
                 target_function = getattr(target_module, target_function_name)
                 if target_function.__doc__:
                     target_docstring = target_function.__doc__.strip()
             except (ImportError, AttributeError):
                 pass  # Fall back to basic docstring if target can't be imported
-            
+
             # Create comprehensive docstring combining deprecation notice with target docs
             if target_docstring:
                 forwarding_docstring = f"""**DEPRECATED: Use {new_location} instead**
@@ -188,4 +197,5 @@ DeprecationWarning
 
     return decorator
 
+
 # EOF

scitex/decorators/_numpy_fn.py

@@ -47,7 +47,9 @@ def numpy_fn(func: Callable) -> Callable:
             elif isinstance(arg, (int, float, str, type(None))):
                 # Pass through scalars and strings unchanged
                 validated_args.append(arg)
-            elif isinstance(arg, list) and all(isinstance(item, np.ndarray) for item in arg):
+            elif isinstance(arg, list) and all(
+                isinstance(item, np.ndarray) for item in arg
+            ):
                 # List of arrays - pass through as is
                 validated_args.append(arg)
             else:
@@ -65,14 +67,26 @@ def numpy_fn(func: Callable) -> Callable:
             if original_object is not None:
                 if isinstance(original_object, list):
                     return results.tolist()
-                elif hasattr(original_object, '__class__') and original_object.__class__.__name__ == 'Tensor':
+                elif (
+                    hasattr(original_object, "__class__")
+                    and original_object.__class__.__name__ == "Tensor"
+                ):
                     import torch
+
                     return torch.tensor(results)
-                elif hasattr(original_object, '__class__') and original_object.__class__.__name__ == 'DataFrame':
+                elif (
+                    hasattr(original_object, "__class__")
+                    and original_object.__class__.__name__ == "DataFrame"
+                ):
                     import pandas as pd
+
                     return pd.DataFrame(results)
-                elif hasattr(original_object, '__class__') and original_object.__class__.__name__ == 'Series':
+                elif (
+                    hasattr(original_object, "__class__")
+                    and original_object.__class__.__name__ == "Series"
+                ):
                     import pandas as pd
+
                     return pd.Series(results)
             return results