scitex 2.0.0__py2.py3-none-any.whl

scitex/decorators/_timeout.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-07 05:58:41 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/decorators/_timeout.py
+
+#!./env/bin/python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-04-23 19:11:33"
+# Author: Yusuke Watanabe (ywata1989@gmail.com)
+
+"""
+This script does XYZ.
+"""
+
+"""
+Imports
+"""
+
+
+"""
+Config
+"""
+# CONFIG = scitex.gen.load_configs()
+
+"""
+Functions & Classes
+"""
+from multiprocessing import Process, Queue
+
+
+def timeout(seconds=10, error_message="Timeout"):
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            def queue_wrapper(queue, args, kwargs):
+                result = func(*args, **kwargs)
+                queue.put(result)
+
+            queue = Queue()
+            args_for_process = (queue, args, kwargs)
+            process = Process(target=queue_wrapper, args=args_for_process)
+            process.start()
+            process.join(timeout=seconds)
+
+            if process.is_alive():
+                process.terminate()
+                raise TimeoutError(error_message)
+            else:
+                return queue.get()
+
+        return wrapper
+
+    return decorator
+
+
+# EOF

scitex/decorators/_torch_fn.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-04-30 15:40:43 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/decorators/_torch_fn.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/decorators/_torch_fn.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from functools import wraps
+from typing import Any as _Any
+from typing import Callable
+
+import numpy as np
+import pandas as pd
+import torch
+import xarray as xr
+
+from ._converters import _return_always, is_nested_decorator, to_torch
+
+
+def torch_fn(func: Callable) -> Callable:
+    """Decorator for PyTorch function compatibility.
+    
+    Automatically converts inputs to PyTorch tensors and handles various data types
+    gracefully. Preserves the original input type in the output.
+    
+    Features
+    --------
+    - Converts inputs to PyTorch tensors
+    - Preserves scalar parameters (int, float, bool, str) 
+    - Preserves dimension tuples like dim=(0, 1)
+    - Handles nested lists/tuples gracefully
+    - Automatically converts axis to dim for torch functions
+    - Applies device="cuda" if available
+    - Returns output in same type as input (numpy->numpy, pandas->pandas, etc.)
+    
+    Parameters
+    ----------
+    func : Callable
+        The function to decorate
+        
+    Returns
+    -------
+    Callable
+        The decorated function
+        
+    Examples
+    --------
+    >>> @torch_fn
+    ... def mean_squared(x, dim=None):
+    ...     return (x ** 2).mean(dim=dim)
+    >>> 
+    >>> # Works with numpy arrays
+    >>> result = mean_squared(np.array([1, 2, 3]))
+    >>> 
+    >>> # Works with nested lists
+    >>> result = mean_squared([[1, 2], [3, 4]])
+    >>> 
+    >>> # Preserves dimension tuples
+    >>> result = mean_squared(data, dim=(0, 1))
+    
+    Notes
+    -----
+    For optimal performance with batch processing, apply torch_fn before batch_fn:
+    @batch_fn
+    @torch_fn
+    def my_function(x): ...
+    
+    Or use auto-ordering to handle this automatically.
+    """
+    @wraps(func)
+    def wrapper(*args: _Any, **kwargs: _Any) -> _Any:
+        # Skip conversion if already in a nested decorator context
+        if is_nested_decorator():
+            results = func(*args, **kwargs)
+            return results
+
+        # Set the current decorator context
+        wrapper._current_decorator = "torch_fn"
+
+        # Store original object for type preservation
+        original_object = args[0] if args else None
+
+        converted_args, converted_kwargs = to_torch(
+            *args, return_fn=_return_always, **kwargs
+        )
+
+        # Skip strict assertion for certain types that may not convert to tensors
+        # Instead, convert what we can and pass through what we can't
+        validated_args = []
+        for arg_index, arg in enumerate(converted_args):
+            if isinstance(arg, torch.Tensor):
+                validated_args.append(arg)
+            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, torch.Tensor) for item in arg):
+                # List of tensors - pass through as is
+                validated_args.append(arg)
+            else:
+                # Try one more conversion attempt
+                try:
+                    validated_args.append(torch.tensor(arg).float())
+                except:
+                    # If all else fails, pass through unchanged
+                    validated_args.append(arg)
+
+        results = func(*validated_args, **converted_kwargs)
+
+        # Convert results back to original input types
+        if isinstance(results, torch.Tensor):
+            if original_object is not None:
+                if isinstance(original_object, list):
+                    return results.detach().cpu().numpy().tolist()
+                elif isinstance(original_object, np.ndarray):
+                    return results.detach().cpu().numpy()
+                elif isinstance(original_object, pd.DataFrame):
+                    return pd.DataFrame(results.detach().cpu().numpy())
+                elif isinstance(original_object, pd.Series):
+                    return pd.Series(results.detach().cpu().numpy().flatten())
+                elif isinstance(original_object, xr.DataArray):
+                    return xr.DataArray(results.detach().cpu().numpy())
+            return results
+
+        return results
+
+    # Mark as a wrapper for detection
+    wrapper._is_wrapper = True
+    wrapper._decorator_type = "torch_fn"
+    return wrapper
+
+
+# EOF

