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

scitex/{gen/_tee.py → logging/_Tee.py}

@@ -1,7 +1,15 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-02-15 00:02:15 (ywatanabe)"
-# File: ./src/scitex/gen/_tee.py
+# Timestamp: "2025-10-13 07:12:49 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/logging/_Tee.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = (
+    "./src/scitex/logging/_Tee.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
 
 THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/gen/_tee.py"
 
@@ -25,60 +33,31 @@ Prerequisites:
 import os as _os
 import re
 import sys
-from typing import Any, List, TextIO
+from typing import Any, TextIO
 
 from ..str._clean_path import clean_path
-from ..path import split
 from ..str._printc import printc
 
 """Functions & Classes"""
-# class Tee(object):
-#     """Duplicates output streams to both console and log files.
-
-#     Example
-#     -------
-#     >>> import sys
-#     >>> sys.stdout = Tee(sys.stdout, "stdout.txt")
-#     >>> sys.stderr = Tee(sys.stderr, "stderr.txt")
-#     >>> print("Hello")  # Outputs to both console and stdout.txt
-#     >>> raise Exception("Error")  # Outputs to both console and stderr.txt
-#     """
-
-#     def __init__(self, sys_stdout_or_stderr, spath):
-#         """
-#         Parameters
-#         ----------
-#         stream : TextIO
-#             Original output stream (sys.stdout or sys.stderr)
-#         log_path : str
-#             Path to log file
-#         """
-#         self._files = [sys_stdout_or_stderr, open(spath, "w")]
-#         self._is_stderr = sys_stdout_or_stderr is sys.stderr
-
-#     def __getattr__(self, attr, *args):
-#         return self._wrap(attr, *args)
-
-#     def _wrap(self, attr, *args):
-#         def g(*a, **kw):
-#             for f in self._files:
-#                 if self._is_stderr and f is not sys.stderr:
-#                     # Filter tqdm lines from log file
-#                     msg = a[0] if a else ""
-#                     if not re.match(r"^[\s]*[0-9]+%.*\[A*$", msg):
-#                         res = getattr(f, attr, *args)(*a, **kw)
-#                 else:
-#                     res = getattr(f, attr, *args)(*a, **kw)
-#             return res
-
-#         return g
+def _get_logger():
+    """Get logger lazily to avoid circular import during module initialization."""
+    from scitex import logging
+
+    return logging.getLogger(__name__)
 
 
 class Tee:
-    def __init__(self, stream: TextIO, log_path: str) -> None:
+    def __init__(self, stream: TextIO, log_path: str, verbose=True) -> None:
+        self.verbose = verbose
         self._stream = stream
+        self._log_path = log_path
         try:
             self._log_file = open(log_path, "w", buffering=1)  # Line buffering
+            if verbose:
+                # Show where logs are being saved using scitex logging
+                logger = _get_logger()
+                stream_name = "stderr" if stream is sys.stderr else "stdout"
+                logger.debug(f"Tee [{stream_name}]: {log_path}")
         except Exception as e:
             printc(f"Failed to open log file {log_path}: {e}", c="red")
             self._log_file = None
@@ -118,6 +97,10 @@ class Tee:
             try:
                 self._log_file.flush()
                 self._log_file.close()
+                if self.verbose:
+                    # Use lazy logger to avoid circular import
+                    logger = _get_logger()
+                    logger.debug(f"Tee: Closed log file: {self._log_path}")
                 self._log_file = None  # Prevent double-close
             except Exception:
                 pass
@@ -128,45 +111,16 @@ class Tee:
         if hasattr(self, "_log_file") and self._log_file is not None:
             try:
                 # Check if the file object is still valid
-                if hasattr(self._log_file, "closed") and not self._log_file.closed:
+                if (
+                    hasattr(self._log_file, "closed")
+                    and not self._log_file.closed
+                ):
                     self.close()
             except Exception:
                 # Silently ignore exceptions during cleanup
                 pass
 
 
