scitex 2.16.1__py3-none-any.whl → 2.17.0__py3-none-any.whl

scitex/session/_lifecycle/_start.py

@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-02-01 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/session/_lifecycle/_start.py
+"""Session start function."""
+
+from __future__ import annotations
+
+import inspect
+import logging
+import os as _os
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple, Union
+
+from scitex.dict import DotDict
+from scitex.logging import getLogger
+from scitex.repro import RandomStateManager
+from scitex.str._clean_path import clean_path
+
+from .._manager import get_global_session_manager
+from ._config import setup_configs
+from ._matplotlib import setup_matplotlib
+from ._utils import (
+    clear_python_log_dir,
+    get_debug_mode,
+    initialize_env,
+    print_header,
+    simplify_relative_path,
+)
+
+logger = getLogger(__name__)
+
+# For development code flow analysis
+try:
+    from scitex.dev._analyze_code_flow import analyze_code_flow
+except ImportError:
+
+    def analyze_code_flow(file):
+        return "Code flow analysis not available"
+
+
+def start(
+    sys=None,
+    plt=None,
+    file: Optional[str] = None,
+    sdir: Optional[Union[str, Path]] = None,
+    sdir_suffix: Optional[str] = None,
+    args: Optional[Any] = None,
+    os: Optional[Any] = None,
+    random: Optional[Any] = None,
+    np: Optional[Any] = None,
+    torch: Optional[Any] = None,
+    seed: int = 42,
+    agg: bool = False,
+    fig_size_mm: Tuple[int, int] = (160, 100),
+    fig_scale: float = 1.0,
+    dpi_display: int = 100,
+    dpi_save: int = 300,
+    fontsize="small",
+    autolayout=True,
+    show_execution_flow=False,
+    hide_top_right_spines: bool = True,
+    alpha: float = 0.9,
+    line_width: float = 1.0,
+    clear_logs: bool = False,
+    verbose: bool = True,
+) -> Tuple[DotDict, Any, Any, Any, Optional[Dict[str, Any]], Any]:
+    """Initialize experiment session with reproducibility settings.
+
+    Parameters
+    ----------
+    sys : module, optional
+        Python sys module for I/O redirection
+    plt : module, optional
+        Matplotlib pyplot module for plotting configuration
+    file : str, optional
+        Script file path. If None, automatically detected
+    sdir : Union[str, Path], optional
+        Save directory path
+    sdir_suffix : str, optional
+        Suffix to append to save directory
+    args : object, optional
+        Command line arguments or configuration object
+    seed : int, default=42
+        Random seed for reproducibility
+    agg : bool, default=False
+        Whether to use matplotlib Agg backend
+    verbose : bool, default=True
+        Whether to print detailed information
+
+    Returns
+    -------
+    tuple
+        (CONFIGS, stdout, stderr, plt, COLORS, rng)
+    """
+    IS_DEBUG = get_debug_mode()
+    ID, PID = initialize_env(IS_DEBUG)
+
+    # Convert Path objects to strings for internal processing
+    if sdir is not None and isinstance(sdir, Path):
+        sdir = str(sdir)
+
+    # Defines SDIR
+    if sdir is None:
+        # Define __file__
+        if file:
+            caller_file = file
+        else:
+            caller_file = inspect.stack()[1].filename
+            if "ipython" in caller_file:
+                caller_file = f"/tmp/{_os.getenv('USER')}.py"
+
+        # Convert to absolute path if relative and resolve symlinks
+        if not _os.path.isabs(caller_file):
+            caller_file = _os.path.realpath(_os.path.abspath(caller_file))
+        else:
+            caller_file = _os.path.realpath(caller_file)
+
+        # Define sdir
+        sdir = clean_path(_os.path.splitext(caller_file)[0] + f"_out/RUNNING/{ID}/")
+
+        # Optional
+        if sdir_suffix:
+            sdir = sdir[:-1] + f"-{sdir_suffix}/"
+    else:
+        caller_file = file
+
+    if clear_logs and caller_file:
+        clear_python_log_dir(sdir + caller_file + "/")
+    _os.makedirs(sdir, exist_ok=True)
+    relative_sdir = simplify_relative_path(sdir)
+
+    # Setup configs - use caller_file (computed) instead of file (parameter)
+    CONFIGS = setup_configs(
+        IS_DEBUG, ID, PID, caller_file, sdir, relative_sdir, verbose
+    )
+
+    # Logging
+    if sys is not None:
+        from scitex.io._flush import flush
+        from scitex.logging._Tee import tee
+
+        flush(sys)
+        sys.stdout, sys.stderr = tee(sys, sdir=sdir, verbose=verbose)
+        CONFIGS["_sys"] = sys
+
+        # Redirect logging handlers to use the tee-wrapped streams
+        _redirect_logging_handlers(sys)
+
+    # Initialize RandomStateManager
+    rng = RandomStateManager(seed=seed, verbose=verbose)
+    if verbose:
+        logger.info(f"Initialized RandomStateManager with seed {seed}")
+
+    # Matplotlib configurations
+    plt, COLORS = setup_matplotlib(
+        plt,
+        agg,
+        fig_size_mm=fig_size_mm,
+        fig_scale=fig_scale,
+        dpi_display=dpi_display,
+        dpi_save=dpi_save,
+        hide_top_right_spines=hide_top_right_spines,
+        alpha=alpha,
+        line_width=line_width,
+        fontsize=fontsize,
+        autolayout=autolayout,
+        verbose=verbose,
+    )
+
+    # Adds argument-parsed variables
+    if args is not None:
+        CONFIGS["ARGS"] = vars(args) if hasattr(args, "__dict__") else args
+
+    CONFIGS = DotDict(CONFIGS)
+
+    # Register session
+    session_manager = get_global_session_manager()
+    session_manager.create_session(ID, CONFIGS)
+
+    print_header(ID, PID, caller_file, args, CONFIGS, verbose)
+
+    if show_execution_flow:
+        from scitex.str._printc import printc as _printc
+
+        structure = analyze_code_flow(caller_file)
+        _printc(structure)
+
+    # Start verification tracking
+    _start_verification(CONFIGS)
+
+    # Return appropriate values based on whether sys was provided
+    if sys is not None:
+        return CONFIGS, sys.stdout, sys.stderr, plt, COLORS, rng
+    else:
+        return CONFIGS, None, None, plt, COLORS, rng
+
+
+def _redirect_logging_handlers(sys) -> None:
+    """Redirect logging handlers to use tee-wrapped streams."""
+    # Update all existing StreamHandler instances
+    for logger_name in list(logging.Logger.manager.loggerDict.keys()):
+        try:
+            lgr = logging.getLogger(logger_name)
+            for handler in lgr.handlers:
+                if isinstance(handler, logging.StreamHandler):
+                    if not hasattr(handler, "stream"):
+                        continue
+                    if handler.stream in (sys.__stderr__, sys.__stdout__):
+                        handler.stream = (
+                            sys.stderr
+                            if handler.stream == sys.__stderr__
+                            else sys.stdout
+                        )
+        except Exception:
+            pass
+
+    # Also update the root logger handlers
+    try:
+        root_logger = logging.getLogger()
+        for handler in root_logger.handlers:
+            if isinstance(handler, logging.StreamHandler):
+                if not hasattr(handler, "stream"):
+                    continue
+                if handler.stream in (sys.__stderr__, sys.__stdout__):
+                    handler.stream = (
+                        sys.stderr if handler.stream == sys.__stderr__ else sys.stdout
+                    )
+    except Exception:
+        pass
+
+
+def _start_verification(CONFIG) -> None:
+    """Start verification tracking for this session."""
+    try:
+        from scitex.verify import on_session_start
+
+        session_id = CONFIG.get("ID", "unknown")
+        file_path = CONFIG.get("FILE")
+        if file_path is not None:
+            file_path = str(file_path)
+        on_session_start(session_id=session_id, script_path=file_path)
+    except Exception:
+        pass
+
+
+# EOF

