scitex 2.0.0__py2.py3-none-any.whl

scitex/decorators/_auto_order.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2025-06-01 10:30:00 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/decorators/_auto_order.py
+
+"""
+Auto-ordering decorator system that enforces predefined order regardless of 
+how decorators are written in code.
+
+The enforced order is:
+1. Type conversion (innermost): torch_fn, numpy_fn, pandas_fn
+2. Batch processing (outermost): batch_fn
+
+This uses a delayed application approach where decorators are collected
+and then applied in the correct order when the function is first called.
+
+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):
+...     return x.mean()
+
+The auto-ordering system eliminates decorator ordering complexity and
+prevents common errors from incorrect decorator stacking.
+"""
+
+from functools import wraps
+from typing import Callable, List, Tuple, Any
+
+# Import original decorators
+from ._torch_fn import torch_fn as _orig_torch_fn
+from ._numpy_fn import numpy_fn as _orig_numpy_fn
+from ._pandas_fn import pandas_fn as _orig_pandas_fn
+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,
+}
+
+# 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,
+}
+
+
+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'):
+            # 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'):
+                    # Sort by priority (descending = innermost first)
+                    decorators = sorted(
+                        auto_ordered_wrapper._pending_decorators,
+                        key=lambda x: x[1],
+                        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')
+                
+                # Call the final decorated function
+                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')
+
+
+# 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
+    >>> def my_func(x):
+    ...     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)")
+    print("  2. Batch processing (batch_fn)")
+
+
+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',
+]

scitex/decorators/_batch_fn.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-01 09:18:26 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/decorators/_batch_fn.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/decorators/_batch_fn.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+from typing import Any as _Any
+
+from functools import wraps
+from typing import Callable
+
+import numpy as np
+import torch
+from tqdm import tqdm as _tqdm
+
+from ._converters import is_nested_decorator
+
+
+def batch_fn(func: Callable) -> Callable:
+    @wraps(func)
+    def wrapper(x: _Any, *args: _Any, **kwargs: _Any) -> _Any:
+        # Skip batching if in a nested decorator context and batch_size is already set
+        if is_nested_decorator() and "batch_size" in kwargs:
+            return func(x, *args, **kwargs)
+
+        # Set the current decorator context
+        wrapper._current_decorator = "batch_fn"
+        
+        # Mark that batch_fn has been applied
+        if not hasattr(wrapper, '_decorator_order'):
+            wrapper._decorator_order = []
+        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:
+                    return func(x, *args, **kwargs, batch_size=batch_size)
+                else:
+                    return func(x, *args, **kwargs)
+            except:
+                # Fallback for wrapped functions
+                return func(x, *args, **kwargs)
+
+        n_batches = (len(x) + batch_size - 1) // batch_size
+        results = []
+
+        for i_batch in _tqdm(range(n_batches)):
+            start = i_batch * batch_size
+            end = min((i_batch + 1) * batch_size, len(x))
+
+            # 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)
+                else:
+                    batch_result = func(x[start:end], *args, **kwargs)
+            except:
+                # Fallback for wrapped functions
+                batch_result = func(x[start:end], *args, **kwargs)
+
+            if isinstance(batch_result, torch.Tensor):
+                batch_result = batch_result.cpu()
+            elif isinstance(batch_result, tuple):
+                batch_result = tuple(
+                    val.cpu() if isinstance(val, torch.Tensor) else val
+                    for val in batch_result
+                )
+
+            results.append(batch_result)
+
+        if isinstance(results[0], tuple):
+            n_vars = len(results[0])
+            combined_results = []
+            for i_var in range(n_vars):
+                # Check if this element is stackable (tensor/array) or should be kept as-is
+                first_elem = results[0][i_var]
+                if isinstance(first_elem, (torch.Tensor, np.ndarray)):
+                    # Stack tensors/arrays
+                    if isinstance(first_elem, torch.Tensor):
+                        if first_elem.ndim == 0:
+                            combined = torch.stack([res[i_var] for res in results])
+                        else:
+                            combined = torch.vstack([res[i_var] for res in results])
+                    else:
+                        combined = np.vstack([res[i_var] for res in results])
+                    combined_results.append(combined)
+                else:
+                    # For non-tensor elements (like lists), just take the first one
+                    # (assuming they're all the same across batches)
+                    combined_results.append(first_elem)
+            return tuple(combined_results)
+        elif isinstance(results[0], torch.Tensor):
+            # Check if results are 0-D tensors (scalars)
+            if results[0].ndim == 0:
+                return torch.stack(results)
+            else:
+                return torch.vstack(results)
+        elif isinstance(results[0], np.ndarray):
+            # Handle numpy arrays
+            if results[0].ndim == 0:
+                return np.array(results)
+            else:
+                return np.vstack(results)
+        elif isinstance(results[0], (int, float)):
+            # Handle scalar results
+            return np.array(results) if len(results) > 1 else results[0]
+        else:
+            # For lists and other types
+            return sum(results, [])
+
+    # Mark as a wrapper for detection
+    wrapper._is_wrapper = True
+    wrapper._decorator_type = "batch_fn"
+    return wrapper
+
+
+# EOF

scitex/decorators/_cache_disk.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-07 06:08:45 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/decorators/_cache_disk.py
+
+import functools
+import os
+
+from joblib import Memory as _Memory
+
+
+def cache_disk(func):
+    """Disk caching decorator that uses joblib.Memory.
+
+    Usage:
+        @cache_disk
+        def expensive_function(x):
+            return x ** 2
+    """
+    scitex_dir = os.getenv("SciTeX_DIR", "~/.cache/scitex/")
+    cache_dir = scitex_dir + "cache/"
+    memory = _Memory(cache_dir, verbose=0)
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        cached_func = memory.cache(func)
+        return cached_func(*args, **kwargs)
+
+    return wrapper
+
+
+# EOF

scitex/decorators/_cache_mem.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-07 05:52:33 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/decorators/_cache_mem.py
+
+from functools import lru_cache as _lru_cache
+
+# Memory cache
+cache_mem = _lru_cache(maxsize=None)
+
+
+# EOF

scitex/decorators/_combined.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2025-06-01 10:20:00 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/decorators/_combined.py
+
+"""
+Combined decorators with predefined application order to reduce complexity.
+
+The order is always: type conversion → batch processing
+This ensures consistent behavior and reduces unexpected interactions.
+"""
+
+from functools import wraps
+from typing import Callable
+
+from ._batch_fn import batch_fn
+from ._torch_fn import torch_fn
+from ._numpy_fn import numpy_fn
+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
+
+
+# Aliases for common use cases
+batch_torch_fn = torch_batch_fn  # Alternative name
+batch_numpy_fn = numpy_batch_fn  # Alternative name
+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',
+]