-# class Tee:
-#     def __init__(self, stream: TextIO, log_path: str) -> None:
-#         self._files: List[TextIO] = [stream, open(log_path, "w")]
-#         self._is_stderr: bool = stream is sys.stderr
-#         self._stream = stream
-
-#     def write(self, data: Any) -> None:
-#         for file in self._files:
-#             if hasattr(file, 'write'):
-#                 if self._is_stderr and file is not sys.stderr:
-#                     if isinstance(data, str) and not re.match(r"^[\s]*[0-9]+%.*\[A*$", data):
-#                         file.write(data)
-#                 else:
-#                     file.write(data)
-
-#     def flush(self) -> None:
-#         for file in self._files:
-#             if hasattr(file, 'flush'):
-#                 file.flush()
-
-#     def isatty(self) -> bool:
-#         return getattr(self._stream, 'isatty', lambda: False)()
-
-#     def fileno(self) -> int:
-#         """Delegate fileno to original stream for IPython compatibility"""
-#         return self._stream.fileno()
-
-#     @property
-#     def buffer(self):
-#         return getattr(self._stream, 'buffer', self._stream)
-
-
 def tee(sys, sdir=None, verbose=True):
     """Redirects stdout and stderr to both console and log files.
 
@@ -213,26 +167,31 @@ def tee(sys, sdir=None, verbose=True):
 
     if verbose:
         message = f"Standard output/error are being logged at:\n\t{spath_stdout}\n\t{spath_stderr}"
-        printc(message)
+        logger = _get_logger()
+        logger.info(message)
+        # printc(message)
 
     return sys_stdout, sys_stderr
 
 
-main = tee
-
 if __name__ == "__main__":
-    # # Argument Parser
+    # Argument Parser
     import matplotlib.pyplot as plt
+
     import scitex
 
+    main = tee
+
     # import argparse
     # parser = argparse.ArgumentParser(description='')
     # parser.add_argument('--var', '-v', type=int, default=1, help='')
     # parser.add_argument('--flag', '-f', action='store_true', default=False, help='')
     # args = parser.parse_args()
     # Main
-    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt, verbose=False)
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.session.start(
+        sys, plt, verbose=False
+    )
     main(sys, CONFIG["SDIR"])
-    scitex.gen.close(CONFIG, verbose=False, notify=False)
+    scitex.session.close(CONFIG, verbose=False, notify=False)
 
 # EOF

scitex/logging/__init__.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-08-21 20:09:30 (ywatanabe)"
+# File: /home/ywatanabe/proj/SciTeX-Code/src/scitex/logging/__init__.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""Modular logging utilities for SciTeX.
+
+This module provides enhanced logging capabilities with both console and file output,
+ensuring consistent logging across the SciTeX package.
+
+Migration:
+    # OLD (deprecated)
+    from scitex import logging
+    logger = logging.getLogger(__name__)
+
+    # NEW (recommended)
+    from scitex import logging
+    logger = logging.getLogger(__name__)
+
+Usage:
+    from scitex import logging  # DEPRECATED
+    logger = logging.getLogger(__name__)
+    logger.success("Operation completed successfully")
+    logger.fail("Operation failed")
+
+    # Configure logging with file output
+    logging.configure(level='info', enable_file=True)
+
+    # Get current log file location
+    log_file = logging.get_log_path()
+"""
+
+import warnings
+
+# Issue deprecation warning when module is imported
+warnings.warn(
+    "scitex.logging is deprecated. Use scitex.logging instead. "
+    "The scitex.logging module will be removed in a future version.",
+    DeprecationWarning,
+    stacklevel=2
+)
+
+import logging as _logging
+
+from ._Tee import Tee, tee
+# Import modular components
+from ._levels import SUCCESS, FAIL, DEBUG, INFO, WARNING, ERROR, CRITICAL
+from ._logger import SciTeXLogger, setup_logger_class
+from ._formatters import SciTeXConsoleFormatter, SciTeXFileFormatter
+from ._handlers import create_console_handler, create_file_handler, get_default_log_path
+from ._config import (
+    set_level,
+    get_level,
+    enable_file_logging,
+    is_file_logging_enabled,
+    configure,
+    get_log_path
+)
+from ._print_capture import (
+    PrintCapture,
+    enable_print_capture,
+    disable_print_capture,
+    is_print_capture_enabled
+)
+from ._context import log_to_file
+
+# Re-export standard logging functions for compatibility
+getLogger = _logging.getLogger
+basicConfig = _logging.basicConfig
+disable = _logging.disable
+
+level_by_env = os.getenv("SCITEX_LOGGING_LEVEL", "INFO").upper()
+level_map = {
+    "DEBU": DEBUG,
+    "DEBUG": DEBUG,
+    "INFO": INFO,
+    "WARN": WARNING,
+    "WARNING": WARNING,
+    "ERRO": ERROR,
+    "ERROR": ERROR,
+    "CRIT": CRITICAL,
+    "CRITICAL": CRITICAL,
+    "SUCC": SUCCESS,
+    "SUCCESS": SUCCESS,
+    "FAIL": FAIL,
+}
+level = level_map.get(level_by_env, INFO)
+
+# Auto-configure logging on import with file logging enabled, print capture disabled by default
+configure(level=level, enable_file=True, enable_console=True, capture_prints=False)
+
+# Export only essential public functions - minimal API
+__all__ = [
+    # Core logging functions (most commonly used)
+    'getLogger',
+
+    # Log levels
+    'DEBUG',
+    'INFO',
+    'WARNING',
+    'ERROR',
+    'CRITICAL',
+    'SUCCESS',
+    'FAIL',
+
+    # Configuration (minimal set)
+    'configure',
+    'get_log_path',
+    'Tee',
+    'tee',
+
+    # Context managers
+    'log_to_file',
+]
+
+# EOF