scitex/session/_lifecycle/_utils.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+# Timestamp: "2026-02-01 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-python/src/scitex/session/_lifecycle/_utils.py
+"""Utility functions for session lifecycle."""
+
+from __future__ import annotations
+
+import os as _os
+import re
+from datetime import datetime
+from time import sleep
+from typing import Any, Dict, Tuple
+
+from scitex.logging import getLogger
+from scitex.repro._gen_ID import gen_ID
+from scitex.str._printc import printc as _printc
+
+logger = getLogger(__name__)
+
+
+def get_scitex_version() -> str:
+    """Gets scitex version."""
+    try:
+        import scitex
+
+        return scitex.__version__
+    except Exception as e:
+        print(e)
+        return "(not found)"
+
+
+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)
+            if IS_DEBUG == "true":
+                IS_DEBUG = True
+        else:
+            IS_DEBUG = False
+
+    except Exception as e:
+        print(e)
+        IS_DEBUG = False
+    return IS_DEBUG
+
+
+def initialize_env(IS_DEBUG: bool) -> Tuple[str, int]:
+    """Initialize environment with ID and PID.
+
+    Parameters
+    ----------
+    IS_DEBUG : bool
+        Debug mode flag
+
+    Returns
+    -------
+    tuple
+        (ID, PID) - Unique identifier and Process ID
+    """
+    ID = gen_ID(N=4) if not IS_DEBUG else "DEBUG_" + gen_ID(N=4)
+    PID = _os.getpid()
+    return ID, PID
+
+
+def simplify_relative_path(sdir: str) -> str:
+    """Simplify the relative path by removing specific patterns.
+
+    Parameters
+    ----------
+    sdir : str
+        The directory path to simplify
+
+    Returns
+    -------
+    str
+        Simplified relative path
+    """
+    base_path = _os.getcwd()
+    relative_sdir = _os.path.relpath(sdir, base_path) if base_path else sdir
+    simplified_path = relative_sdir.replace("scripts/", "./scripts/").replace(
+        "RUNNING/", ""
+    )
+    # Remove date-time pattern and random string
+    simplified_path = re.sub(
+        r"\d{4}Y-\d{2}M-\d{2}D-\d{2}h\d{2}m\d{2}s_\w+/?$", "", simplified_path
+    )
+    return simplified_path
+
+
+def clear_python_log_dir(log_dir: str) -> None:
+    """Clear Python log directory."""
+    try:
+        if _os.path.exists(log_dir):
+            _os.system(f"rm -rf {log_dir}")
+    except Exception as e:
+        print(f"Failed to clear directory {log_dir}: {e}")
+
+
+def print_header(
+    ID: str,
+    PID: int,
+    file: str,
+    args: Any,
+    configs: Dict[str, Any],
+    verbose: bool = True,
+) -> None:
+    """Prints formatted header with scitex version, ID, and PID information."""
+    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}"
+    else:
+        args_str = "Arguments: None"
+
+    _printc(
+        (f"SciTeX v{get_scitex_version()} | {ID} (PID: {PID})\n\n{file}\n\n{args_str}"),
+        char="=",
+    )
+
+    sleep(1)
+    if verbose:
+        from pprint import pformat
+
+        config_str = pformat(configs.to_dict())
+        logger.info(f"\n{'-' * 40}\n\n{config_str}\n\n{'-' * 40}\n")
+    sleep(1)
+
+
+def format_diff_time(diff_time) -> str:
+    """Format time difference as HH:MM:SS."""
+    total_seconds = int(diff_time.total_seconds())
+    hours = total_seconds // 3600
+    minutes = (total_seconds % 3600) // 60
+    seconds = total_seconds % 60
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+
+def process_timestamp(CONFIG, verbose=True):
+    """Process session timestamps."""
+    try:
+        CONFIG["END_DATETIME"] = datetime.now()
+        CONFIG["RUN_DURATION"] = format_diff_time(
+            CONFIG["END_DATETIME"] - CONFIG["START_DATETIME"]
+        )
+        if verbose:
+            logger.info(
+                f"\nSTART TIME: {CONFIG['START_DATETIME']}\n"
+                f"END TIME: {CONFIG['END_DATETIME']}\n"
+                f"RUN DURATION: {CONFIG['RUN_DURATION']}\n"
+            )
+
+    except Exception as e:
+        print(e)
+
+    return CONFIG
+
+
+def args_to_str(args_dict) -> str:
+    """Convert args dictionary to formatted string."""
+    if args_dict:
+        max_key_length = max(len(str(k)) for k in args_dict.keys())
+        return "\n".join(
+            f"{str(k):<{max_key_length}} : {str(v)}"
+            for k, v in sorted(args_dict.items())
+        )
+    else:
+        return ""
+
+
+def escape_ansi_from_log_files(log_files) -> None:
+    """Remove ANSI escape sequences from log files."""
+    ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+    for f in log_files:
+        with open(f, encoding="utf-8") as file:
+            content = file.read()
+        cleaned_content = ansi_escape.sub("", content)
+        with open(f, "w", encoding="utf-8") as file:
+            file.write(cleaned_content)
+
+
+# EOF

