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

scitex/decorators/_cache_disk.py

@@ -1,10 +1,19 @@
 #!/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
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = (
+    "./src/scitex/decorators/_cache_disk.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
 # 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
 
@@ -17,8 +26,8 @@ def cache_disk(func):
         def expensive_function(x):
             return x ** 2
     """
-    scitex_dir = os.getenv("SciTeX_DIR", "~/.cache/scitex/")
-    cache_dir = scitex_dir + "cache/"
+    scitex_dir = os.getenv("SCITEX_DIR", "~/.scitex")
+    cache_dir = os.path.join(scitex_dir, "cache", "functions")
     memory = _Memory(cache_dir, verbose=0)
 
     @functools.wraps(func)
@@ -28,5 +37,4 @@ def cache_disk(func):
 
     return wrapper
 
-
 # EOF

scitex/decorators/_cache_disk_async.py

@@ -0,0 +1,49 @@
+#!/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
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = (
+    "./src/scitex/decorators/_cache_disk_async.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+"""Async disk caching decorator using joblib.Memory."""
+
+import asyncio
+import functools
+
+from joblib import Memory as _Memory
+
+
+def cache_disk_async(func):
+    """Disk caching decorator for async functions.
+
+    Usage:
+        @cache_disk_async
+        async def expensive_async_function(x):
+            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")
+    memory = _Memory(cache_dir, verbose=0)
+
+    # Create sync wrapper for joblib
+    def sync_wrapper(*args, **kwargs):
+        return asyncio.run(func(*args, **kwargs))
+
+    cached_sync = memory.cache(sync_wrapper)
+
+    @functools.wraps(func)
+    async def async_wrapper(*args, **kwargs):
+        # Run cached sync version in executor to avoid blocking
+        loop = asyncio.get_event_loop()
+        result = await loop.run_in_executor(None, lambda: cached_sync(*args, **kwargs))
+        return result
+
+    return async_wrapper
+
+# EOF

scitex/decorators/_deprecated.py

@@ -1,26 +1,191 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-08-21 20:57:29 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/decorators/_deprecated.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
 import functools
+import importlib
 import warnings
 
 
-def deprecated(reason=None):
+def deprecated(reason=None, forward_to=None):
     """
     A decorator to mark functions as deprecated. It will result in a warning being emitted
     when the function is used.
 
     Args:
         reason (str): A human-readable string explaining why this function was deprecated.
+        forward_to (str): Optional module path to forward calls to (e.g., "..session.start").
+                         If provided, calls will be forwarded to the new function instead of
+                         executing the original deprecated function.
     """
 
     def decorator(func):
-        @functools.wraps(func)
-        def new_func(*args, **kwargs):
-            warnings.warn(
-                f"{func.__name__} is deprecated: {reason}",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            return func(*args, **kwargs)
+        if forward_to:
+            # Create a forwarding wrapper with auto-generated docstring
+            @functools.wraps(func)
+            def new_func(*args, **kwargs):
+                warnings.warn(
+                    f"{func.__name__} is deprecated: {reason}",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+                # 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('.')
+                        # Count the number of dots to determine how many levels to go up
+                        level_count = 0
+                        for char in module_path:
+                            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
+                            else:
+                                # Can't go up that many levels, fallback to absolute
+                                module_path = module_path.lstrip('.')
+                
+                try:
+                    target_module = importlib.import_module(module_path)
+                    target_function = getattr(target_module, function_name)
+                    return target_function(*args, **kwargs)
+                except (ImportError, AttributeError) as e:
+                    # Fallback to original function if forwarding fails
+                    warnings.warn(
+                        f"Failed to forward {func.__name__} to {forward_to}: {e}. "
+                        f"Using original deprecated implementation.",
+                        RuntimeWarning,
+                        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('.')
+                        level_count = 0
+                        for char in target_module_path:
+                            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
+                            else:
+                                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**
 
-        return new_func
+{target_docstring}
+
+Deprecation Notice
+------------------
+This function is deprecated and will be removed in a future version.
+Use `{new_location}` instead. This wrapper forwards all calls to the new function
+while displaying a deprecation warning.
+
+Parameters
+----------
+*args : tuple
+    Positional arguments passed to {new_location}
+**kwargs : dict 
+    Keyword arguments passed to {new_location}
+    
+Returns
+-------
+Any
+    Same return value as {new_location}
+    
+Warns
+-----
+DeprecationWarning
+    Always warns that this function is deprecated
+"""
+            else:
+                # Fallback if target docstring unavailable
+                forwarding_docstring = f"""**DEPRECATED: Use {new_location} instead**
+    
+This function provides backward compatibility for existing code that uses
+{original_name}(). It forwards all calls to the new {new_location}
+function while displaying a deprecation warning.
+
+Parameters
+----------
+*args : tuple
+    Positional arguments passed to {new_location}
+**kwargs : dict 
+    Keyword arguments passed to {new_location}
+    
+Returns
+-------
+Any
+    Same return value as {new_location}
+    
+Warns
+-----
+DeprecationWarning
+    Always warns that this function is deprecated
+"""
+            new_func.__doc__ = forwarding_docstring
+            return new_func
+        else:
+            # Original behavior for non-forwarding deprecation
+            @functools.wraps(func)
+            def new_func(*args, **kwargs):
+                warnings.warn(
+                    f"{func.__name__} is deprecated: {reason}",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+                return func(*args, **kwargs)
+
+            return new_func
 
     return decorator
+
+# EOF

scitex/decorators/_timeout.py

@@ -6,7 +6,7 @@
 #!./env/bin/python3
 # -*- coding: utf-8 -*-
 # Time-stamp: "2024-04-23 19:11:33"
-# Author: Yusuke Watanabe (ywata1989@gmail.com)
+# Author: Yusuke Watanabe (ywatanabe@scitex.ai)
 
 """
 This script does XYZ.

scitex/dev/_analyze_code_flow.py

@@ -263,7 +263,7 @@ if __name__ == "__main__":
 
     import matplotlib.pyplot as plt
 
-    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.session.start(
         sys,
         plt,
         verbose=False,
@@ -272,7 +272,7 @@ if __name__ == "__main__":
 
     exit_status = main(parse_args())
 
-    scitex.gen.close(
+    scitex.session.close(
         CONFIG,
         verbose=False,
         notify=False,

scitex/dict/_DotDict.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-04-24 09:31:50 (ywatanabe)"
-# File: /ssh:sp:/home/ywatanabe/proj/scitex_repo/src/scitex/dict/_DotDict.py
+# Timestamp: "2025-08-22 22:03:48 (ywatanabe)"
+# File: /home/ywatanabe/proj/SciTeX-Code/src/scitex/dict/_DotDict.py
 # ----------------------------------------
+from __future__ import annotations
 import os
-
-__FILE__ = "./src/scitex/dict/_DotDict.py"
+__FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -23,13 +23,14 @@ class DotDict:
         # Avoids conflicts with keys named like standard methods ('keys', 'items', etc.)
         super().__setattr__("_data", {})
         if dictionary is not None:
-            if not isinstance(dictionary, dict):
+            if isinstance(dictionary, DotDict):
+                dictionary = dictionary._data
+            elif not isinstance(dictionary, dict):
                 raise TypeError("Input must be a dictionary.")
+
             for key, value in dictionary.items():
-                # Recursively convert nested dictionaries
-                if isinstance(value, dict):
+                if isinstance(value, dict) and not isinstance(value, DotDict):
                     value = DotDict(value)
-                # Use __setitem__ to populate data correctly
                 self[key] = value
 
     # --- Attribute Access (for valid identifiers) ---
@@ -55,9 +56,8 @@ class DotDict:
         if key == "_data" or key.startswith("_"):
             super().__setattr__(key, value)
         else:
-            # Store in the internal dictionary
-            if isinstance(value, dict):
-                value = DotDict(value)  # Convert dicts on the fly
+            if isinstance(value, dict) and not isinstance(value, DotDict):
+                value = DotDict(value)
             self._data[key] = value
 
     def __delattr__(self, key):
@@ -80,8 +80,8 @@ class DotDict:
 
     def __setitem__(self, key, value):
         # Called for obj[key] = value
-        if isinstance(value, dict):
-            value = DotDict(value)  # Convert dicts on the fly
+        if isinstance(value, dict) and not isinstance(value, DotDict):
+            value = DotDict(value)
         self._data[key] = value
 
     def __delitem__(self, key):
@@ -124,7 +124,9 @@ class DotDict:
 
         try:
             # Use the internal _data for representation
-            return json.dumps(self.to_dict(), indent=4, default=default_handler)
+            return json.dumps(
+                self.to_dict(), indent=4, default=default_handler
+            )
         except TypeError as e:
             # Fallback if default_handler still fails (e.g., complex recursion)
             return f"<DotDict object at {hex(id(self))}, contains: {list(self._data.keys())}> Error: {e}"
@@ -199,7 +201,9 @@ class DotDict:
         """
         # Mimic dict.pop behavior with optional default
         if len(args) > 1:
-            raise TypeError(f"pop expected at most 2 arguments, got {1 + len(args)}")
+            raise TypeError(
+                f"pop expected at most 2 arguments, got {1 + len(args)}"
+            )
         if key not in self._data:
             if args:
                 return args[0]  # Return default if provided
@@ -247,6 +251,60 @@ class DotDict:
         # Return a sorted list of the combined unique names
         return sorted(list(standard_attrs.union(data_keys)))
 
+    # --- Comparison Methods ---
+
+    def __eq__(self, other):
+        """Check equality. Supports comparison with dict, DotDict, and scalar values."""
+        if isinstance(other, DotDict):
+            return self._data == other._data
+        elif isinstance(other, dict):
+            return self._data == other
+        else:
+            # For scalar comparison, compare against empty/falsy
+            return False
+
+    def __ne__(self, other):
+        """Check inequality."""
+        return not self.__eq__(other)
+
+    def __lt__(self, other):
+        """Less than comparison - delegate to _data or handle scalars."""
+        if isinstance(other, (int, float)):
+            # If comparing to scalar, treat empty as 0
+            if len(self._data) == 0:
+                return 0 < other
+            # If single numeric value in total field, use it
+            if "total" in self._data and isinstance(self._data["total"], (int, float)):
+                return self._data["total"] < other
+            # Otherwise not comparable
+            return NotImplemented
+        return NotImplemented
+
+    def __le__(self, other):
+        """Less than or equal."""
+        return self.__lt__(other) or self.__eq__(other)
+
+    def __gt__(self, other):
+        """Greater than comparison - delegate to _data or handle scalars."""
+        if isinstance(other, (int, float)):
+            # If comparing to scalar, treat empty as 0
+            if len(self._data) == 0:
+                return 0 > other
+            # If single numeric value in total field, use it
+            if "total" in self._data and isinstance(self._data["total"], (int, float)):
+                return self._data["total"] > other
+            # Otherwise not comparable
+            return NotImplemented
+        return NotImplemented
+
+    def __ge__(self, other):
+        """Greater than or equal."""
+        return self.__gt__(other) or self.__eq__(other)
+
+    def __bool__(self):
+        """Truth value testing. Empty DotDict is False, non-empty is True."""
+        return len(self._data) > 0
+
 
 # Example Usage:
 if __name__ == "__main__":