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

scitex/gen/_get_notebook_path.py

@@ -14,18 +14,18 @@ import os
 import json
 from typing import Optional
 
-__all__ = ['get_notebook_path', 'get_notebook_name']
+__all__ = ["get_notebook_path", "get_notebook_name"]
 
 
 def get_notebook_path() -> Optional[str]:
     """
     Get the full path of the current Jupyter notebook.
-    
+
     Returns
     -------
     Optional[str]
         Full path to the notebook file, or None if not in a notebook
-        
+
     Examples
     --------
     >>> path = get_notebook_path()
@@ -35,54 +35,61 @@ def get_notebook_path() -> Optional[str]:
     try:
         # Try to get from IPython
         from IPython import get_ipython
+
         ip = get_ipython()
-        
+
         if not ip:
             return None
-            
+
         # Check if we're in a notebook
-        if type(ip).__name__ != 'ZMQInteractiveShell':
+        if type(ip).__name__ != "ZMQInteractiveShell":
             return None
-        
+
         # Try multiple methods to get the notebook path
-        
+
         # Method 1: From IPython's config
-        if hasattr(ip, 'config') and hasattr(ip.config, 'IPKernelApp'):
+        if hasattr(ip, "config") and hasattr(ip.config, "IPKernelApp"):
             connection_file = ip.config.IPKernelApp.connection_file
             if connection_file:
                 # Extract kernel ID from connection file
-                kernel_id = os.path.basename(connection_file).split('-', 1)[1].replace('.json', '')
-                
+                kernel_id = (
+                    os.path.basename(connection_file)
+                    .split("-", 1)[1]
+                    .replace(".json", "")
+                )
+
                 # Try to get notebook path from Jupyter server
                 notebook_path = _get_notebook_from_server(kernel_id)
                 if notebook_path:
                     return os.path.abspath(notebook_path)
-        
+
         # Method 2: From environment variable (JupyterLab sets this)
-        if 'JPY_SESSION_NAME' in os.environ:
-            session_name = os.environ['JPY_SESSION_NAME']
-            if session_name.endswith('.ipynb'):
+        if "JPY_SESSION_NAME" in os.environ:
+            session_name = os.environ["JPY_SESSION_NAME"]
+            if session_name.endswith(".ipynb"):
                 return os.path.abspath(session_name)
-        
+
         # Method 3: From notebook's metadata
         try:
             # This works in some notebook environments
             import ipykernel
             import notebook
             from notebook.notebookapp import list_running_servers
-            
+
             for server in list_running_servers():
-                response = _get_notebook_list(server['url'], server.get('token', ''))
+                response = _get_notebook_list(server["url"], server.get("token", ""))
                 if response:
                     for session in response:
-                        if session['kernel']['id'] == kernel_id:
-                            return os.path.join(server['notebook_dir'], session['notebook']['path'])
+                        if session["kernel"]["id"] == kernel_id:
+                            return os.path.join(
+                                server["notebook_dir"], session["notebook"]["path"]
+                            )
         except:
             pass
-            
+
     except Exception:
         pass
-    
+
     return None
 
 
@@ -91,25 +98,25 @@ def _get_notebook_from_server(kernel_id: str) -> Optional[str]:
     try:
         import requests
         from notebook.notebookapp import list_running_servers
-        
+
         for server in list_running_servers():
             url = f"{server['url']}api/sessions"
-            token = server.get('token', '')
-            
+            token = server.get("token", "")
+
             if token:
-                headers = {'Authorization': f'token {token}'}
+                headers = {"Authorization": f"token {token}"}
                 response = requests.get(url, headers=headers)
             else:
                 response = requests.get(url)
-                
+
             if response.status_code == 200:
                 sessions = response.json()
                 for session in sessions:
-                    if session['kernel']['id'] == kernel_id:
-                        return session['notebook']['path']
+                    if session["kernel"]["id"] == kernel_id:
+                        return session["notebook"]["path"]
     except:
         pass
-    
+
     return None
 
 
@@ -117,31 +124,32 @@ def _get_notebook_list(server_url: str, token: str) -> Optional[list]:
     """Get list of running notebooks from server."""
     try:
         import requests
+
         url = f"{server_url}api/sessions"
-        
+
         if token:
-            headers = {'Authorization': f'token {token}'}
+            headers = {"Authorization": f"token {token}"}
             response = requests.get(url, headers=headers)
         else:
             response = requests.get(url)
-            
+
         if response.status_code == 200:
             return response.json()
     except:
         pass
-    
+
     return None
 
 
 def get_notebook_name() -> Optional[str]:
     """
     Get just the name of the current notebook (without path).