scitex/decorators/_wrap.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-01 09:16:13 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/decorators/_wrap.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/decorators/_wrap.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+
+def wrap(func):
+    """Basic function wrapper that preserves function metadata.
+    Usage:
+    @wrap
+    def my_function(x):
+        return x + 1
+    # Or manually:
+    def my_function(x):
+        return x + 1
+    wrapped_func = wrap(my_function)
+    This wrapper is useful as a template for creating more complex decorators
+    or when you want to ensure function metadata is preserved.
+    """
+    import functools
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    # Store reference to original function
+    wrapper._original_func = func
+    # Mark as a wrapper for detection
+    wrapper._is_wrapper = True
+    return wrapper
+
+
+# EOF

scitex/decorators/_xarray_fn.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-04-30 15:41:19 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/decorators/_xarray_fn.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/decorators/_xarray_fn.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+from functools import wraps
+from typing import Any as _Any
+from typing import Callable
+
+import numpy as np
+import pandas as pd
+import torch
+import xarray as xr
+
+from ._converters import is_nested_decorator
+
+
+def xarray_fn(func: Callable) -> Callable:
+    @wraps(func)
+    def wrapper(*args: _Any, **kwargs: _Any) -> _Any:
+        # Skip conversion if already in a nested decorator context
+        if is_nested_decorator():
+            results = func(*args, **kwargs)
+            return results
+
+        # Set the current decorator context
+        wrapper._current_decorator = "xarray_fn"
+
+        # Store original object for type preservation
+        original_object = args[0] if args else None
+
+        # Convert args to xarray DataArrays
+        def to_xarray(data):
+            if isinstance(data, xr.DataArray):
+                return data
+            elif isinstance(data, np.ndarray):
+                return xr.DataArray(data)
+            elif isinstance(data, list):
+                return xr.DataArray(data)
+            elif isinstance(data, torch.Tensor):
+                return xr.DataArray(data.detach().cpu().numpy())
+            elif isinstance(data, pd.DataFrame):
+                return xr.DataArray(data.values)
+            elif isinstance(data, pd.Series):
+                return xr.DataArray(data.values)
+            else:
+                return xr.DataArray([data])
+
+        converted_args = [to_xarray(arg) for arg in args]
+        converted_kwargs = {k: to_xarray(v) for k, v in kwargs.items()}
+
+        # Assertion to ensure all args are converted to xarray DataArrays
+        for arg_index, arg in enumerate(converted_args):
+            assert isinstance(
+                arg, xr.DataArray
+            ), f"Argument {arg_index} not converted to DataArray: {type(arg)}"
+
+        results = func(*converted_args, **converted_kwargs)
+
+        # Convert results back to original input types
+        if isinstance(results, xr.DataArray):
+            if original_object is not None:
+                if isinstance(original_object, list):
+                    return results.values.tolist()
+                elif isinstance(original_object, np.ndarray):
+                    return results.values
+                elif isinstance(original_object, torch.Tensor):
+                    return torch.tensor(results.values)
+                elif isinstance(original_object, pd.DataFrame):
+                    return pd.DataFrame(results.values)
+                elif isinstance(original_object, pd.Series):
+                    return pd.Series(results.values.flatten())
+            return results
+
+        return results
+
+    # Mark as a wrapper for detection
+    wrapper._is_wrapper = True
+    wrapper._decorator_type = "xarray_fn"
+    return wrapper
+
+
+# EOF