scitex/session/_manager.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-08-21 20:36:50 (ywatanabe)"
 # File: /home/ywatanabe/proj/SciTeX-Code/src/scitex/session/_manager.py
 # ----------------------------------------
 from __future__ import annotations
+
 import os
 
 __FILE__ = __file__
@@ -22,7 +22,12 @@ class SessionManager:
     def __init__(self):
         self.active_sessions = {}
 
-    def create_session(self, session_id: str, config: Dict[str, Any]) -> None:
+    def create_session(
+        self,
+        session_id: str,
+        config: Dict[str, Any],
+        script_path: str = None,
+    ) -> None:
         """Register a new session.
 
         Parameters
@@ -31,24 +36,56 @@ class SessionManager:
             Unique identifier for the session
         config : Dict[str, Any]
             Session configuration dictionary
+        script_path : str, optional
+            Path to the script being run
         """
         self.active_sessions[session_id] = {
             "config": config,
             "start_time": datetime.now(),
             "status": "running",
+            "script_path": script_path,
         }
 
-    def close_session(self, session_id: str) -> None:
+        # Start verification tracking (silent fail)
+        try:
+            from scitex.verify import on_session_start
+
+            on_session_start(
+                session_id=session_id,
+                script_path=script_path,
+            )
+        except Exception:
+            pass
+
+    def close_session(
+        self,
+        session_id: str,
+        status: str = "success",
+        exit_code: int = 0,
+    ) -> None:
         """Mark a session as closed.
 
         Parameters
         ----------
         session_id : str
             Unique identifier for the session to close
+        status : str, optional
+            Final status (success, failed, error)
+        exit_code : int, optional
+            Exit code of the session
         """
         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]["exit_code"] = exit_code
