scitex 2.13.0__py3-none-any.whl → 2.15.1__py3-none-any.whl

scitex/utils/_notify.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-06-15 20:25:22 (ywatanabe)"
 # File: /ssh:ywatanabe@sp:/home/ywatanabe/proj/SciTeX-Code/src/scitex/utils/_notify.py
 # ----------------------------------------
@@ -89,15 +88,27 @@ def notify(
 
     FAKE_PYTHON_SCRIPT_NAME = "$ python -c ..."
     # Use scitex.ai email addresses (not Gmail)
+    # New env var names with backward compatibility
     sender_gmail = os.getenv(
-        "SCITEX_SCHOLAR_FROM_EMAIL_ADDRESS",
-        os.getenv("SCITEX_EMAIL_AGENT", "agent@scitex.ai"),
+        "SCITEX_SCHOLAR_EMAIL_NOREPLY",  # New name
+        os.getenv(
+            "SCITEX_SCHOLAR_FROM_EMAIL_ADDRESS",  # Deprecated
+            os.getenv(
+                "SCITEX_EMAIL_NOREPLY",
+                os.getenv("SCITEX_EMAIL_AGENT", "no-reply@scitex.ai"),
+            ),
+        ),
     )
     sender_password = os.getenv(
-        "SCITEX_SCHOLAR_FROM_EMAIL_PASSWORD", os.getenv("SCITEX_EMAIL_PASSWORD", "")
+        "SCITEX_SCHOLAR_EMAIL_PASSWORD",  # New name
+        os.getenv(
+            "SCITEX_SCHOLAR_FROM_EMAIL_PASSWORD",  # Deprecated
+            os.getenv("SCITEX_EMAIL_PASSWORD", ""),
+        ),
     )
     recipient_email = recipient_email or os.getenv(
-        "SCITEX_SCHOLAR_TO_EMAIL_ADDRESS", "ywata1989@gmail.com"
+        "SCITEX_SCHOLAR_EMAIL_RECIPIENT",  # New name
+        os.getenv("SCITEX_SCHOLAR_TO_EMAIL_ADDRESS", ""),  # Deprecated
     )
 
     if file is not None:

scitex/utils/_search.py

@@ -1,21 +1,19 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Time-stamp: "2024-11-02 13:01:38 (ywatanabe)"
 # File: ./scitex_repo/src/scitex/utils/_search.py
 
-import numpy as np
 import re
 from collections import abc
 
+import numpy as np
+
 try:
     import pandas as pd
 except ImportError:
     pd = None
 
-try:
-    import xarray as xr
-except ImportError:
-    xr = None
+# xarray imported lazily to avoid atexit hang issues
+xr = None
 
 try:
     from natsort import natsorted
@@ -77,10 +75,14 @@ def search(
             if isinstance(string_or_pattern, (pd.Series, pd.Index)):
                 return string_or_pattern.tolist()
 
-        # Check for xarray types if xarray is available
-        if xr is not None:
+        # Check for xarray types (lazy import to avoid atexit hang)
+        try:
+            import xarray as xr
+
             if isinstance(string_or_pattern, xr.DataArray):
                 return string_or_pattern.tolist()
+        except ImportError:
+            pass
 
         # Check for other iterables
         if isinstance(string_or_pattern, abc.KeysView):
@@ -107,7 +109,7 @@ def search(
 
     if ensure_one:
         assert len(indices_matched) == 1, (
-            "Expected exactly one match, but found {}".format(len(indices_matched))
+            f"Expected exactly one match, but found {len(indices_matched)}"
         )
 
     if as_bool:

scitex/writer/README.md

@@ -1,7 +1,7 @@
 <!-- ---
 !-- Timestamp: 2025-10-29 17:33:34
 !-- Author: ywatanabe
-!-- File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/README.md
+!-- File: /home/ywatanabe/proj/scitex-python/src/scitex/writer/README.md
 !-- --- -->
 
 # SciTeX Writer

scitex/writer/Writer.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-10-29 06:13:07 (ywatanabe)"
 # File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/_Writer.py
 # ----------------------------------------
 from __future__ import annotations
+
 import os
 
 __FILE__ = "./src/scitex/writer/_Writer.py"
@@ -18,25 +18,24 @@ Provides object-oriented interface to scitex-writer functionality.
 
 
 from pathlib import Path
-from typing import Optional
-from typing import Callable
+from typing import Callable, Optional
+
+from scitex import logging
+from scitex.git import init_git_repo
 
-from ._compile import compile_manuscript
-from ._compile import compile_supplementary
-from ._compile import compile_revision
-from ._compile import CompilationResult
-from .utils._watch import watch_manuscript
 from ._clone_writer_project import (
     clone_writer_project as _clone_writer_project,
 )
-from .dataclasses.config import DOC_TYPE_DIRS
-from .dataclasses import ManuscriptTree
-from .dataclasses import SupplementaryTree
-from .dataclasses import RevisionTree
-from .dataclasses.tree import ScriptsTree
-from .dataclasses.tree import SharedTree
-from scitex import logging
-from scitex.git import init_git_repo
+from ._compile import (
+    CompilationResult,
+    compile_manuscript,
+    compile_revision,
+    compile_supplementary,
+)
+from ._dataclasses import ManuscriptTree, RevisionTree, SupplementaryTree
+from ._dataclasses.config import DOC_TYPE_DIRS
+from ._dataclasses.tree import ScriptsTree, SharedTree
+from .utils._watch import watch_manuscript
 
 logger = logging.getLogger(__name__)
 
@@ -57,18 +56,24 @@ class Writer:
 
         If directory doesn't exist, creates new project.
 
-        Args:
-            project_dir: Path to project directory
-            name: Project name (used if creating new project)
-            git_strategy: Git initialization strategy
-                - 'child': Create isolated git in project directory (default)
-                - 'parent': Use parent git repository
-                - 'origin': Preserve template's original git history
-                - None: Disable git initialization
-            branch: Specific branch of template repository to clone (optional)
-                If None, clones the default branch. Mutually exclusive with tag.
-            tag: Specific tag/release of template repository to clone (optional)
-                If None, clones the default branch. Mutually exclusive with branch.
+        Parameters
+        ----------
+        project_dir : Path
+            Path to project directory.
+        name : str, optional
+            Project name (used if creating new project).
+        git_strategy : str, optional
+            Git initialization strategy:
+            - 'child': Create isolated git in project directory (default)
+            - 'parent': Use parent git repository
+            - 'origin': Preserve template's original git history
+            - None: Disable git initialization
+        branch : str, optional
+            Specific branch of template repository to clone.
+            If None, clones the default branch. Mutually exclusive with tag.
+        tag : str, optional
+            Specific tag/release of template repository to clone.
+            If None, clones the default branch. Mutually exclusive with branch.
         """
         self.project_name = name or Path(project_dir).name
         self.project_dir = Path(project_dir)
@@ -117,11 +122,15 @@ class Writer:
         - 'child': Full template with git initialization
         - 'parent'/'None': Minimal directory structure
 
-        Args:
-            name: Project name (used if creating new project)
+        Parameters
+        ----------
+        name : str, optional
+            Project name (used if creating new project).
 
-        Returns:
-            Path to the project directory
+        Returns
+        -------
+        Path
+            Path to the project directory.
         """
         if self.project_dir.exists():
             logger.info(
@@ -150,11 +159,6 @@ class Writer:
                 f"Could not create project directory at {self.project_dir}"
             )
 
-        # Verify target directory exists
-        if not target_dir.exists():
-            logger.error(f"Writer: Target directory {target_dir} does not exist")
-            raise RuntimeError(f"Target directory {target_dir} was not created")
-
         # Verify project directory was created
         if not self.project_dir.exists():
             logger.error(
@@ -175,8 +179,10 @@ class Writer:
         - Required directories exist (01_manuscript, 02_supplementary, 03_revision)
         - .git exists (for git-enabled strategies)
 
-        Raises:
-            RuntimeError: If structure is invalid
+        Raises
+        ------
+        RuntimeError
+            If structure is invalid.
         """
         required_dirs = [
             self.project_dir / "01_manuscript",
@@ -206,37 +212,26 @@ class Writer:
 
         Runs scripts/shell/compile_manuscript.sh with configured settings.
 
-        Args:
-            timeout: Maximum compilation time in seconds (default: 300)
-            log_callback: Called with each log line: log_callback("Running pdflatex...")
-            progress_callback: Called with progress: progress_callback(50, "Pass 2/3")
-
-        Returns:
-            CompilationResult with success status, PDF path, and errors/warnings
-
-        Shell script options (see scripts/shell/compile_manuscript.sh):
-            -nf,  --no_figs       Exclude figures for quick compilation
-            -p2t, --ppt2tif       Convert PowerPoint to TIF on WSL
-            -c,   --crop_tif      Crop TIF images to remove excess whitespace
-            -q,   --quiet         Do not show detailed logs for LaTeX compilation
-            -v,   --verbose       Show verbose LaTeX compilation output
-            -f,   --force         Force recompilation (ignore cache)
-
-        Example:
-            >>> writer = Writer(Path("my_paper"))
-            >>> result = writer.compile_manuscript()
-            >>> if result.success:
-            ...     print(f"PDF created: {result.output_pdf}")
-
-            >>> # With callbacks for live updates
-            >>> def on_log(msg):
-            ...     append_to_job_log(job_id, msg)
-            >>> def on_progress(percent, step):
-            ...     update_job_progress(job_id, percent, step)
-            >>> result = writer.compile_manuscript(
-            ...     log_callback=on_log,
-            ...     progress_callback=on_progress
-            ... )
+        Parameters
+        ----------
+        timeout : int, optional
+            Maximum compilation time in seconds (default: 300).
+        log_callback : callable, optional
+            Called with each log line: log_callback("Running pdflatex...").
+        progress_callback : callable, optional
+            Called with progress: progress_callback(50, "Pass 2/3").
+
+        Returns
+        -------
+        CompilationResult
+            With success status, PDF path, and errors/warnings.
+
+        Examples
+        --------
+        >>> writer = Writer(Path("my_paper"))
+        >>> result = writer.compile_manuscript()
+        >>> if result.success:
+        ...     print(f"PDF created: {result.output_pdf}")
         """
         return compile_manuscript(
             self.project_dir,
@@ -256,25 +251,26 @@ class Writer:
 
         Runs scripts/shell/compile_supplementary.sh with configured settings.
 
-        Args:
-            timeout: Maximum compilation time in seconds (default: 300)
-            log_callback: Called with each log line
-            progress_callback: Called with progress updates
-
-        Returns:
-            CompilationResult with success status, PDF path, and errors/warnings
-
-        Shell script options (see scripts/shell/compile_supplementary.sh):
-            -nf,  --no_figs       Exclude figures for quick compilation
-            -q,   --quiet         Do not show detailed logs for LaTeX compilation
-            -v,   --verbose       Show verbose LaTeX compilation output
-            -f,   --force         Force recompilation (ignore cache)
-
-        Example:
-            >>> writer = Writer(Path("my_paper"))
-            >>> result = writer.compile_supplementary()
-            >>> if result.success:
-            ...     print(f"PDF created: {result.output_pdf}")
+        Parameters
+        ----------
+        timeout : int, optional
+            Maximum compilation time in seconds (default: 300).
+        log_callback : callable, optional
+            Called with each log line.
+        progress_callback : callable, optional
+            Called with progress updates.
+
+        Returns
+        -------
+        CompilationResult
+            With success status, PDF path, and errors/warnings.
+
+        Examples
+        --------
+        >>> writer = Writer(Path("my_paper"))
+        >>> result = writer.compile_supplementary()
+        >>> if result.success:
+        ...     print(f"PDF created: {result.output_pdf}")
         """
         return compile_supplementary(
             self.project_dir,
@@ -295,27 +291,28 @@ class Writer:
 
         Runs scripts/shell/compile_revision.sh with configured settings.
 
-        Args:
-            track_changes: Enable change tracking in compiled PDF (default: False)
-            timeout: Maximum compilation time in seconds (default: 300)
-            log_callback: Called with each log line
-            progress_callback: Called with progress updates
-
-        Returns:
-            CompilationResult with success status, PDF path, and errors/warnings
-
-        Shell script options (see scripts/shell/compile_revision.sh):
-            -tc, --track_changes  Show tracked changes in output PDF
-            -nf, --no_figs        Exclude figures for quick compilation
-            -q,  --quiet          Do not show detailed logs for LaTeX compilation
-            -v,  --verbose        Show verbose LaTeX compilation output
-            -f,  --force          Force recompilation (ignore cache)
-
-        Example:
-            >>> writer = Writer(Path("my_paper"))
-            >>> result = writer.compile_revision(track_changes=True)
-            >>> if result.success:
-            ...     print(f"Revision PDF: {result.output_pdf}")
+        Parameters
+        ----------
+        track_changes : bool, optional
+            Enable change tracking in compiled PDF (default: False).
+        timeout : int, optional
+            Maximum compilation time in seconds (default: 300).
+        log_callback : callable, optional
+            Called with each log line.
+        progress_callback : callable, optional
+            Called with progress updates.
+
+        Returns
+        -------
+        CompilationResult
+            With success status, PDF path, and errors/warnings.
+
+        Examples
+        --------
+        >>> writer = Writer(Path("my_paper"))
+        >>> result = writer.compile_revision(track_changes=True)
+        >>> if result.success:
+        ...     print(f"Revision PDF: {result.output_pdf}")
         """
         return compile_revision(
             self.project_dir,
@@ -358,7 +355,9 @@ def run_session() -> None:
     """Initialize scitex framework, run main function, and cleanup."""
     global CONFIG, CC, sys, plt, rng
     import sys
+
     import matplotlib.pyplot as plt
+
     import scitex as stx
 
     args = parse_args()
@@ -417,7 +416,7 @@ def main(args):
     elif args.action == "info":
         writer = Writer(Path(args.dir) if args.dir else Path.cwd())
         print(f"Project: {writer.project_dir}")
-        print(f"\nDocuments:")
+        print("\nDocuments:")
         print(f"  - Manuscript: {writer.manuscript}")
         print(f"  - Supplementary: {writer.supplementary}")
         print(f"  - Revision: {writer.revision}")

scitex/writer/__init__.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/__init__.py
 
 """
@@ -7,62 +6,41 @@ SciTeX Writer - LaTeX Compilation System
 
 Python wrapper around scitex-writer shell scripts for LaTeX compilation.
 
-Features:
-- Compile manuscript, supplementary, and revision documents
-- Watch mode for auto-recompilation
-- Exit code and output handling
-- Integration with scitex.project
-
 Examples:
-    Compile manuscript:
-        >>> from scitex.writer import compile_manuscript
-        >>> result = compile_manuscript(project_dir=Path("/path/to/project"))
-        >>> if result.success:
-        ...     print(f"PDF: {result.output_pdf}")
+    >>> from scitex.writer import Writer, compile
 
-    Watch mode:
-        >>> from scitex.writer import watch_manuscript
-        >>> watch_manuscript(project_dir=Path("/path/to/project"))
+    # Using Writer class
+    >>> writer = Writer(project_dir=Path("."))
+    >>> result = writer.compile_manuscript()
 
-    With SciTeXProject:
-        >>> from scitex.project import SciTeXProject
-        >>> project = SciTeXProject.load_from_directory(Path("/path"))
-        >>> writer_dir = project.get_scitex_directory('writer')
-        >>> result = compile_manuscript(project_dir=writer_dir)
+    # Using unified compile function
+    >>> result = compile("manuscript", project_dir=Path("."))
+    >>> results = compile("manuscript", "supplementary", project_dir=Path("."))
+    >>> results = await compile("all", project_dir=Path("."), async_=True)
 """
 
+from . import utils
+from ._compile import compile
 from .Writer import Writer
-from .dataclasses import (
-    CompilationResult,
-    WriterConfig,
-    LaTeXIssue,
-)
-from ._compile import (
-    compile_manuscript,
-    compile_supplementary,
-    compile_revision,
-)
-from ._compile_async import (
-    compile_manuscript_async,
-    compile_supplementary_async,
-    compile_revision_async,
-    compile_all_async,
-)
-
-__version__ = "0.1.0"
 
 __all__ = [
     "Writer",
-    "CompilationResult",
-    "WriterConfig",
-    "LaTeXIssue",
-    "compile_manuscript",
-    "compile_supplementary",
-    "compile_revision",
-    "compile_manuscript_async",
-    "compile_supplementary_async",
-    "compile_revision_async",
-    "compile_all_async",
+    "compile",
+    "utils",
 ]
 
+
+# Clean up namespace - hide internal submodules
+def _cleanup():
+    import sys
+
+    _this = sys.modules[__name__]
+    for _attr in list(vars(_this).keys()):
+        if _attr in ("_dataclasses",):
+            delattr(_this, _attr)
+
+
+_cleanup()
+del _cleanup
+
 # EOF

scitex/writer/_compile/__init__.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 # Timestamp: "2025-11-08 (ywatanabe)"
 # File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/_compile/__init__.py
 # ----------------------------------------
 from __future__ import annotations
+
 import os
 
 __FILE__ = "./src/scitex/writer/_compile/__init__.py"
@@ -22,14 +22,15 @@ Provides organized compilation functionality:
 - _validator: Pre-compile validation
 """
 
+from .._dataclasses import CompilationResult
+from ._compile_unified import compile
 from ._runner import run_compile
-from ..dataclasses import CompilationResult
 from .manuscript import compile_manuscript
-from .supplementary import compile_supplementary
 from .revision import compile_revision
-
+from .supplementary import compile_supplementary
 
 __all__ = [
+    "compile",
     "run_compile",
     "compile_manuscript",
     "compile_supplementary",

scitex/writer/_compile/_compile_async.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+# Timestamp: "2025-10-28 17:43:50 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/_compile_async.py
+# ----------------------------------------
+from __future__ import annotations
+
+import os
+
+__FILE__ = "./src/scitex/writer/_compile_async.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+"""
+Asynchronous compilation support for writer module.
+
+Allows non-blocking compilation operations for concurrent workflows.
+"""
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from functools import partial, wraps
+from pathlib import Path
+from typing import Any, Callable
+
+from scitex.logging import getLogger
+
+from .._dataclasses import CompilationResult
+from .manuscript import compile_manuscript
+from .revision import compile_revision
+from .supplementary import compile_supplementary
+
+logger = getLogger(__name__)
+
+# Thread pool for async operations
+_executor = ThreadPoolExecutor(max_workers=2)
+
+
+def _make_async_wrapper(sync_func: Callable) -> Callable:
+    """
+    Factory function to create async wrappers for sync compilation functions.
+
+    Args:
+        sync_func: Synchronous compilation function
+
+    Returns
+    -------
+        Async wrapper function
+    """
+
+    @wraps(sync_func)
+    async def async_wrapper(*args: Any, **kwargs: Any) -> CompilationResult:
+        loop = asyncio.get_event_loop()
+        # Use partial to bind kwargs since run_in_executor only accepts positional args
+        bound_func = partial(sync_func, *args, **kwargs)
+        return await loop.run_in_executor(_executor, bound_func)
+
+    return async_wrapper
+
+
+# Create async wrappers using factory function
+compile_manuscript_async = _make_async_wrapper(compile_manuscript)
+compile_supplementary_async = _make_async_wrapper(compile_supplementary)
+compile_revision_async = _make_async_wrapper(compile_revision)
+
+
+async def compile_all_async(
+    project_dir: Path, track_changes: bool = False, timeout: int = 300
+) -> dict:
+    """
+    Compile all document dataclasses concurrently.
+
+    Runs all three document compilations in parallel for faster overall completion.
+
+    Args:
+        project_dir: Path to writer project
+        track_changes: Whether to track changes in revision
+        timeout: Timeout per compilation
+
+    Returns
+    -------
+        Dict with keys 'manuscript', 'supplementary', 'revision' and CompilationResult values.
+        If a compilation fails, the value will be None.
+
+    Example:
+        >>> results = await compile_all_async(Path("my_paper"))
+        >>> for doc_type, result in results.items():
+        ...     if result and result.success:
+        ...         print(f"{doc_type}: OK")
+        ...     else:
+        ...         print(f"{doc_type}: FAILED")
+    """
+    logger.info(f"Starting concurrent compilation of all documents in {project_dir}")
+
+    try:
+        results = await asyncio.gather(
+            compile_manuscript_async(project_dir, timeout=timeout),
+            compile_supplementary_async(project_dir, timeout=timeout),
+            compile_revision_async(project_dir, track_changes, timeout=timeout),
+            return_exceptions=True,
+        )
+    except Exception as e:
+        logger.error(f"Error during concurrent compilation: {e}")
+        return {
+            "manuscript": None,
+            "supplementary": None,
+            "revision": None,
+        }
+
+    # Handle exceptions and convert to None
+    def safe_result(result):
+        if isinstance(result, Exception):
+            logger.error(f"Compilation exception: {result}")
+            return None
+        return result
+
+    return {
+        "manuscript": safe_result(results[0]),
+        "supplementary": safe_result(results[1]),
+        "revision": safe_result(results[2]),
+    }
+
+
+__all__ = [
+    "compile_manuscript_async",
+    "compile_supplementary_async",
+    "compile_revision_async",
+    "compile_all_async",
+]
+
+# EOF