scitex/logging/_config.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-08-21 21:41:37 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/log/_config.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""Configuration and setup for SciTeX logging."""
+
+import logging
+from typing import Optional, Union
+
+from ._handlers import create_console_handler, create_file_handler, get_default_log_path
+from ._levels import CRITICAL, DEBUG, ERROR, FAIL, INFO, SUCCESS, WARNING
+from ._logger import setup_logger_class
+
+# Global level variable
+_GLOBAL_LEVEL = None
+_FILE_LOGGING_ENABLED = True  # Enable file logging by default
+
+
+def set_level(level: Union[str, int]):
+    """Set global log level for all SciTeX loggers."""
+    global _GLOBAL_LEVEL
+
+    level_map = {
+        "debug": DEBUG,
+        "info": INFO,
+        "warning": WARNING,
+        "error": ERROR,
+        "critical": CRITICAL,
+        "success": SUCCESS,
+        "fail": FAIL,
+    }
+
+    if isinstance(level, str):
+        level = level_map.get(level.lower(), level)
+
+    _GLOBAL_LEVEL = level
+    logging.getLogger().setLevel(level)
+
+    # Update all existing handlers
+    for handler in logging.getLogger().handlers:
+        handler.setLevel(level)
+
+
+def get_level():
+    """Get current global log level."""
+    return _GLOBAL_LEVEL or logging.getLogger().level
+
+
+def enable_file_logging(enabled: bool = True):
+    """Enable or disable file logging globally."""
+    global _FILE_LOGGING_ENABLED
+    _FILE_LOGGING_ENABLED = enabled
+
+
+def is_file_logging_enabled():
+    """Check if file logging is enabled."""
+    return _FILE_LOGGING_ENABLED
+
+
+def configure(
+    level: Union[str, int] = "info",
+    log_file: Optional[str] = None,
+    enable_file: bool = True,
+    enable_console: bool = True,
+    capture_prints: bool = True,
+    max_file_size: int = 10 * 1024 * 1024,
+    backup_count: int = 5,
+):
+    """Configure logging for SciTeX with both console and file output.
+
+    Args:
+        level: Log level (string or logging constant)
+        log_file: Path to log file (default: ~/.scitex/logs/scitex-YYYY-MM-DD.log)
+        enable_file: Whether to enable file logging
+        enable_console: Whether to enable console logging
+        capture_prints: Whether to capture print() statements to logs
+        max_file_size: Maximum size of log file before rotation (default: 10MB)
+        backup_count: Number of backup files to keep (default: 5)
+    """
+    # Setup custom logger class
+    setup_logger_class()
+
+    # Convert level if string
+    level_map = {
+        "debug": DEBUG,
+        "info": INFO,
+        "warning": WARNING,
+        "error": ERROR,
+        "critical": CRITICAL,
+        "success": SUCCESS,
+        "fail": FAIL,
+    }
+
+    if isinstance(level, str):
+        level = level_map.get(level.lower(), level)
+
+    # Set global level
+    set_level(level)
+
+    # Clear any existing handlers
+    root_logger = logging.getLogger()
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+
+    handlers = []
+
+    # Add console handler if enabled
+    if enable_console:
+        console_handler = create_console_handler(level)
+        handlers.append(console_handler)
+
+    # Add file handler if enabled
+    if enable_file and is_file_logging_enabled():
+        if log_file is None:
+            log_file = get_default_log_path()
+
+        file_handler = create_file_handler(
+            log_file, level, max_bytes=max_file_size, backup_count=backup_count
+        )
+        handlers.append(file_handler)
+
+    # Configure basic logging with our handlers
+    logging.basicConfig(
+        level=level, handlers=handlers, force=True  # Force reconfiguration
+    )
+
+    # Enable print capture if requested
+    if capture_prints:
+        from ._print_capture import enable_print_capture
+
+        enable_print_capture()
+
+
+def get_log_path():
+    """Get the current log file path."""
+    for handler in logging.getLogger().handlers:
+        if hasattr(handler, "baseFilename"):
+            return handler.baseFilename
+    return None
+
+
+__all__ = [
+    "set_level",
+    "get_level",
+    "enable_file_logging",
+    "is_file_logging_enabled",
+    "configure",
+    "get_log_path",
+]
+
+# EOF

scitex/logging/_context.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-11 22:30:00 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/logging/_context.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = (
+    "./src/scitex/logging/_context.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""
+Context manager for temporary logging to specific files.
+
+Provides clean API for adding/removing file handlers during execution.
+"""
+
+import logging as _logging
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Optional, Union
+
+from ._formatters import SciTeXFileFormatter
+
+
+@contextmanager
+def log_to_file(
+    file_path: Union[str, Path],
+    level: int = _logging.DEBUG,
+    mode: str = 'w',
+    formatter: Optional[_logging.Formatter] = None,
+):
+    """Context manager to temporarily log all output to a specific file.
+
+    Usage:
+        from scitex import logging
+        logger = logging.getLogger(__name__)
+
+        with logging.log_to_file("/path/to/log.txt"):
+            logger.info("This goes to both console and /path/to/log.txt")
+            logger.success("This too!")
+
+    Args:
+        file_path: Path to log file
+        level: Logging level for this handler (default: DEBUG)
+        mode: File mode ('w' for overwrite, 'a' for append)
+        formatter: Custom formatter (default: SciTeXFileFormatter)
+
+    Yields:
+        The file handler (can be ignored)
+    """
+    # Ensure directory exists
+    file_path = Path(file_path)
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Create handler
+    handler = _logging.FileHandler(str(file_path), mode=mode)
+    handler.setLevel(level)
+
+    # Set formatter
+    if formatter is None:
+        formatter = SciTeXFileFormatter()
+    handler.setFormatter(formatter)
+
+    # Add to root logger
+    root_logger = _logging.getLogger()
+    root_logger.addHandler(handler)
+
+    # Log where output is going (lazy import to avoid circular dependency)
+    def _log_info():
+        try:
+            from scitex import logging
+            logger = logging.getLogger(__name__)
+            logger.info(f"Logging to: {file_path}")
+        except:
+            pass  # Silently fail if logging not ready
+
+    _log_info()
+
+    try:
+        yield handler
+    finally:
+        # Clean up handler
+        root_logger.removeHandler(handler)
+        handler.close()
+
+        # Log completion (lazy import)
+        def _log_saved():
+            try:
+                from scitex import logging
+                logger = logging.getLogger(__name__)
+                logger.info(f"Log saved: {file_path}")
+            except:
+                pass
+
+        _log_saved()
+
+
+__all__ = ['log_to_file']
+
+# EOF

