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

scitex/session/_decorator.py

@@ -105,7 +105,6 @@ def session(
     """
 
     def decorator(func: Callable) -> Callable:
-
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
             # If called with arguments (not CLI), run directly
@@ -150,17 +149,16 @@ def _run_with_session(
     # Get calling file
     frame = inspect.currentframe()
     caller_frame = frame.f_back.f_back  # Go up two levels
-    caller_file = caller_frame.f_globals.get('__file__', 'unknown.py')
+    caller_file = caller_frame.f_globals.get("__file__", "unknown.py")
 
     # Generate argparse from function signature
     parser = _create_parser(func)
     args = parser.parse_args()
 
     # Clean up INJECTED sentinels from args before passing to session
-    cleaned_args = argparse.Namespace(**{
-        k: v for k, v in vars(args).items()
-        if not isinstance(v, type(INJECTED))
-    })
+    cleaned_args = argparse.Namespace(
+        **{k: v for k, v in vars(args).items() if not isinstance(v, type(INJECTED))}
+    )
 
     # Start session
     import matplotlib.pyplot as plt
@@ -181,11 +179,11 @@ def _run_with_session(
 
     # Store session variables in function globals
     func_globals = func.__globals__
-    func_globals['CONFIG'] = CONFIG
-    func_globals['plt'] = plt
-    func_globals['COLORS'] = COLORS
-    func_globals['rng_manager'] = rng_manager
-    func_globals['logger'] = script_logger
+    func_globals["CONFIG"] = CONFIG
+    func_globals["plt"] = plt
+    func_globals["COLORS"] = COLORS
+    func_globals["rng_manager"] = rng_manager
+    func_globals["logger"] = script_logger
 
     # Log injected globals for user awareness
     _decorator_logger.info("=" * 60)
@@ -214,11 +212,11 @@ def _run_with_session(
 
         # Map of injected variable names to their actual objects
         injection_map = {
-            'CONFIG': CONFIG,
-            'plt': plt,
-            'COLORS': COLORS,
-            'rng_manager': rng_manager,
-            'logger': script_logger,
+            "CONFIG": CONFIG,
+            "plt": plt,
+            "COLORS": COLORS,
+            "rng_manager": rng_manager,
+            "logger": script_logger,
         }
 
         # Build filtered_kwargs with user args and injected values
@@ -282,7 +280,8 @@ def _run_with_session(
         # Final matplotlib cleanup (belt and suspenders approach)
         try:
             import matplotlib.pyplot as plt
-            plt.close('all')
+
+            plt.close("all")
         except:
             pass
 
@@ -311,12 +310,13 @@ def _create_parser(func: Callable) -> argparse.ArgumentParser:
 
     # Get actual values for deterministic items
     # Get calling file from the decorated function's module
-    caller_file = func.__globals__.get('__file__', 'unknown.py')
+    caller_file = func.__globals__.get("__file__", "unknown.py")
 
     # Calculate SDIR_OUT (base output directory)
     import os
-    sdir_out = Path(os.path.splitext(caller_file)[0] + '_out')
-    sdir_run_example = sdir_out / 'RUNNING' / '<SESSION_ID>'
+
+    sdir_out = Path(os.path.splitext(caller_file)[0] + "_out")
+    sdir_run_example = sdir_out / "RUNNING" / "<SESSION_ID>"
 
     # Get current PID
     current_pid = os.getpid()
@@ -333,9 +333,10 @@ def _create_parser(func: Callable) -> argparse.ArgumentParser:
                 # Load and list all config variables with their values
                 try:
                     import yaml
+
                     all_vars = []
                     for yaml_file in yaml_files:
-                        with open(yaml_file, 'r') as f:
+                        with open(yaml_file, "r") as f:
                             data = yaml.safe_load(f)
                             if isinstance(data, dict):
                                 namespace = yaml_file.stem.upper()
@@ -344,30 +345,37 @@ def _create_parser(func: Callable) -> argparse.ArgumentParser:
                                     value_str = str(value)
                                     if len(value_str) > 50:
                                         value_str = value_str[:47] + "..."
-                                    all_vars.append(f"        - CONFIG.{namespace}.{key} (from ./config/{yaml_file.name})\n            {value_str}")
+                                    all_vars.append(
+                                        f"        - CONFIG.{namespace}.{key} (from ./config/{yaml_file.name})\n            {value_str}"
+                                    )
 
                     if all_vars:
-                        config_status += '\n'.join(all_vars)
+                        config_status += "\n".join(all_vars)
                     else:
                         config_status = "        CONFIG from YAML files:\n        (no variables found)"
                 except Exception as e:
                     # If we can't load the YAML files, just show error
                     config_status = "        CONFIG from YAML files:\n        (unable to load at help-time, will be available at runtime)"
             else:
-                config_status = "        CONFIG from YAML files:\n        (no .yaml files found)"
+                config_status = (
+                    "        CONFIG from YAML files:\n        (no .yaml files found)"
+                )
         else:
             config_status = "        CONFIG from YAML files:\n        (./config/ directory not found)"
     except:
-        config_status = "        CONFIG from YAML files:\n        (unable to check at help-time)"
+        config_status = (
+            "        CONFIG from YAML files:\n        (unable to check at help-time)"
+        )
 
     # Get available color keys
     try:
         from scitex.plt.utils._configure_mpl import configure_mpl
         import matplotlib.pyplot as plt_temp
+
         _, colors_dict = configure_mpl(plt_temp)
         # Show all color keys
         sorted_keys = sorted(colors_dict.keys())
-        color_keys = ', '.join(f"'{k}'" for k in sorted_keys)
+        color_keys = ", ".join(f"'{k}'" for k in sorted_keys)
     except Exception as e:
         # Fallback if configure_mpl fails
         color_keys = "'blue', 'red', 'green', 'yellow', 'purple', 'orange', ..."
@@ -424,7 +432,7 @@ Global Variables Injected by @session Decorator:
 
     # Add arguments from function signature (skip injected parameters)
     # Track used short forms to avoid conflicts
-    used_short_forms = {'h'}  # Reserve -h for help
+    used_short_forms = {"h"}  # Reserve -h for help
 
     for param_name, param in sig.parameters.items():
         # Skip parameters with INJECTED as default (these are injected by decorator)
@@ -458,9 +466,9 @@ def _generate_short_form(param_name: str, used_short_forms: set) -> str:
         return first_letter
 
     # Strategy 2: Try first letter of each word (for snake_case or camelCase)
-    words = param_name.replace('_', ' ').replace('-', ' ').split()
+    words = param_name.replace("_", " ").replace("-", " ").split()
     if len(words) > 1:
-        acronym = ''.join(w[0].lower() for w in words)
+        acronym = "".join(w[0].lower() for w in words)
         if len(acronym) == 1 and acronym not in used_short_forms:
             return acronym
 
@@ -526,7 +534,7 @@ def _add_argument(
         # Boolean flags
         parser.add_argument(
             *arg_names,
-            action='store_true' if not default else 'store_false',
+            action="store_true" if not default else "store_false",
             default=default,
             help=f"(default: {default})",
         )
@@ -534,26 +542,24 @@ def _add_argument(
         # Regular arguments
         choices_str = f", choices: {choices}" if choices else ""
         kwargs = {
-            'type': param_type,
-            'help': f"(default: {default}{choices_str})" if has_default else f"(required{choices_str})",
+            "type": param_type,
+            "help": f"(default: {default}{choices_str})"
+            if has_default
+            else f"(required{choices_str})",
         }
 
         if choices:
-            kwargs['choices'] = choices
+            kwargs["choices"] = choices
 
         if has_default:
-            kwargs['default'] = default
+            kwargs["default"] = default
         else:
-            kwargs['required'] = True
+            kwargs["required"] = True
 
         parser.add_argument(*arg_names, **kwargs)
 
 
-def run(
-    func: Callable,
-    parse_args: Callable = None,
-    **session_kwargs
-) -> Any:
+def run(func: Callable, parse_args: Callable = None, **session_kwargs) -> Any:
     """Run function with session management.
 
     Alternative to decorator for more explicit control.
@@ -583,7 +589,7 @@ def run(
     # Get file
     frame = inspect.currentframe()
     caller_frame = frame.f_back
-    caller_file = caller_frame.f_globals.get('__file__', 'unknown.py')
+    caller_file = caller_frame.f_globals.get("__file__", "unknown.py")
 
     # Start session
     import matplotlib.pyplot as plt
@@ -598,7 +604,7 @@ def run(
 
     # Run
     try:
-        if hasattr(args, '__dict__'):
+        if hasattr(args, "__dict__"):
             exit_status = func(args)
         else:
             exit_status = func()
@@ -619,4 +625,5 @@ def run(
 
     return exit_status
 
+
 # EOF

scitex/session/_lifecycle.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/session/_lifecycle.py"
-)
+
+__FILE__ = "./src/scitex/session/_lifecycle.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -48,18 +47,20 @@ import platform
 is_headless = False
 try:
     # Check for WSL
-    if 'microsoft' in platform.uname().release.lower() or 'WSL' in os.environ.get('WSL_DISTRO_NAME', ''):
+    if "microsoft" in platform.uname().release.lower() or "WSL" in os.environ.get(
+        "WSL_DISTRO_NAME", ""
+    ):
         is_headless = True
     # Check for no X11 display
-    elif not os.environ.get('DISPLAY'):
+    elif not os.environ.get("DISPLAY"):
         is_headless = True
 except Exception:
     # Fallback: if on Linux without DISPLAY, assume headless
-    if sys.platform.startswith('linux') and not os.environ.get('DISPLAY'):
+    if sys.platform.startswith("linux") and not os.environ.get("DISPLAY"):
         is_headless = True
 
 if is_headless:
-    matplotlib.use('Agg')
+    matplotlib.use("Agg")
 
 import matplotlib.pyplot as plt_module
 
@@ -113,7 +114,7 @@ def _print_header(
         Whether to print detailed information, by default True
     """
 
-    if args is not None and hasattr(args, '_get_kwargs'):
+    if args is not None and hasattr(args, "_get_kwargs"):
         args_str = "Arguments:"
         for arg, value in args._get_kwargs():
             args_str += f"\n    {arg}: {value}"
@@ -133,9 +134,9 @@ def _print_header(
 
     sleep(1)
     if verbose:
-        print(f"\n{'-'*40}\n")
+        print(f"\n{'-' * 40}\n")
         pprint(configs.to_dict())
-        print(f"\n{'-'*40}\n")
+        print(f"\n{'-' * 40}\n")
     sleep(1)
 
 
@@ -196,8 +197,8 @@ def _setup_configs(
     if sdir_path:
         # Remove /RUNNING/ID/ to get base output dir
         parts = sdir_path.parts
-        if 'RUNNING' in parts:
-            running_idx = parts.index('RUNNING')
+        if "RUNNING" in parts:
+            running_idx = parts.index("RUNNING")
             sdir_out = Path(*parts[:running_idx])
         else:
             sdir_out = sdir_path.parent
@@ -206,17 +207,20 @@ def _setup_configs(
 
     # Load YAML configs from ./config/*.yaml
     from scitex.io._load_configs import load_configs
+
     CONFIGS = load_configs(IS_DEBUG).to_dict()
 
     # Add session-specific config with clean structure (Path objects only)
-    CONFIGS.update({
-        "ID": ID,
-        "PID": PID,
-        "START_DATETIME": datetime.now(),
-        "FILE": Path(file) if file else None,
-        "SDIR_OUT": sdir_out,
-        "SDIR_RUN": sdir_path,
-    })
+    CONFIGS.update(
+        {
+            "ID": ID,
+            "PID": PID,
+            "START_DATETIME": datetime.now(),
+            "FILE": Path(file) if file else None,
+            "SDIR_OUT": sdir_out,
+            "SDIR_RUN": sdir_path,
+        }
+    )
     return CONFIGS
 
 
@@ -298,6 +302,7 @@ def _get_debug_mode() -> bool:
     """Get debug mode from configuration."""
     try:
         from scitex.io._load import load
+
         IS_DEBUG_PATH = "./config/IS_DEBUG.yaml"
         if _os.path.exists(IS_DEBUG_PATH):
             IS_DEBUG = load(IS_DEBUG_PATH).get("IS_DEBUG", False)
@@ -442,9 +447,7 @@ def start(
             caller_file = _os.path.realpath(caller_file)
 
         # Define sdir
-        sdir = clean_path(
-            _os.path.splitext(caller_file)[0] + f"_out/RUNNING/{ID}/"
-        )
+        sdir = clean_path(_os.path.splitext(caller_file)[0] + f"_out/RUNNING/{ID}/")
 
         # Optional
         if sdir_suffix:
@@ -457,13 +460,12 @@ def start(
     ########################################
 
     # Setup configs after having all necessary parameters
-    CONFIGS = _setup_configs(
-        IS_DEBUG, ID, PID, file, sdir, relative_sdir, verbose
-    )
+    CONFIGS = _setup_configs(IS_DEBUG, ID, PID, file, sdir, relative_sdir, verbose)
 
     # Logging
     if sys is not None:
         from scitex.io._flush import flush
+
         flush(sys)
         # Lazy import to avoid circular dependency
         from scitex.logging._Tee import tee
@@ -594,7 +596,9 @@ def _save_configs(CONFIG):
     from scitex.io._save import save as scitex_io_save
 
     # Convert to dict with all keys (including private ones) for saving
-    config_dict = CONFIG.to_dict(include_private=True) if hasattr(CONFIG, 'to_dict') else CONFIG
+    config_dict = (
+        CONFIG.to_dict(include_private=True) if hasattr(CONFIG, "to_dict") else CONFIG
+    )
 
     scitex_io_save(
         config_dict, str(CONFIG["SDIR_RUN"] / "CONFIGS/CONFIG.pkl"), verbose=False
@@ -635,9 +639,7 @@ def _args_to_str(args_dict):
         return ""
 
 
-def running2finished(
-    CONFIG, exit_status=None, remove_src_dir=True, max_wait=60
-):
+def running2finished(CONFIG, exit_status=None, remove_src_dir=True, max_wait=60):
     """Move session from RUNNING to FINISHED directory.
 
     Parameters
@@ -666,7 +668,6 @@ def running2finished(
     src_dir = str(CONFIG["SDIR_RUN"])
     _os.makedirs(dest_dir, exist_ok=True)
     try:
-
         # Copy files individually
         for item in _os.listdir(src_dir):
             s = _os.path.join(src_dir, item)
@@ -677,13 +678,9 @@ def running2finished(
                 shutil.copy2(s, d)
 
         start_time = time.time()
-        while (
-            not _os.path.exists(dest_dir)
-            and time.time() - start_time < max_wait
-        ):
+        while not _os.path.exists(dest_dir) and time.time() - start_time < max_wait:
             time.sleep(0.1)
         if _os.path.exists(dest_dir):
-
             print()
             logger.success(
                 f"Congratulations! The script completed: {dest_dir}",
@@ -743,7 +740,7 @@ def close(CONFIG, message=":)", notify=False, verbose=True, exit_status=None):
             import atexit
 
             # Close all figures
-            plt.close('all')
+            plt.close("all")
 
             # CRITICAL: Unregister matplotlib's atexit handlers to prevent segfault
             # Matplotlib registers handlers that try to cleanup on exit,
@@ -751,12 +748,13 @@ def close(CONFIG, message=":)", notify=False, verbose=True, exit_status=None):
             try:
                 # Remove matplotlib-related atexit handlers
                 import weakref
+
                 # Matplotlib uses weakref for some cleanup
-                if hasattr(matplotlib, '_pylab_helpers'):
+                if hasattr(matplotlib, "_pylab_helpers"):
                     matplotlib._pylab_helpers.Gcf.destroy_all()
 
                 # Clear any pyplot state
-                if hasattr(plt, 'get_fignums'):
+                if hasattr(plt, "get_fignums"):
                     for fignum in plt.get_fignums():
                         plt.close(fignum)
 
@@ -765,6 +763,7 @@ def close(CONFIG, message=":)", notify=False, verbose=True, exit_status=None):
 
             # Force garbage collection to cleanup matplotlib resources
             import gc
+
             gc.collect()
 
             if verbose:
@@ -826,4 +825,5 @@ def close(CONFIG, message=":)", notify=False, verbose=True, exit_status=None):
                 # Silent fail to ensure logs are saved even if there's an error
                 pass
 
+
 # EOF

scitex/session/_manager.py

@@ -5,6 +5,7 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
@@ -17,13 +18,13 @@ from typing import Any, Dict
 
 class SessionManager:
     """Manages experiment sessions with tracking and lifecycle management."""
-    
+
     def __init__(self):
         self.active_sessions = {}
-    
+
     def create_session(self, session_id: str, config: Dict[str, Any]) -> None:
         """Register a new session.
-        
+
         Parameters
         ----------
         session_id : str
@@ -32,51 +33,53 @@ class SessionManager:
             Session configuration dictionary
         """
         self.active_sessions[session_id] = {
-            'config': config,
-            'start_time': datetime.now(),
-            'status': 'running'
+            "config": config,
+            "start_time": datetime.now(),
+            "status": "running",
         }
-    
+
     def close_session(self, session_id: str) -> None:
         """Mark a session as closed.
-        
+
         Parameters
         ----------
         session_id : str
             Unique identifier for the session to close
         """
         if session_id in self.active_sessions:
-            self.active_sessions[session_id]['status'] = 'closed'
-            self.active_sessions[session_id]['end_time'] = datetime.now()
-    
+            self.active_sessions[session_id]["status"] = "closed"
+            self.active_sessions[session_id]["end_time"] = datetime.now()
+
     def get_active_sessions(self) -> Dict[str, Any]:
         """Get all active sessions.
-        
+
         Returns
         -------
         Dict[str, Any]
             Dictionary of active session information
         """
-        return {k: v for k, v in self.active_sessions.items() if v['status'] == 'running'}
-    
+        return {
+            k: v for k, v in self.active_sessions.items() if v["status"] == "running"
+        }
+
     def get_session(self, session_id: str) -> Dict[str, Any]:
         """Get specific session information.
-        
+
         Parameters
         ----------
         session_id : str
             Session ID to retrieve
-            
+
         Returns
         -------
         Dict[str, Any]
             Session information dictionary
         """
         return self.active_sessions.get(session_id, {})
-    
+
     def list_sessions(self) -> Dict[str, Any]:
         """Get all sessions (active and closed).
-        
+
         Returns
         -------
         Dict[str, Any]
@@ -91,7 +94,7 @@ _session_manager = SessionManager()
 
 def get_global_session_manager() -> SessionManager:
     """Get the global session manager instance.
-    
+
     Returns
     -------
     SessionManager
@@ -99,4 +102,5 @@ def get_global_session_manager() -> SessionManager:
     """
     return _session_manager
 
-# EOF
+
+# EOF

scitex/sh/__init__.py

@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 from __future__ import annotations
 import os
+
 __FILE__ = __file__
 __DIR__ = os.path.dirname(__FILE__)
 
@@ -17,7 +18,7 @@ def sh(
     verbose: bool = True,
     return_as: ReturnFormat = "dict",
     timeout: int = None,
-    stream_output: bool = False
+    stream_output: bool = False,
 ) -> Union[str, ShellResult]:
     """
     Executes a shell command safely (list format only).
@@ -54,7 +55,7 @@ def sh(
         command_str_or_list,
         verbose=verbose,
         timeout=timeout,
-        stream_output=stream_output
+        stream_output=stream_output,
     )
 
     if return_as == "dict":
@@ -87,6 +88,6 @@ def sh_run(command: CommandInput, verbose: bool = True) -> ShellResult:
     return execute(command, verbose=verbose)
 
 
-__all__ = ['sh', 'sh_run', 'quote']
+__all__ = ["sh", "sh_run", "quote"]
 
 # EOF

scitex/sh/_execute.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/sh/_execute.py"
-)
+
+__FILE__ = "./src/scitex/sh/_execute.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -28,7 +27,7 @@ def execute(
     command_str_or_list: CommandInput,
     verbose: bool = True,
     timeout: int = None,
-    stream_output: bool = False
+    stream_output: bool = False,
 ) -> ShellResult:
     """
     Executes a shell command safely (list format only).
@@ -84,7 +83,7 @@ def _execute_buffered(
         process.kill()
         stdout_bytes, stderr_bytes = process.communicate()
         timeout_msg = f"Command timed out after {timeout} seconds"
-        stderr_bytes = (stderr_bytes + b"\n" + timeout_msg.encode("utf-8"))
+        stderr_bytes = stderr_bytes + b"\n" + timeout_msg.encode("utf-8")
 
     stdout = stdout_bytes.decode("utf-8").strip()
     stderr = stderr_bytes.decode("utf-8").strip()
@@ -114,7 +113,7 @@ def _execute_with_streaming(
 
     # Set PYTHONUNBUFFERED for Python scripts and unbuffered mode for shell
     env = os.environ.copy()
-    env['PYTHONUNBUFFERED'] = '1'
+    env["PYTHONUNBUFFERED"] = "1"
 
     process = subprocess.Popen(
         command_str_or_list,
@@ -131,6 +130,7 @@ def _execute_with_streaming(
 
     # Use non-blocking reads
     import fcntl
+
     def make_non_blocking(fd):
         flags = fcntl.fcntl(fd, fcntl.F_GETFL)
         fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
@@ -193,7 +193,9 @@ def _execute_with_streaming(
                         stderr_data.append(chunk)
                         if verbose:
                             text = chunk.decode("utf-8", errors="replace")
-                            print(scitex.str.color_text(text, "red"), end="", flush=True)
+                            print(
+                                scitex.str.color_text(text, "red"), end="", flush=True
+                            )
                 except (IOError, BlockingIOError):
                     pass
                 break
@@ -218,4 +220,5 @@ def _execute_with_streaming(
 
     return result
 
+
 # EOF

scitex/sh/_security.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/sh/_security.py"
-)
+
+__FILE__ = "./src/scitex/sh/_security.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
@@ -64,4 +63,5 @@ def quote(arg: str) -> str:
     """
     return shlex.quote(arg)
 
+
 # EOF

scitex/sh/_types.py

@@ -5,9 +5,8 @@
 # ----------------------------------------
 from __future__ import annotations
 import os
-__FILE__ = (
-    "./src/scitex/sh/_types.py"
-)
+
+__FILE__ = "./src/scitex/sh/_types.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------