+
+        # Stop verification tracking (silent fail)
+        try:
+            from scitex.verify import on_session_close
+
+            on_session_close(status=status, exit_code=exit_code)
+        except Exception:
+            pass
 
     def get_active_sessions(self) -> Dict[str, Any]:
         """Get all active sessions.

scitex/session/template.py

@@ -16,7 +16,7 @@ def main(
     CONFIG=INJECTED,
     plt=INJECTED,
     COLORS=INJECTED,
-    rng=INJECTED,
+    rngg=scitex.INJECTED,
     logger=INJECTED,
 ):
     """Demonstration for scitex.session.session"""

scitex/template/_templates/plt.py

@@ -74,7 +74,7 @@ def main(
     CONFIG=stx.INJECTED,   # Session config
     plt=stx.INJECTED,      # Pre-configured matplotlib
     COLORS=stx.INJECTED,   # Color palette
-    rng=stx.INJECTED,      # Random generator
+    rngg=stx.INJECTED,      # Random generator
     logger=stx.INJECTED,   # Logger
 ):
     """Example plotting with session management."""

scitex/template/_templates/session.py

@@ -91,7 +91,7 @@ def main(
     CONFIG=stx.INJECTED,           # Auto-injected from ./config/*.yaml
     plt=stx.INJECTED,              # Pre-configured matplotlib
     COLORS=stx.INJECTED,           # Color palette
-    rng=stx.INJECTED,              # Random number generator
+    rngg=stx.INJECTED,              # Random number generator
     logger=stx.INJECTED,           # Session logger
 ):
     """