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

scitex/gen/_deprecated_close.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-08-22 17:05:52 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/gen/_deprecated_close.py
+# ----------------------------------------
+from __future__ import annotations
+import os
+__FILE__ = __file__
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""
+Deprecated wrapper for the old scitex.gen.close function.
+
+This module provides backward compatibility by forwarding calls to the new
+scitex.session.close function while showing deprecation warnings.
+"""
+
+from ..decorators._deprecated import deprecated
+
+
+@deprecated(
+    "Use scitex.session.close instead. The old interface will be removed in a future version."
+)
+def close(*args, **kwargs):
+    """Deprecated close function - use scitex.session.close instead.
+
+    This function provides backward compatibility for existing code that uses
+    scitex.gen.close(). It forwards all calls to the new scitex.session.close()
+    function while displaying a deprecation warning.
+
+    Parameters
+    ----------
+    *args : tuple
+        Positional arguments passed to scitex.session.close()
+    **kwargs : dict
+        Keyword arguments passed to scitex.session.close()
+
+    Returns
+    -------
+    Any
+        Same return value as scitex.session.close()
+    """
+    # Import here to avoid circular dependencies
+    from ..session import close as session_close
+
+    return session_close(*args, **kwargs)
+
+
+@deprecated(
+    "Use scitex.session.running2finished instead. The old interface will be removed in a future version."
+)
+def running2finished(*args, **kwargs):
+    """Deprecated running2finished function - use scitex.session.running2finished instead.
+
+    This function provides backward compatibility for existing code that uses
+    scitex.gen.running2finished(). It forwards all calls to the new
+    scitex.session.running2finished() function while displaying a deprecation warning.
+
+    Parameters
+    ----------
+    *args : tuple
+        Positional arguments passed to scitex.session.running2finished()
+    **kwargs : dict
+        Keyword arguments passed to scitex.session.running2finished()
+
+    Returns
+    -------
+    Any
+        Same return value as scitex.session.running2finished()
+    """
+    # Import here to avoid circular dependencies
+    from ..session import running2finished as session_running2finished
+
+    return session_running2finished(*args, **kwargs)
+
+
+__all__ = ["close", "running2finished"]
+
+# EOF

scitex/gen/_deprecated_start.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# File: /home/ywatanabe/proj/SciTeX-Code/src/scitex/gen/_deprecated_start.py
+
+"""
+Deprecated wrapper for the old scitex.gen.start function.
+
+This module provides backward compatibility by forwarding calls to the new
+scitex.session.start function while showing deprecation warnings.
+"""
+
+from ..decorators._deprecated import deprecated
+
+
+@deprecated(
+    reason="Use scitex.session.start instead. The old interface will be removed in a future version.",
+    forward_to="..session.start"
+)
+def start(*args, **kwargs):
+    """This docstring will be auto-generated by the @deprecated decorator."""
+    # This function body will never be executed due to forwarding
+    # but we need a placeholder implementation
+    raise NotImplementedError("This function should be forwarded by the @deprecated decorator")
+
+
+__all__ = ['start']

scitex/gen/_detect_environment.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-07-04 11:20:00 (ywatanabe)"
+# File: ./src/scitex/gen/_detect_environment.py
+
+"""
+Enhanced environment detection for SciTeX.
+
+Provides better discrimination between:
+- Python scripts
+- IPython console
+- Jupyter notebooks
+- Interactive Python
+"""
+
+import os
+import sys
+from typing import Literal, Tuple
+
+__all__ = ['detect_environment', 'get_output_directory']
+
+EnvironmentType = Literal['script', 'jupyter', 'ipython', 'interactive', 'unknown']
+
+
+def detect_environment() -> EnvironmentType:
+    """
+    Detect the current execution environment.
+    
+    Returns
+    -------
+    EnvironmentType
+        One of: 'script', 'jupyter', 'ipython', 'interactive', 'unknown'
+        
+    Examples
+    --------
+    >>> env = detect_environment()
+    >>> print(f"Running in: {env}")
+    Running in: script
+    """
+    # Check for Jupyter notebook
+    if 'ipykernel' in sys.modules:
+        try:
+            ip = get_ipython()
+            if ip and type(ip).__name__ == 'ZMQInteractiveShell':
+                return 'jupyter'
+        except NameError:
+            pass
+    
+    # Check for IPython console
+    try:
+        ip = get_ipython()
+        if ip and type(ip).__name__ == 'TerminalInteractiveShell':
+            return 'ipython'
+    except NameError:
+        pass
+    
+    # Check for regular Python script
+    if sys.argv and sys.argv[0] and sys.argv[0].endswith('.py'):
+        return 'script'
+    
+    # Check for interactive Python
+    if hasattr(sys, 'ps1'):
+        return 'interactive'
+    
+    return 'unknown'
+
+
+def get_output_directory(specified_path: str, env_type: EnvironmentType = None) -> Tuple[str, bool]:
+    """
+    Get the appropriate output directory based on environment.
+    
+    Parameters
+    ----------
+    specified_path : str
+        The path specified by the user
+    env_type : EnvironmentType, optional
+        Override environment detection
+        
+    Returns
+    -------
+    tuple[str, bool]
+        (output_directory, should_use_temp)
+        
+    Examples
+    --------
+    >>> output_dir, use_temp = get_output_directory("data.csv")
+    >>> print(f"Save to: {output_dir}, Temp: {use_temp}")
+    Save to: ./script_out/data.csv, Temp: False
+    """
+    import inspect
+    
+    if env_type is None:
+        env_type = detect_environment()
+    
+    # For absolute paths, use as-is
+    if specified_path.startswith('/'):
+        return specified_path, False
+    
+    # Get base directory based on environment
+    if env_type == 'script':
+        # Use script location
+        try:
+            script_path = inspect.stack()[1].filename
+            if script_path and not script_path.startswith('<'):
+                script_dir = os.path.dirname(os.path.abspath(script_path))
+                script_name = os.path.splitext(os.path.basename(script_path))[0]
+                base_dir = os.path.join(script_dir, f"{script_name}_out")
+                return os.path.join(base_dir, specified_path), False
+        except:
+            pass
+    
+    elif env_type == 'jupyter':
+        # For Jupyter, use current working directory with subdirectory
+        # This keeps outputs near the notebook
+        base_dir = os.path.join(os.getcwd(), 'notebook_outputs')
+        return os.path.join(base_dir, specified_path), False
+    
+    elif env_type in ['ipython', 'interactive']:
+        # Use temp directory for console sessions
+        user = os.getenv('USER', 'unknown')
+        base_dir = f'/tmp/{user}/{env_type}'
+        return os.path.join(base_dir, specified_path), True
+    
+    # Fallback: use current directory
+    return os.path.join('./output', specified_path), False
+
+
+def is_notebook() -> bool:
+    """Check if running in Jupyter notebook."""
+    return detect_environment() == 'jupyter'
+
+
+def is_ipython() -> bool:
+    """Check if running in IPython (console or notebook)."""
+    return detect_environment() in ['jupyter', 'ipython']
+
+
+def is_script() -> bool:
+    """Check if running as a script."""
+    return detect_environment() == 'script'
+
+
+# Backward compatibility
+def is_ipython_legacy() -> bool:
+    """Legacy IPython detection for compatibility."""
+    try:
+        __IPYTHON__
+        return True
+    except NameError:
+        return False
+
+# EOF

scitex/gen/_detect_notebook_path.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-07-04 11:22:00 (ywatanabe)"
+# File: ./src/scitex/gen/_detect_notebook_path.py
+
+"""
+Detect Jupyter notebook filename for consistent output paths.
+
+When running in a notebook like ./examples/analysis.ipynb,
+outputs should go to ./examples/analysis_out/
+"""
+
+import os
+import json
+from typing import Optional
+
+__all__ = ['get_notebook_path', 'get_notebook_output_dir']
+
+
+def get_notebook_path() -> Optional[str]:
+    """
+    Get the path of the currently running Jupyter notebook.
+    
+    Returns
+    -------
+    Optional[str]
+        Path to the notebook file, or None if not in a notebook
+        
+    Examples
+    --------
+    >>> path = get_notebook_path()
+    >>> print(path)
+    ./examples/my_analysis.ipynb
+    """
+    try:
+        # Method 1: Try to get from IPython
+        ip = get_ipython()
+        
+        # Check if we're in a notebook
+        if not (ip and type(ip).__name__ == 'ZMQInteractiveShell'):
+            return None
+            
+        # Method 2: Check IPython's notebook_name
+        if hasattr(ip, 'notebook_name'):
+            return ip.notebook_name
+            
+        # Method 3: Try to get from kernel connection file
+        import re
+        import glob
+        
+        # Get kernel ID from the current session
+        kernel_id = re.search(
+            r'kernel-(.*?)\.json',
+            ip.config['IPKernelApp']['connection_file']
+        ).group(1)
+        
+        # Search for notebook sessions
+        runtime_dir = os.environ.get('JUPYTER_RUNTIME_DIR', 
+                                     os.path.expanduser('~/.local/share/jupyter/runtime'))
+        
+        for nbserver in glob.glob(os.path.join(runtime_dir, 'nbserver-*.json')):
+            try:
+                with open(nbserver, 'r') as f:
+                    server_info = json.load(f)
+                    
+                # Check notebook sessions
+                import requests
+                sessions_url = f"{server_info['url']}api/sessions?token={server_info.get('token', '')}"
+                response = requests.get(sessions_url)
+                
+                if response.status_code == 200:
+                    sessions = response.json()
+                    for session in sessions:
+                        if session['kernel']['id'] == kernel_id:
+                            # Found our notebook!
+                            notebook_path = session['notebook']['path']
+                            return notebook_path
+            except:
+                continue
+                
+        # Method 4: Try JavaScript bridge (if available)
+        try:
+            from IPython.display import Javascript, display
+            import time
+            
+            # This won't work in papermill, but works in interactive notebooks
+            display(Javascript('''
+                IPython.notebook.kernel.execute(
+                    `__notebook_path__ = '${IPython.notebook.notebook_path}'`
+                );
+            '''))
+            
+            # Brief pause for JS execution
+            time.sleep(0.1)
+            
+            if '__notebook_path__' in globals():
+                return globals()['__notebook_path__']
+        except:
+            pass
+            
+    except Exception:
+        pass
+        
+    return None
+
+
+def get_notebook_output_dir(notebook_path: Optional[str] = None) -> Optional[str]:
+    """
+    Get the output directory for a notebook.
+    
+    Parameters
+    ----------
+    notebook_path : Optional[str]
+        Path to notebook, or None to auto-detect
+        
+    Returns
+    -------
+    Optional[str]
+        Output directory path like ./examples/analysis_out/
+        
+    Examples
+    --------
+    >>> output_dir = get_notebook_output_dir()
+    >>> print(output_dir)
+    ./examples/analysis_out/
+    
+    >>> output_dir = get_notebook_output_dir('./docs/tutorial.ipynb')
+    >>> print(output_dir)
+    ./docs/tutorial_out/
+    """
+    if notebook_path is None:
+        notebook_path = get_notebook_path()
+        
+    if not notebook_path:
+        return None
+        
+    # Get directory and base name
+    notebook_dir = os.path.dirname(notebook_path) or '.'
+    notebook_base = os.path.splitext(os.path.basename(notebook_path))[0]
+    
+    # Create output directory path
+    output_dir = os.path.join(notebook_dir, f"{notebook_base}_out")
+    
+    return output_dir
+
+
+def detect_notebook_from_cwd() -> Optional[str]:
+    """
+    Fallback: Try to detect notebook from current working directory.
+    
+    If there's exactly one .ipynb file in the current directory,
+    assume that's the running notebook.
+    
+    Returns
+    -------
+    Optional[str]
+        Path to notebook or None
+    """
+    import glob
+    
+    notebooks = glob.glob('*.ipynb')
+    
+    # Only use this method if there's exactly one notebook
+    if len(notebooks) == 1:
+        return notebooks[0]
+        
+    return None
+
+# EOF

scitex/gen/_embed.py

@@ -63,13 +63,17 @@ def embed():
 
 
 if __name__ == "__main__":
+    import sys
+    import matplotlib.pyplot as plt
+    import scitex
+    
     # Start
-    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt)
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.session.start(sys, plt)
 
     embed()
 
     # Close
-    scitex.gen.close(CONFIG)
+    scitex.session.close(CONFIG)
 
 # EOF
 

scitex/gen/_get_notebook_path.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-07-04 12:00:00 (ywatanabe)"
+# File: ./src/scitex/gen/_get_notebook_path.py
+
+"""
+Get the current Jupyter notebook path.
+
+This module provides functions to detect and retrieve the path
+of the currently running Jupyter notebook.
+"""
+
+import os
+import json
+from typing import Optional
+
+__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()
+    >>> if path:
+    ...     print(f"Running in notebook: {path}")
+    """
+    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':
+            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'):
+            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', '')
+                
+                # 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'):
+                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', ''))
+                if response:
+                    for session in response:
+                        if session['kernel']['id'] == kernel_id:
+                            return os.path.join(server['notebook_dir'], session['notebook']['path'])
+        except:
+            pass
+            
+    except Exception:
+        pass
+    
+    return None
+
+
+def _get_notebook_from_server(kernel_id: str) -> Optional[str]:
+    """Try to get notebook path from Jupyter server API."""
+    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', '')
+            
+            if 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']
+    except:
+        pass
+    
+    return None
+
+
+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}'}
+            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()
+    >>> if name:
+    ...     print(f"Notebook: {name}")
+    """
+    notebook_path = get_notebook_path()
+    if notebook_path:
+        return os.path.basename(notebook_path)
+    return None
+
+
+def get_notebook_directory() -> Optional[str]:
+    """
+    Get the directory containing the current notebook.
+    
+    Returns
+    -------
+    Optional[str]
+        Directory path, or None if not in a notebook
+    """
+    notebook_path = get_notebook_path()
+    if notebook_path:
+        return os.path.dirname(os.path.abspath(notebook_path))
+    return None
+
+
+# Simpler fallback method for when advanced detection fails
+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]]
+        (notebook_name, notebook_directory)
+    """
+    try:
+        # 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))
+                
+                # 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:
+                    # 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':
+            # 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'):
+                    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 match:
+                            return match.group(0), os.getcwd()
+            
+            # Strategy 2: Check environment variables
+            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'):
+                        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'):
+                        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
+                    # is likely to have been saved recently
+                    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