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

scitex/__init__.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-07-14 15:28:49 (ywatanabe)"
 # File: /ssh:ywatanabe@sp:/home/ywatanabe/proj/SciTeX-Code/src/scitex/__init__.py
 # ----------------------------------------
@@ -16,14 +15,15 @@ Modules are imported on-demand to avoid circular dependencies.
 
 import warnings
 
-# Always show our own deprecation warnings first
-warnings.filterwarnings("always", category=DeprecationWarning, module="scitex.*")
-# Then ignore others
-warnings.filterwarnings("ignore", category=DeprecationWarning)
+# Show deprecation warnings from scitex modules (educational for migration)
+warnings.filterwarnings("default", category=DeprecationWarning, module="scitex.*")
 
 # Version
 from .__version__ import __version__
 
+# Installation guide - show users what modules are available
+from ._install_guide import show_install_guide
+
 
 # Sentinel object for decorator-injected parameters
 class _InjectedSentinel:
@@ -145,7 +145,8 @@ resource = _LazyModule("resource")
 tex = _LazyModule("tex")
 linalg = _LazyModule("linalg")
 parallel = _LazyModule("parallel")
-dt = _LazyModule("dt")
+datetime = _LazyModule("datetime")
+dt = _LazyModule("dt")  # Alias for datetime (shorter name)
 types = _LazyModule("types")
 utils = _LazyModule("utils")
 etc = _LazyModule("etc")
@@ -163,6 +164,10 @@ cloud = _LazyModule("cloud")
 config = _LazyModule("config")
 audio = _LazyModule("audio")
 msword = _LazyModule("msword")
+fts = _LazyModule(
+    "fts"
+)  # Figure-Table-Statistics - single source of truth for bundle schemas
+fsb = fts  # Legacy alias (FSB -> FTS)
 
 # Centralized path configuration - eager loaded for convenience
 # Usage: scitex.PATHS.logs, scitex.PATHS.cache, etc.