scitex/logging/_formatters.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-10-11 00:17:43 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/logging/_formatters.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = (
+    "./src/scitex/logging/_formatters.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+__FILE__ = __file__
+"""Custom formatters for SciTeX logging."""
+
+import logging
+import sys
+
+# Global format configuration via environment variable
+# Options: default, minimal, detailed, debug, full
+# SCITEX_LOG_FORMAT=debug python script.py
+LOG_FORMAT = os.getenv("SCITEX_LOG_FORMAT", "default")
+
+# Available format templates
+FORMAT_TEMPLATES = {
+    "minimal": "%(levelname)s: %(message)s",
+    "default": "%(levelname)s: %(message)s",
+    "detailed": "%(levelname)s: [%(name)s] %(message)s",
+    "debug": "%(levelname)s: [%(filename)s:%(lineno)d - %(funcName)s()] %(message)s",
+    "full": "%(asctime)s - %(levelname)s: [%(filename)s:%(lineno)d - %(name)s.%(funcName)s()] %(message)s",
+}
+
+
+class SciTeXConsoleFormatter(logging.Formatter):
+    """Custom formatter with color support and configurable format."""
+
+    # ANSI color codes for log levels
+    COLORS = {
+        "DEBU": "\033[90m",  # Grey
+        "INFO": "\033[90m",  # Grey
+        "SUCC": "\033[32m",  # Green
+        "WARN": "\033[33m",  # Yellow
+        "FAIL": "\033[91m",  # Light Red
+        "ERRO": "\033[31m",  # Red
+        "CRIT": "\033[35m",  # Magenta
+    }
+
+    # Color name to ANSI code mapping
+    COLOR_NAMES = {
+        "black": "\033[30m",
+        "red": "\033[31m",
+        "green": "\033[32m",
+        "yellow": "\033[33m",
+        "blue": "\033[34m",
+        "magenta": "\033[35m",
+        "cyan": "\033[36m",
+        "white": "\033[37m",
+        "grey": "\033[90m",
+        "light_red": "\033[91m",
+        "light_green": "\033[92m",
+        "light_yellow": "\033[93m",
+        "light_blue": "\033[94m",
+        "light_magenta": "\033[95m",
+        "light_cyan": "\033[96m",
+    }
+
+    RESET = "\033[0m"
+
+    def __init__(self, fmt=None, indent_width=2):
+        """
+        Initialize with format from global config.
+
+        Args:
+            fmt: Format template string
+            indent_width: Number of spaces per indent level (default: 2)
+        """
+        if fmt is None:
+            fmt = FORMAT_TEMPLATES.get(LOG_FORMAT, FORMAT_TEMPLATES["default"])
+        super().__init__(fmt)
+        self.indent_width = indent_width
+
+    def format(self, record):
+        # Apply indentation if specified in record
+        indent_level = getattr(record, "indent", 0)
+        if indent_level > 0:
+            indent = " " * (indent_level * self.indent_width)
+            record.msg = f"{indent}{record.msg}"
+
+        # Use parent formatter to apply template
+        formatted = super().format(record)
+
+        if hasattr(sys.stdout, "isatty") and sys.stdout.isatty():
+            # Check for custom color override
+            custom_color = getattr(record, "color", None)
+
+            if custom_color and custom_color in self.COLOR_NAMES:
+                # Use custom color
+                color = self.COLOR_NAMES[custom_color]
+                return f"{color}{formatted}{self.RESET}"
+            else:
+                # Use default color for log level
+                levelname = record.levelname
+                if levelname in self.COLORS:
+                    color = self.COLORS[levelname]
+                    return f"{color}{formatted}{self.RESET}"
+
+        return formatted
+
+
+class SciTeXFileFormatter(logging.Formatter):
+    """Custom formatter for file output without colors."""
+
+    def __init__(self):
+        super().__init__(
+            fmt="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+
+
+__all__ = [
+    "SciTeXConsoleFormatter",
+    "SciTeXFileFormatter",
+    "LOG_FORMAT",
+    "FORMAT_TEMPLATES",
+]
+
+# EOF