-    
+
     Returns
     -------
     Optional[str]
         Notebook filename, or None if not in a notebook
-        
+
     Examples
     --------
     >>> name = get_notebook_name()
@@ -157,7 +165,7 @@ def get_notebook_name() -> Optional[str]:
 def get_notebook_directory() -> Optional[str]:
     """
     Get the directory containing the current notebook.
-    
+
     Returns
     -------
     Optional[str]
@@ -173,7 +181,7 @@ def get_notebook_directory() -> Optional[str]:
 def get_notebook_info_simple() -> tuple[Optional[str], Optional[str]]:
     """
     Simple method to get notebook info using current working directory.
-    
+
     Returns
     -------
     tuple[Optional[str], Optional[str]]
@@ -183,60 +191,71 @@ def get_notebook_info_simple() -> tuple[Optional[str], Optional[str]]:
         # In Jupyter, __file__ is not defined but we can use inspect
         import inspect
         import re
-        
+
         # Get the call stack and look for notebook indicators
         for frame_info in inspect.stack():
             filename = frame_info.filename
             if filename:
                 # Check for ipynb in the filename
-                if filename.endswith('.ipynb'):
-                    return os.path.basename(filename), os.path.dirname(os.path.abspath(filename))
-                
+                if filename.endswith(".ipynb"):
+                    return os.path.basename(filename), os.path.dirname(
+                        os.path.abspath(filename)
+                    )
+
                 # Look for notebook execution patterns in the filename
                 # Jupyter often uses patterns like <ipython-input-...> or kernel UUIDs
-                if '<ipython-input' in filename or 'ipykernel_' in filename:
+                if "<ipython-input" in filename or "ipykernel_" in filename:
                     # We're definitely in a notebook, need to find which one
                     break
-                    
+
         # If we can't find it in stack, check if we're in a notebook environment
         from IPython import get_ipython
+
         ip = get_ipython()
-        
-        if ip and type(ip).__name__ == 'ZMQInteractiveShell':
+
+        if ip and type(ip).__name__ == "ZMQInteractiveShell":
             # We're in a notebook but can't determine the name from stack
             # Try multiple strategies to find the notebook name
-            
+
             # Strategy 1: Check IPython's config for hints
-            if hasattr(ip, 'config') and hasattr(ip.config, 'IPKernelApp'):
-                if hasattr(ip.config.IPKernelApp, 'connection_file'):
+            if hasattr(ip, "config") and hasattr(ip.config, "IPKernelApp"):
+                if hasattr(ip.config.IPKernelApp, "connection_file"):
                     conn_file = ip.config.IPKernelApp.connection_file
                     # Sometimes the connection file path contains hints about the notebook
-                    if conn_file and '.ipynb' in conn_file:
-                        match = re.search(r'([^/]+)\.ipynb', conn_file)
+                    if conn_file and ".ipynb" in conn_file:
+                        match = re.search(r"([^/]+)\.ipynb", conn_file)
                         if match:
                             return match.group(0), os.getcwd()
-            
+
             # Strategy 2: Check environment variables
-            for env_var in ['JUPYTER_NOTEBOOK_NAME', 'JPY_SESSION_NAME', 'NOTEBOOK_NAME']:
+            for env_var in [
+                "JUPYTER_NOTEBOOK_NAME",
+                "JPY_SESSION_NAME",
+                "NOTEBOOK_NAME",
+            ]:
                 if env_var in os.environ:
                     notebook_name = os.environ[env_var]
-                    if notebook_name.endswith('.ipynb'):
+                    if notebook_name.endswith(".ipynb"):
                         return notebook_name, os.getcwd()
-            
+
             # Strategy 3: Look for recently modified .ipynb files in current directory
             cwd = os.getcwd()
             try:
                 # Get all .ipynb files with their modification times
                 notebook_files = []
                 for file in os.listdir(cwd):
-                    if file.endswith('.ipynb') and not file.startswith('.') and not file.endswith('_test_output.ipynb'):
+                    if (
+                        file.endswith(".ipynb")
+                        and not file.startswith(".")
+                        and not file.endswith("_test_output.ipynb")
+                    ):
                         file_path = os.path.join(cwd, file)
                         mtime = os.path.getmtime(file_path)
                         notebook_files.append((file, mtime))
-                
+
                 # Sort by modification time (most recent first)
                 notebook_files.sort(key=lambda x: x[1], reverse=True)