@@ -214,7 +219,8 @@ __all__ = [
     "tex",
     "linalg",
     "parallel",
-    "dt",
+    "datetime",
+    "dt",  # Alias for datetime (shorter name)
     "types",
     "utils",
     "etc",
@@ -225,6 +231,8 @@ __all__ = [
     "config",
     "audio",
     "msword",
+    "fts",
+    "fsb",  # Legacy alias
     "PATHS",
     "INJECTED",
 ]

scitex/__version__.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-05-31 00:20:14 (ywatanabe)"
 # File: /ssh:ywatanabe@sp:/home/ywatanabe/proj/.claude-worktree/scitex_repo/src/scitex/__version__.py
 # ----------------------------------------
@@ -9,6 +8,6 @@ __FILE__ = "./src/scitex/__version__.py"
 __DIR__ = os.path.dirname(__FILE__)
 # ----------------------------------------
 
-__version__ = "2.7.3"
+__version__ = "2.10.0"
 
 # EOF

scitex/_install_guide.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""
+Installation guide and module dependency checking for SciTeX.
+
+This module provides helpers to check module dependencies and show
+helpful installation guides when dependencies are missing.
+"""
+
+import functools
+import importlib
+import warnings
+from typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar
+
+from ._optional_deps import PACKAGE_TO_EXTRA, check_optional_deps
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+# Module name -> (required_packages, extra_name, description)
+MODULE_REQUIREMENTS: Dict[str, Tuple[List[str], str, str]] = {
+    "ai": (["openai", "anthropic"], "ai", "LLM APIs"),
+    "audio": (["pyttsx3", "gtts"], "audio", "Text-to-Speech"),
+    "benchmark": (["psutil"], "benchmark", "Performance Monitoring"),
+    "browser": (["playwright"], "browser", "Web Automation"),
+    "capture": (["mss", "PIL"], "capture", "Screenshot Capture"),
+    "cli": (["click"], "cli", "Command Line Interface"),
+    "db": (["sqlalchemy"], "db", "Database"),
+    "decorators": (["joblib"], "decorators", "Caching Utilities"),
+    "dsp": (["scipy", "sounddevice"], "dsp", "Signal Processing"),
+    "fts": (["matplotlib", "PIL", "flask"], "fts", "Figures/Tables/Stats"),
+    "gen": (["IPython", "h5py"], "gen", "General Utilities"),
+    "git": (["git"], "git", "Git Operations"),
+    "io": (["h5py", "openpyxl"], "io", "File I/O"),
+    "linalg": (["scipy", "sympy"], "linalg", "Linear Algebra"),
+    "msword": (["docx"], "msword", "MS Word"),
+    "neuro": (["mne"], "neuro", "Neuroscience"),
+    "nn": (["torch"], "nn", "Neural Networks"),
+    "path": (["git"], "path", "Path Utilities"),
+    "plt": (["matplotlib", "seaborn"], "plt", "Plotting"),
+    "repro": (["torch"], "repro", "Reproducibility"),
+    "resource": (["psutil"], "resource", "Resource Monitoring"),
+    "scholar": (["selenium", "bs4", "playwright"], "scholar", "Paper Management"),
+    "stats": (["scipy", "statsmodels"], "stats", "Statistical Analysis"),
+    "str": (["natsort"], "str", "String Utilities"),
+    "torch": (["torch"], "torch", "PyTorch Support"),
+    "types": (["xarray"], "types", "Type Utilities"),
+    "web": (["aiohttp", "bs4"], "web", "Web Utilities"),
+    "writer": (["yq"], "writer", "Academic Writing"),
+}
+
+
+def check_module_deps(module_name: str) -> Dict[str, Any]:
+    """
+    Check if a module's dependencies are installed.
+
+    Args:
+        module_name: Name of the scitex module (e.g., 'audio', 'scholar')
+
+    Returns:
+        Dict with keys:
+        - available: bool - whether all required deps are installed
+        - missing: list - list of missing packages
+        - install_cmd: str - command to install missing deps
+        - extra: str - the installation extra name
+    """
+    if module_name not in MODULE_REQUIREMENTS:
+        return {"available": True, "missing": [], "install_cmd": "", "extra": ""}
+
+    required, extra, _desc = MODULE_REQUIREMENTS[module_name]
+    available = check_optional_deps(*required)
+    missing = [pkg for pkg, is_available in available.items() if not is_available]
+
+    return {
+        "available": len(missing) == 0,
+        "missing": missing,
+        "install_cmd": f"pip install scitex[{extra}]",
+        "extra": extra,
+    }
+
+
+def require_module(module_name: str) -> None:
+    """
+    Check module dependencies and raise helpful error if missing.
+
+    Call this at the top of a module's __init__.py to provide
+    clear guidance when dependencies aren't installed.
+
+    Args:
+        module_name: Name of the scitex module
+
+    Raises:
+        ImportError: With helpful installation instructions
+
+    Example:
+        # In scitex/audio/__init__.py:
+        from scitex._install_guide import require_module
+        require_module("audio")  # Raises helpful error if deps missing
+    """
+    result = check_module_deps(module_name)
+
+    if not result["available"]:
+        if module_name in MODULE_REQUIREMENTS:
+            _, extra, desc = MODULE_REQUIREMENTS[module_name]
+        else:
+            extra, desc = "all", module_name
+
+        missing_str = ", ".join(result["missing"])
+        raise ImportError(
+            f"\n"
+            f"{'=' * 70}\n"
+            f"scitex.{module_name} - {desc}\n"
+            f"{'=' * 70}\n"
+            f"\n"
+            f"This module requires dependencies that are not installed:\n"
+            f"  Missing: {missing_str}\n"
+            f"\n"
+            f"To use this module, install with:\n"
+            f"\n"
+            f"    {result['install_cmd']}\n"
+            f"\n"
+            f"Or install all optional dependencies:\n"
+            f"\n"
+            f"    pip install scitex[all]\n"
+            f"\n"
+            f"{'=' * 70}\n"
+        )
+
+
+def warn_module_deps(module_name: str) -> List[str]:
+    """
+    Check module dependencies and print warning if missing (non-blocking).
+
+    Unlike require_module(), this doesn't raise an error, just warns.
+
+    Args:
+        module_name: Name of the scitex module
+
+    Returns:
+        List of missing package names
+    """
+    result = check_module_deps(module_name)
+
+    if not result["available"]:
+        if module_name in MODULE_REQUIREMENTS:
+            _, extra, desc = MODULE_REQUIREMENTS[module_name]
+        else:
+            extra, desc = "all", module_name
+
+        missing_str = ", ".join(result["missing"])
+        warnings.warn(
+            f"\nscitex.{module_name} ({desc}): Some features unavailable.\n"
+            f"Missing: {missing_str}\n"
+            f"Install with: {result['install_cmd']}\n",
+            ImportWarning,
+            stacklevel=2,
+        )
+
+    return result["missing"]
+
+
+def requires(*packages: str, extra: Optional[str] = None):
+    """
+    Decorator that checks dependencies before function execution.
+
+    Args:
+        *packages: Required package names
+        extra: Installation extra name (auto-detected if not provided)
+
+    Example:
+        @requires("torch", "torchvision", extra="dl")
+        def train_model(data):
+            import torch
+            ...
+    """
+
+    def decorator(func: F) -> F:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            missing = []
+            for pkg in packages:
+                try:
+                    importlib.import_module(pkg)
+                except ImportError:
+                    missing.append(pkg)
+
+            if missing:
+                install_extra = extra
+                if install_extra is None:
+                    pkg_info = PACKAGE_TO_EXTRA.get(missing[0])
+                    install_extra = pkg_info[1] if pkg_info else "all"
+
+                missing_str = ", ".join(missing)
+                raise ImportError(
+                    f"\n"
+                    f"Function '{func.__name__}' requires: {missing_str}\n"
+                    f"Install with: pip install scitex[{install_extra}]\n"
+                )
+
+            return func(*args, **kwargs)
+
+        return wrapper  # type: ignore
+
+    return decorator
+
+
+def show_install_guide(module_name: Optional[str] = None) -> None:
+    """
+    Print installation guide for scitex modules.
+
+    Args:
+        module_name: Specific module to show guide for, or None for all
+
+    Example:
+        >>> from scitex._install_guide import show_install_guide
+        >>> show_install_guide("audio")
+        >>> show_install_guide()  # Shows all modules
+    """
+    print("\n" + "=" * 70)
+    print("SciTeX Installation Guide")
+    print("=" * 70)
+
+    if module_name:
+        if module_name in MODULE_REQUIREMENTS:
+            required, extra, desc = MODULE_REQUIREMENTS[module_name]
+            result = check_module_deps(module_name)
+            status = "Installed" if result["available"] else "Not installed"
+
+            print(f"\n{module_name} - {desc}")
+            print(f"  Status: {status}")
+            print(f"  Install: pip install scitex[{extra}]")
+            if not result["available"]:
+                print(f"  Missing: {', '.join(result['missing'])}")
+        else:
+            print(f"\nModule '{module_name}' not found.")
+    else:
+        print("\nModule-oriented installation (install only what you need):\n")
+
+        for mod_name, (required, extra, desc) in sorted(MODULE_REQUIREMENTS.items()):
+            result = check_module_deps(mod_name)
+            status = "[ok]" if result["available"] else "[--]"
+            print(f"  {status} {mod_name:12} pip install scitex[{extra}]")
+
+        print("\nConvenience groups:\n")
+        print("  pip install scitex[science]  # scipy, matplotlib, scikit-learn")
+        print("  pip install scitex[dl]       # PyTorch, transformers")
+        print("  pip install scitex[all]      # Everything")
+
+    print("\n" + "=" * 70 + "\n")
+
+
+# EOF

scitex/_optional_deps.py

@@ -1,46 +1,150 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 """
 Utility for handling optional dependencies with helpful error messages.
+
+SciTeX uses module-oriented optional dependencies. Install what you need:
+    pip install scitex[audio]       # Audio/TTS module
+    pip install scitex[scholar]     # Paper management
+    pip install scitex[stats]       # Statistical analysis
+    pip install scitex[io]          # File I/O operations
+    pip install scitex[all]         # Everything
+
+Multiple modules:
+    pip install scitex[audio,scholar,stats]
 """
 
-from typing import Optional, Dict, Any
 import importlib
+from typing import Any, Callable, Dict, List, Optional, TypeVar
 
+F = TypeVar("F", bound=Callable[..., Any])
+
+# Mapping of package imports to their installation extras
+# Format: import_name -> (pip_package, install_extra)
+PACKAGE_TO_EXTRA: Dict[str, tuple] = {
+    # AI Module
+    "openai": ("openai", "ai"),
+    "anthropic": ("anthropic", "ai"),
+    "google.generativeai": ("google-genai", "ai"),
+    "groq": ("groq", "ai"),
+    # Audio Module
+    "pyttsx3": ("pyttsx3", "audio"),
+    "gtts": ("gTTS", "audio"),
+    "pydub": ("pydub", "audio"),
+    "elevenlabs": ("elevenlabs", "audio"),
+    # Benchmark/Resource Module
+    "psutil": ("psutil", "benchmark"),
+    # Browser/Capture Module
+    "playwright": ("playwright", "browser"),
+    "mss": ("mss", "capture"),
+    # CLI Module
+    "click": ("click", "cli"),
+    # DB Module
+    "sqlalchemy": ("sqlalchemy", "db"),
+    "psycopg2": ("psycopg2-binary", "db"),
+    # DSP Module
+    "sounddevice": ("sounddevice", "dsp"),
+    # Gen Module
+    "IPython": ("ipython", "gen"),
+    "pyperclip": ("pyperclip", "gen"),
+    "readchar": ("readchar", "gen"),
+    # Git Module
+    "git": ("GitPython", "git"),
+    # IO Module
+    "h5py": ("h5py", "io"),
+    "openpyxl": ("openpyxl", "io"),
+    "xlrd": ("xlrd", "io"),
+    "ruamel": ("ruamel.yaml", "io"),
+    "xarray": ("xarray", "io"),
+    "zarr": ("zarr", "io"),
+    "PIL": ("Pillow", "io"),
+    "piexif": ("piexif", "io"),
+    "pypdf": ("pypdf", "io"),
+    "qrcode": ("qrcode[pil]", "io"),
+    "PyPDF2": ("PyPDF2", "io"),
+    "fitz": ("PyMuPDF", "io"),
+    "pdfplumber": ("pdfplumber", "io"),
+    "docx": ("python-docx", "io"),
+    "html2text": ("html2text", "io"),
+    "plotly": ("plotly", "io"),
+    "pymatreader": ("pymatreader", "io"),
+    # Linalg Module
+    "sympy": ("sympy", "linalg"),
+    "geom_median": ("geom_median", "linalg"),
+    # MSWord Module
+    "pypandoc": ("pypandoc", "msword"),
+    # NN Module
+    "torch": ("torch", "nn"),
+    "torchaudio": ("torchaudio", "nn"),
+    "torchsummary": ("torchsummary", "nn"),
+    "julius": ("julius", "nn"),
+    # PLT Module
+    "matplotlib": ("matplotlib", "plt"),
+    "seaborn": ("seaborn", "plt"),
+    "termplotlib": ("termplotlib", "plt"),
+    # Scholar Module
+    "selenium": ("selenium", "scholar"),
+    "bs4": ("beautifulsoup4", "scholar"),
+    "crawl4ai": ("crawl4ai", "scholar"),
+    "scholarly": ("scholarly", "scholar"),
+    "pymed": ("pymed", "scholar"),
+    "pytesseract": ("pytesseract", "scholar"),
+    "bibtexparser": ("bibtexparser", "scholar"),
+    "feedparser": ("feedparser", "scholar"),
+    "httpx": ("httpx", "scholar"),
+    "tenacity": ("tenacity", "scholar"),
+    "pydantic": ("pydantic", "scholar"),
+    "watchdog": ("watchdog", "scholar"),
+    # Stats Module
+    "scipy": ("scipy", "stats"),
+    "statsmodels": ("statsmodels", "stats"),
+    # Web Module
+    "aiohttp": ("aiohttp", "web"),
+    "requests": ("requests", "web"),
+    "readability": ("readability-lxml", "web"),
+    # Writer Module
+    "yq": ("yq", "writer"),
+    # DL Module (convenience group)
+    "torchvision": ("torchvision", "dl"),
+    "transformers": ("transformers", "dl"),
+    "accelerate": ("accelerate", "dl"),
+    "bitsandbytes": ("bitsandbytes", "dl"),
+    "fairscale": ("fairscale", "dl"),
+    "einops": ("einops", "dl"),
+    # ML Module (convenience group)
+    "sklearn": ("scikit-learn", "ml"),
+    "skimage": ("scikit-image", "ml"),
+    "imblearn": ("imbalanced-learn", "ml"),
+    "umap": ("umap-learn", "ml"),
+    "sktime": ("sktime", "ml"),
+    "catboost": ("catboost", "ml"),
+    "optuna": ("optuna", "ml"),
+    "cv2": ("opencv-python", "ml"),
+    # Jupyter Module
+    "jupyterlab": ("jupyterlab", "jupyter"),
+    "ipykernel": ("ipykernel", "jupyter"),
+    "ipdb": ("ipdb", "jupyter"),
+    "papermill": ("papermill", "jupyter"),
+    "jupytext": ("jupytext", "jupyter"),
+    # Neuro Module
+    "mne": ("mne", "neuro"),
+    "obspy": ("obspy", "neuro"),
+    "pyedflib": ("pyedflib", "neuro"),
+    "pybids": ("pybids", "neuro"),
+    "tensorpac": ("tensorpac", "neuro"),
+    "ripple_detection": ("ripple_detection", "neuro"),
+    # Webdev Module
+    "fastapi": ("fastapi", "webdev"),
+    "flask": ("flask", "webdev"),
+    "streamlit": ("streamlit", "webdev"),
+    "celery": ("celery", "webdev"),
+    # GUI Module
+    "dearpygui": ("dearpygui", "gui"),
+    "PyQt6": ("PyQt6", "gui"),
+}
 
-# Mapping of modules to their installation extras
+# Backwards compatibility: simple mapping
 DEPENDENCY_GROUPS: Dict[str, str] = {
-    # Deep Learning
-    "torch": "dl",
-    "torchvision": "dl",
-    "torchaudio": "dl",
-    "transformers": "dl",
-    "accelerate": "dl",
-    "bitsandbytes": "dl",
-    "fairscale": "dl",
-    # AI APIs
-    "openai": "ai-apis",
-    "anthropic": "ai-apis",
-    "google.generativeai": "ai-apis",
-    "groq": "ai-apis",
-    # Scholar
-    "selenium": "scholar",
-    "playwright": "scholar",
-    "crawl4ai": "scholar",
-    "bs4": "scholar",
-    # Neuroscience
-    "mne": "neuro",
-    "obspy": "neuro",
-    "pyedflib": "neuro",
-    "tensorpac": "neuro",
-    # Web
-    "fastapi": "web",
-    "flask": "web",
-    "streamlit": "web",
-    # Jupyter
-    "jupyterlab": "jupyter",
-    "IPython": "jupyter",
-    "ipykernel": "jupyter",
+    module: info[1] for module, info in PACKAGE_TO_EXTRA.items()
 }
 
 
@@ -68,14 +172,18 @@ def optional_import(
         if not raise_error:
             return None
 
-        pkg_name = package_name or module_name
-        extra_group = DEPENDENCY_GROUPS.get(module_name, "all")
+        pkg_info = PACKAGE_TO_EXTRA.get(module_name)
+        if pkg_info:
+            pip_pkg, extra = pkg_info
+        else:
+            pip_pkg = package_name or module_name
+            extra = "all"
 
         error_msg = (
             f"\n{'=' * 70}\n"
-            f"Optional dependency '{pkg_name}' is not installed.\n\n"
+            f"Optional dependency '{pip_pkg}' is not installed.\n\n"
             f"To use this feature, install it with:\n"
-            f"  pip install scitex[{extra_group}]\n\n"
+            f"  pip install scitex[{extra}]\n\n"
             f"Or install all optional dependencies:\n"
             f"  pip install scitex[all]\n"
             f"{'=' * 70}\n"
@@ -108,7 +216,42 @@ def check_optional_deps(*module_names: str) -> Dict[str, bool]:
     return result
 
 
-# Convenience: Check common dependency groups
+def get_install_command(module_name: str) -> str:
+    """
+    Get the pip install command for a module.
+
+    Args:
+        module_name: Name of the module
+
+    Returns:
+        pip install command string
+
+    Example:
+        >>> get_install_command('torch')
+        'pip install scitex[nn]'
+    """
+    pkg_info = PACKAGE_TO_EXTRA.get(module_name)
+    if pkg_info:
+        return f"pip install scitex[{pkg_info[1]}]"
+    return "pip install scitex[all]"
+
+
+def list_available_extras() -> List[str]:
+    """
+    List all available installation extras.
+
+    Returns:
+        List of extra names (e.g., ['audio', 'scholar', 'stats', ...])
+    """
+    extras = set(info[1] for info in PACKAGE_TO_EXTRA.values())
+    # Add convenience groups
+    extras.update(
+        ["science", "dl", "ml", "jupyter", "neuro", "webdev", "gui", "dev", "all"]
+    )
+    return sorted(extras)
+
+
+# Convenience functions for common checks
 def has_deep_learning() -> bool:
     """Check if deep learning dependencies are available."""
     return check_optional_deps("torch")["torch"]
@@ -130,4 +273,28 @@ def has_jupyter() -> bool:
     return check_optional_deps("IPython")["IPython"]
 
 
+def has_audio() -> bool:
+    """Check if audio/TTS dependencies are available."""
+    deps = check_optional_deps("pyttsx3", "gtts")
+    return any(deps.values())
+
+
+def has_stats() -> bool:
+    """Check if stats dependencies are available."""
+    return check_optional_deps("scipy", "statsmodels") == {
+        "scipy": True,
+        "statsmodels": True,
+    }
+
+
+def has_io() -> bool:
+    """Check if IO dependencies are available."""
+    return check_optional_deps("h5py")["h5py"]
+
+
+def has_plotting() -> bool:
+    """Check if plotting dependencies are available."""
+    return check_optional_deps("matplotlib")["matplotlib"]
+
+
 # EOF

scitex/ai/_gen_ai/_Groq.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Time-stamp: "2024-11-28 02:47:54 (ywatanabe)"
 # File: ./scitex_repo/src/scitex/ai/_gen_ai/_Groq.py
 
@@ -22,11 +21,9 @@ Prerequisites:
 
 """Imports"""
 import os
-import sys
-from typing import Any, Dict, Generator, List, Optional, Union
+from typing import Any, Dict, Generator, List, Optional
 
 from groq import Groq as _Groq
-import matplotlib.pyplot as plt
 
 from ._BaseGenAI import BaseGenAI
 
@@ -55,6 +52,7 @@ class Groq(BaseGenAI):
             model=model,
             api_key=api_key,
             stream=stream,
+            seed=seed,
             n_keep=n_keep,
             temperature=temperature,
             provider="Groq",

scitex/ai/_gen_ai/_OpenAI.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-01-22 01:21:11 (ywatanabe)"
 # File: _OpenAI.py
 
@@ -8,7 +7,9 @@ THIS_FILE = "/home/ywatanabe/proj/scitex_repo/src/scitex/ai/_gen_ai/_OpenAI.py"
 
 """Imports"""
 import os
+
 from openai import OpenAI as _OpenAI
+
 from ._BaseGenAI import BaseGenAI
 
 """Functions & Classes"""
@@ -55,6 +56,7 @@ class OpenAI(BaseGenAI):
             model=model,
             api_key=api_key,
             stream=stream,
+            seed=seed,
             n_keep=n_keep,
             temperature=temperature,
             provider="OpenAI",
@@ -148,7 +150,7 @@ class OpenAI(BaseGenAI):
                         if any(char in ".!?\n " for char in current_text):
                             yield buffer
                             buffer = ""
-                except Exception as e:
+                except Exception:
                     pass
 
         # Yield any remaining text
@@ -216,6 +218,7 @@ if __name__ == "__main__":
     import sys
 
     import matplotlib.pyplot as plt
+
     import scitex
 
     CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.session.start(