scitex/dev/__init__.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""Scitex dev module."""
+
+from ._analyze_code_flow import CodeFlowAnalyzer, analyze_code_flow, main, parse_args
+from ._reload import reload, reload_auto, reload_stop
+
+__all__ = [
+    "CodeFlowAnalyzer",
+    "analyze_code_flow",
+    "main",
+    "parse_args",
+    "reload",
+    "reload_auto",
+    "reload_stop",
+]

scitex/dev/_analyze_code_flow.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-20 10:27:28 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/dev/_analyze_code_flow.py
+
+THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/dev/_analyze_code_flow.py"
+
+import ast
+
+import matplotlib.pyplot as plt
+import scitex
+
+
+class CodeFlowAnalyzer:
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        self.execution_flow = []
+        self.sequence = 1
+        self.skip_functions = {
+            "__init__",
+            "__main__",
+            # Python built-ins
+            "len",
+            "min",
+            "max",
+            "sum",
+            "enumerate",
+            "eval",
+            "print",
+            "str",
+            "int",
+            "float",
+            "list",
+            "dict",
+            "set",
+            "tuple",
+            "any",
+            "all",
+            "map",
+            "filter",
+            "zip",
+            # Common DataFrame operations
+            "apply",
+            "unique",
+            "tolist",
+            "to_list",
+            "rename",
+            "merge",
+            "set_index",
+            "reset_index",
+            "groupby",
+            "sort_values",
+            "iloc",
+            "loc",
+            "where",
+            # NumPy operations
+            "reshape",
+            "squeeze",
+            "stack",
+            "concatenate",
+            "array",
+            "zeros",
+            "ones",
+            "full",
+            "empty",
+            "frombuffer",
+            # Common attributes/methods
+            "shape",
+            "dtype",
+            "size",
+            "index",
+            "columns",
+            "values",
+            "name",
+            "names",
+            # File operations
+            "open",
+            "read",
+            "write",
+            "close",
+            # String operations
+            "join",
+            "split",
+            "strip",
+            "replace",
+            # Custom
+            "scitex.str.printc",
+            "printc",
+            "scitex.io.load_configs",
+            "parse_args",
+            "run_main",
+            "load_configs",
+        }
+        # self.seen_calls = set()  # Track unique function calls
+
+    def _trace_calls(self, node, depth=0):
+        sequence_orig = self.sequence
+
+        if isinstance(node, (ast.FunctionDef, ast.ClassDef)):
+
+            if node.name not in self.skip_functions:
+                # Track all function definitions
+                self.execution_flow.append((depth, node.name, self.sequence))
+                self.sequence += 1
+
+        if isinstance(node, ast.Call):
+            if isinstance(node.func, ast.Name):
+                func_name = node.func.id
+
+                if func_name not in self.skip_functions:
+                    self.execution_flow.append((depth, func_name, self.sequence))
+                    self.sequence += 1
+
+            elif isinstance(node.func, ast.Attribute):
+                parts = []
+                current = node.func
+                while isinstance(current, ast.Attribute):
+                    parts.insert(0, current.attr)
+                    current = current.value
+                if isinstance(current, ast.Name):
+                    parts.insert(0, current.id)
+                func_name = ".".join(parts)
+
+                if not any(skip in func_name for skip in self.skip_functions):
+                    self.execution_flow.append((depth, func_name, self.sequence))
+                    self.sequence += 1
+
+        if self.sequence == 1:
+            depth = 0
+
+        for child in ast.iter_child_nodes(node):
+            self._trace_calls(child, depth + 1)
+
+    def _get_func_name(self, node):
+        if isinstance(node.func, ast.Name):
+            return node.func.id
+        elif isinstance(node.func, ast.Attribute):
+            parts = []
+            current = node.func
+            while isinstance(current, ast.Attribute):
+                parts.insert(0, current.attr)
+                current = current.value
+            if isinstance(current, ast.Name):
+                parts.insert(0, current.id)
+            func_name = ".".join(parts)
+            return (
+                func_name
+                if not any(skip in func_name for skip in self.skip_functions)
+                else None
+            )
+        return None
+
+    def _format_output(self):
+        output = ["Execution Flow:"]
+        last_depth = 1
+        skip_until_depth = None
+
+        filtered_flow = []
+
+        for depth, call, seq in self.execution_flow:
+
+            # Start skipping when encountering private method
+            if call.startswith(("_", "self._")):
+                skip_until_depth = depth
+                continue
+
+            # Skip all nested calls within private methods
+            if skip_until_depth is not None and depth > skip_until_depth:
+                continue
+            else:
+                skip_until_depth = None
+
+            filtered_flow.append((depth, call, seq))
+            last_depth = depth
+
+        # Reset seq on depth == 1
+        seq_prev = 0
+        for ii, flow in enumerate(filtered_flow):
+            depth, call, seq = flow
+            if depth == 1:
+                seq_current = 1
+                seq_prev = 1
+            else:
+                if depth > 1:
+                    seq_current = seq_prev + 1
+                    seq_prev = seq_current
+                else:
+                    seq_current = 0
+                    seq_prev = 0
+
+            filtered_flow[ii] = (depth, call, seq_current)
+
+        for depth, call, seq in filtered_flow:
+            prefix = "    " * depth
+            if depth == 1:
+                line = f"\n{prefix}[{int(seq) if isinstance(seq, float) else seq:02d}] {call}"
+            else:
+                line = f"{prefix}[{int(seq) if isinstance(seq, float) else seq:02d}] └── {call}"
+            output.append(line)
+
+        return "\n".join(output)
+
+    def analyze(self):
+        if self.file_path:
+            try:
+                with open(self.file_path, "r") as file:
+                    content = file.read()
+
+                    # Find main guard position and truncate content
+                    if "if __name__" in content:
+                        main_guard_pos = content.find("if __name__")
+                        content = content[:main_guard_pos].strip()
+
+                    tree = ast.parse(content)
+                self._trace_calls(tree)
+                return self._format_output()
+            except Exception as e:
+                print(e)
+                return str(e)
+
+
+def analyze_code_flow(lpath):
+    return CodeFlowAnalyzer(lpath).analyze()
+
+
+def main(args):
+    diagram = analyze_code_flow(__file__)
+    print(diagram)
+    return 0
+
+
+def parse_args():
+    import argparse
+
+    import scitex
+
+    is_script = scitex.gen.is_script()
+
+    parser = argparse.ArgumentParser(description="")
+    parser.add_argument(
+        "--var",
+        "-v",
+        type=int,
+        choices=None,
+        default=1,
+        help="(default: %%(default)s)",
+    )
+    parser.add_argument(
+        "--flag",
+        "-f",
+        action="store_true",
+        default=False,
+        help="(default: %%(default)s)",
+    )
+    args = parser.parse_args()
+    scitex.str.printc(args, c="yellow")
+
+    return args
+
+
+if __name__ == "__main__":
+    import sys
+
+    import matplotlib.pyplot as plt
+
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(
+        sys,
+        plt,
+        verbose=False,
+        agg=True,
+    )
+
+    exit_status = main(parse_args())
+
+    scitex.gen.close(
+        CONFIG,
+        verbose=False,
+        notify=False,
+        message="",
+        exit_status=exit_status,
+    )
+
+
+# EOF

scitex/dev/_reload.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-07 17:17:06 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/dev/_reload.py
+
+
+import importlib
+import sys
+import threading
+import time
+from typing import Any, Optional
+
+_reload_thread: Optional[threading.Thread] = None
+_running: bool = False
+
+
+def reload() -> Any:  # Changed return type hint to Any
+    """Reloads scitex package and its submodules."""
+    import scitex
+
+    scitex_modules = [mod for mod in sys.modules if mod.startswith("scitex")]
+    for module in scitex_modules:
+        try:
+            importlib.reload(sys.modules[module])
+        except Exception:
+            pass
+    return importlib.reload(scitex)
+
+
+def reload_auto(interval: int = 10) -> None:
+    """Start auto-reload in background thread."""
+    global _reload_thread, _running
+
+    if _reload_thread and _reload_thread.is_alive():
+        return
+
+    _running = True
+    _reload_thread = threading.Thread(
+        target=_auto_reload_loop, args=(interval,), daemon=True
+    )
+    _reload_thread.start()
+
+
+def reload_stop() -> None:
+    """Stop auto-reload."""
+    global _running
+    _running = False
+
+
+def _auto_reload_loop(interval: int) -> None:
+    while _running:
+        try:
+            reload()
+        except Exception as e:
+            print(f"Reload failed: {e}")
+        time.sleep(interval)
+
+
+# EOF