-                
+
                 if notebook_files:
                     # Return the most recently modified notebook
                     # This is a good heuristic as the currently running notebook
@@ -244,14 +263,14 @@ def get_notebook_info_simple() -> tuple[Optional[str], Optional[str]]:
                     return notebook_files[0][0], cwd
             except:
                 pass
-                    
+
             # If no notebook found, return generic name
             return "untitled.ipynb", cwd
-            
+
     except:
         pass
-        
+
     return None, None
 
 
-# EOF
+# EOF

scitex/gen/_inspect_module.py

@@ -235,7 +235,6 @@ def _print_module_contents(df: pd.DataFrame) -> None:
 
 
 if __name__ == "__main__":
-
     sys.setrecursionlimit(10_000)
     df = inspect_module(scitex, docstring=True, print_output=False, columns=["Name"])
     print(scitex.pd.round(df))

scitex/gen/_norm.py

@@ -81,7 +81,7 @@ def to_01(x, axis=-1, dim=None, device="cuda"):
     """
     # Use dim if provided, otherwise use axis
     dimension = dim if dim is not None else axis
-    
+
     if dimension is None:
         # Scale entire tensor
         x_min = x.min()
@@ -90,7 +90,7 @@ def to_01(x, axis=-1, dim=None, device="cuda"):
         # Scale along specified dimension
         x_min = x.min(dim=dimension, keepdim=True)[0]
         x_max = x.max(dim=dimension, keepdim=True)[0]
-    
+
     # Avoid division by zero
     return (x - x_min) / (x_max - x_min + 1e-8)
 
@@ -117,7 +117,7 @@ def to_nan01(x, axis=-1, dim=None, device="cuda"):
     """
     # Use dim if provided, otherwise use axis
     dimension = dim if dim is not None else axis
-    
+
     if dimension is None:
         # Scale entire tensor
         x_min = torch.nanmin(x)
@@ -126,7 +126,7 @@ def to_nan01(x, axis=-1, dim=None, device="cuda"):
         # Scale along specified dimension
         x_min = torch.nanmin(x, dim=dimension, keepdim=True)[0]
         x_max = torch.nanmax(x, dim=dimension, keepdim=True)[0]
-    
+
     # Avoid division by zero
     return (x - x_min) / (x_max - x_min + 1e-8)
 
@@ -161,7 +161,16 @@ def unbias(x, axis=-1, dim=None, fn="mean", device="cuda"):
 
 
 @torch_fn
-def clip_perc(x, lower_perc=2.5, upper_perc=97.5, low=None, high=None, axis=-1, dim=None, device="cuda"):
+def clip_perc(
+    x,
+    lower_perc=2.5,
+    upper_perc=97.5,
+    low=None,
+    high=None,
+    axis=-1,
+    dim=None,
+    device="cuda",
+):
     """Clips tensor values between specified percentiles along dimension.
 
     Parameters
@@ -193,10 +202,10 @@ def clip_perc(x, lower_perc=2.5, upper_perc=97.5, low=None, high=None, axis=-1,
         lower_perc = low
     if high is not None:
         upper_perc = high
-        
+
     # Use dim if provided, otherwise use axis
     dimension = dim if dim is not None else axis
-    
+
     lower = torch.quantile(x, lower_perc / 100, dim=dimension, keepdim=True)
     upper = torch.quantile(x, upper_perc / 100, dim=dimension, keepdim=True)
     return torch.clamp(x, min=lower, max=upper)

scitex/gen/_norm_cache.py

@@ -20,24 +20,22 @@ from scitex.decorators import torch_fn
 # Cache for normalized data
 _norm_cache = weakref.WeakValueDictionary()
 _cache_metadata = {}
-_cache_config = {
-    'enabled': True,
-    'max_size': 64,
-    'verbose': False
-}
+_cache_config = {"enabled": True, "max_size": 64, "verbose": False}
 
 
-def _get_array_key(x: Union[np.ndarray, torch.Tensor], axis: Optional[int] = None) -> str:
+def _get_array_key(
+    x: Union[np.ndarray, torch.Tensor], axis: Optional[int] = None
+) -> str:
     """
     Generate a unique key for an array based on its content and parameters.
-    
+
     Parameters
     ----------
     x : array-like
         Input array
     axis : int, optional
         Axis parameter
-        
+
     Returns
     -------
     str
@@ -49,7 +47,7 @@ def _get_array_key(x: Union[np.ndarray, torch.Tensor], axis: Optional[int] = Non
         props = f"torch_{x.shape}_{x.dtype}_{x.device}_{axis}"
         # Sample a few values for hash (avoid full array for performance)
         if x.numel() > 100:
-            sample = x.flatten()[::max(1, x.numel() // 100)][:100]
+            sample = x.flatten()[:: max(1, x.numel() // 100)][:100]
         else:
             sample = x.flatten()
         props += f"_{sample.sum().item():.6f}_{sample.std().item():.6f}"
@@ -57,74 +55,81 @@ def _get_array_key(x: Union[np.ndarray, torch.Tensor], axis: Optional[int] = Non
         # For numpy arrays
         props = f"numpy_{x.shape}_{x.dtype}_{axis}"
         if x.size > 100:
-            sample = x.flatten()[::max(1, x.size // 100)][:100]
+            sample = x.flatten()[:: max(1, x.size // 100)][:100]
         else:
             sample = x.flatten()
         props += f"_{np.sum(sample):.6f}_{np.std(sample):.6f}"
-    
+
     return hashlib.md5(props.encode()).hexdigest()
 
 
-def _check_cache(key: str, x: Union[np.ndarray, torch.Tensor]) -> Optional[Union[np.ndarray, torch.Tensor]]:
+def _check_cache(
+    key: str, x: Union[np.ndarray, torch.Tensor]
+) -> Optional[Union[np.ndarray, torch.Tensor]]:
     """Check if cached result exists and is valid."""
-    if not _cache_config['enabled']:
+    if not _cache_config["enabled"]:
         return None
-        
+
     if key in _cache_metadata:
         # Verify array hasn't changed by checking a few properties
         cached_info = _cache_metadata[key]
-        
+
         if isinstance(x, torch.Tensor):
             current_sum = x.sum().item()
             current_mean = x.mean().item()
         else:
             current_sum = np.sum(x)
             current_mean = np.mean(x)
-            
+
         # Check if values match (within floating point tolerance)
-        if (abs(cached_info['sum'] - current_sum) < 1e-10 and 
-            abs(cached_info['mean'] - current_mean) < 1e-10):
-            
+        if (
+            abs(cached_info["sum"] - current_sum) < 1e-10
+            and abs(cached_info["mean"] - current_mean) < 1e-10
+        ):
             # Try to get from weak reference cache
             if key in _norm_cache:
-                if _cache_config['verbose']:
+                if _cache_config["verbose"]:
                     print(f"[Norm Cache HIT] {cached_info['op']}")
                 return _norm_cache[key]
-                
+
     return None
 
 
-def _store_cache(key: str, x: Union[np.ndarray, torch.Tensor], 
-                result: Union[np.ndarray, torch.Tensor], op: str) -> None:
+def _store_cache(
+    key: str,
+    x: Union[np.ndarray, torch.Tensor],
+    result: Union[np.ndarray, torch.Tensor],
+    op: str,
+) -> None:
     """Store result in cache."""
-    if not _cache_config['enabled']:
+    if not _cache_config["enabled"]:
         return
-        
+
     # Store metadata
     if isinstance(x, torch.Tensor):
         _cache_metadata[key] = {
-            'sum': x.sum().item(),
-            'mean': x.mean().item(),
-            'shape': x.shape,
-            'op': op
+            "sum": x.sum().item(),
+            "mean": x.mean().item(),
+            "shape": x.shape,
+            "op": op,
         }
     else:
         _cache_metadata[key] = {
-            'sum': np.sum(x),
-            'mean': np.mean(x),
-            'shape': x.shape,
-            'op': op
+            "sum": np.sum(x),
+            "mean": np.mean(x),
+            "shape": x.shape,
+            "op": op,
         }
-    
+
     # Try to store in weak reference cache
     try:
         _norm_cache[key] = result
     except TypeError:
         # Some types can't be weakly referenced
         pass
-        
+
     # Implement size limit
-    if len(_cache_metadata) > _cache_config['max_size']:
+    if len(_cache_metadata) > _cache_config["max_size"]:
         # Remove oldest entries
         oldest = list(_cache_metadata.keys())[0]
         del _cache_metadata[oldest]
@@ -137,47 +142,51 @@ def _store_cache(key: str, x: Union[np.ndarray, torch.Tensor],
 def to_z_cached(x, axis=-1, dim=None, device="cuda"):
     """
     Cached version of z-score normalization.
-    
+
     Caches results for repeated normalizations of the same data.
     """
     # Generate cache key
     dimension = dim if dim is not None else axis
     cache_key = _get_array_key(x, dimension) + "_z"
-    
+
     # Check cache
     cached = _check_cache(cache_key, x)
     if cached is not None:
         return cached
-    
+
     # Compute normalization
     if isinstance(x, torch.Tensor):
-        result = (x - x.mean(dim=dimension, keepdim=True)) / x.std(dim=dimension, keepdim=True)
+        result = (x - x.mean(dim=dimension, keepdim=True)) / x.std(
+            dim=dimension, keepdim=True
+        )
     else:
-        result = (x - np.mean(x, axis=dimension, keepdims=True)) / np.std(x, axis=dimension, keepdims=True)
-    
+        result = (x - np.mean(x, axis=dimension, keepdims=True)) / np.std(
+            x, axis=dimension, keepdims=True
+        )
+
     # Store in cache
     _store_cache(cache_key, x, result, "z-score")
-    
+
     return result
 
 
 # Cached version of to_01
-@torch_fn  
+@torch_fn
 def to_01_cached(x, axis=-1, dim=None, device="cuda"):
     """
     Cached version of min-max normalization.
-    
+
     Caches results for repeated normalizations of the same data.
     """
     # Generate cache key
     dimension = dim if dim is not None else axis
     cache_key = _get_array_key(x, dimension) + "_01"
-    
+
     # Check cache
     cached = _check_cache(cache_key, x)
     if cached is not None:
         return cached
-    
+
     # Compute normalization
     if isinstance(x, torch.Tensor):
         if dimension is None:
@@ -195,19 +204,21 @@ def to_01_cached(x, axis=-1, dim=None, device="cuda"):
             x_min = np.min(x, axis=dimension, keepdims=True)
             x_max = np.max(x, axis=dimension, keepdims=True)
         result = (x - x_min) / (x_max - x_min + 1e-8)
-    
+
     # Store in cache
     _store_cache(cache_key, x, result, "min-max")
-    
+
     return result
 
 
-def configure_norm_cache(enabled: Optional[bool] = None,
-                        max_size: Optional[int] = None,
-                        verbose: Optional[bool] = None) -> None:
+def configure_norm_cache(
+    enabled: Optional[bool] = None,
+    max_size: Optional[int] = None,
+    verbose: Optional[bool] = None,
+) -> None:
     """
     Configure normalization cache settings.
-    
+
     Parameters
     ----------
     enabled : bool, optional
@@ -218,11 +229,11 @@ def configure_norm_cache(enabled: Optional[bool] = None,
         Enable verbose output
     """
     if enabled is not None:
-        _cache_config['enabled'] = enabled
+        _cache_config["enabled"] = enabled
     if max_size is not None:
-        _cache_config['max_size'] = max_size
+        _cache_config["max_size"] = max_size
     if verbose is not None:
-        _cache_config['verbose'] = verbose
+        _cache_config["verbose"] = verbose
 
 
 def clear_norm_cache() -> None:
@@ -234,10 +245,10 @@ def clear_norm_cache() -> None:
 def get_norm_cache_info() -> dict:
     """Get information about the normalization cache."""
     return {
-        'enabled': _cache_config['enabled'],
-        'max_size': _cache_config['max_size'],
-        'current_size': len(_cache_metadata),
-        'operations': [v['op'] for v in _cache_metadata.values()]
+        "enabled": _cache_config["enabled"],
+        "max_size": _cache_config["max_size"],
+        "current_size": len(_cache_metadata),
+        "operations": [v["op"] for v in _cache_metadata.values()],
     }
 
 
@@ -245,18 +256,19 @@ def get_norm_cache_info() -> dict:
 def patch_normalization_functions():
     """Replace original normalization functions with cached versions."""
     import scitex.gen._norm as norm_module
-    
+
     # Store originals
     norm_module.to_z_original = norm_module.to_z
     norm_module.to_01_original = norm_module.to_01
-    
+
     # Replace with cached versions
     norm_module.to_z = to_z_cached
     norm_module.to_01 = to_01_cached
-    
+
     # Also patch in the gen module namespace
     try:
         import scitex.gen as gen_module
+
         gen_module.to_z = to_z_cached
         gen_module.to_01 = to_01_cached
     except:
@@ -265,5 +277,6 @@ def patch_normalization_functions():
 
 # Auto-patch if enabled
 import os
-if os.getenv('SCITEX_CACHE_NORM', 'true').lower() == 'true':
-    patch_normalization_functions()
+
+if os.getenv("SCITEX_CACHE_NORM", "true").lower() == "true":
+    patch_normalization_functions()