scitex 2.16.0__py3-none-any.whl → 2.16.2__py3-none-any.whl

scitex/writer/_compile/_compile_async.py

@@ -1,130 +0,0 @@
-#!/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

scitex/writer/_compile/_compile_unified.py

@@ -1,148 +0,0 @@
-#!/usr/bin/env python3
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/_compile_unified.py
-
-"""
-Unified compilation interface for writer module.
-
-Provides a single `compile()` function that handles all document types
-with optional async support.
-"""
-
-from __future__ import annotations
-
-import asyncio
-from pathlib import Path
-from typing import Literal, Optional, Union
-
-from .._dataclasses import CompilationResult
-from ._compile_async import (
-    compile_all_async,
-    compile_manuscript_async,
-    compile_revision_async,
-    compile_supplementary_async,
-)
-from .manuscript import compile_manuscript
-from .revision import compile_revision
-from .supplementary import compile_supplementary
-
-DocType = Literal["manuscript", "supplementary", "revision", "all"]
-
-
-def compile(
-    *doc_types: DocType,
-    project_dir: Optional[Path] = None,
-    async_: bool = False,
-    track_changes: bool = False,
-    timeout: int = 300,
-) -> Union[CompilationResult, dict, asyncio.coroutine]:
-    """
-    Unified compilation function for LaTeX documents.
-
-    Args:
-        *doc_types: Document types to compile. One or more of:
-            - "manuscript": Main document
-            - "supplementary": Supplementary materials
-            - "revision": Revision response
-            - "all": All document types (async only)
-        project_dir: Path to writer project directory
-        async_: If True, returns awaitable coroutine
-        track_changes: Enable change tracking for revision (default: False)
-        timeout: Compilation timeout in seconds (default: 300)
-
-    Returns
-    -------
-        - Single doc_type (sync): CompilationResult
-        - Multiple doc_types (sync): dict of {doc_type: CompilationResult}
-        - async_=True: Awaitable coroutine returning above
-
-    Examples
-    --------
-        >>> # Sync single document
-        >>> result = compile("manuscript", project_dir=Path("."))
-
-        >>> # Sync multiple documents
-        >>> results = compile("manuscript", "supplementary", project_dir=Path("."))
-        >>> results["manuscript"].success
-
-        >>> # Async single document
-        >>> result = await compile("manuscript", project_dir=Path("."), async_=True)
-
-        >>> # Async all documents (parallel)
-        >>> results = await compile("all", project_dir=Path("."), async_=True)
-    """
-    if not doc_types:
-        raise ValueError("At least one document type required")
-
-    if project_dir is None:
-        raise ValueError("project_dir is required")
-
-    project_dir = Path(project_dir)
-
-    # Map doc types to functions
-    sync_funcs = {
-        "manuscript": lambda: compile_manuscript(project_dir, timeout=timeout),
-        "supplementary": lambda: compile_supplementary(project_dir, timeout=timeout),
-        "revision": lambda: compile_revision(
-            project_dir, track_changes, timeout=timeout
-        ),
-    }
-
-    async_funcs = {
-        "manuscript": lambda: compile_manuscript_async(project_dir, timeout=timeout),
-        "supplementary": lambda: compile_supplementary_async(
-            project_dir, timeout=timeout
-        ),
-        "revision": lambda: compile_revision_async(
-            project_dir, track_changes, timeout=timeout
-        ),
-    }
-
-    # Handle "all" special case
-    if "all" in doc_types:
-        if async_:
-            return compile_all_async(
-                project_dir, track_changes=track_changes, timeout=timeout
-            )
-        else:
-            # Sync "all" - compile sequentially
-            return {
-                "manuscript": sync_funcs["manuscript"](),
-                "supplementary": sync_funcs["supplementary"](),
-                "revision": sync_funcs["revision"](),
-            }
-
-    # Validate doc types
-    valid_types = {"manuscript", "supplementary", "revision"}
-    for dt in doc_types:
-        if dt not in valid_types:
-            raise ValueError(
-                f"Invalid document type: {dt}. Must be one of {valid_types}"
-            )
-
-    # Single document
-    if len(doc_types) == 1:
-        doc_type = doc_types[0]
-        if async_:
-            return async_funcs[doc_type]()
-        else:
-            return sync_funcs[doc_type]()
-
-    # Multiple documents
-    if async_:
-
-        async def _compile_multiple():
-            tasks = [async_funcs[dt]() for dt in doc_types]
-            results = await asyncio.gather(*tasks, return_exceptions=True)
-            return {
-                dt: (None if isinstance(r, Exception) else r)
-                for dt, r in zip(doc_types, results)
-            }
-
-        return _compile_multiple()
-    else:
-        return {dt: sync_funcs[dt]() for dt in doc_types}
-
-
-__all__ = ["compile"]
-
-# EOF

scitex/writer/_compile/_parser.py

@@ -1,63 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: "2025-10-29 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/_compile/_parser.py
-# ----------------------------------------
-from __future__ import annotations
-import os
-
-__FILE__ = "./src/scitex/writer/_compile/_parser.py"
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
-
-"""
-Compilation output parsing.
-
-Parses LaTeX compilation output and log files for errors and warnings.
-"""
-
-from pathlib import Path
-from typing import Tuple, List, Optional
-
-from scitex.logging import getLogger
-from scitex.writer.utils._parse_latex_logs import parse_compilation_output
-
-logger = getLogger(__name__)
-
-
-def parse_output(
-    stdout: str,
-    stderr: str,
-    log_file: Optional[Path] = None,
-) -> Tuple[List[str], List[str]]:
-    """
-    Parse compilation output for errors and warnings.
-
-    Parameters
-    ----------
-    stdout : str
-        Standard output from compilation
-    stderr : str
-        Standard error from compilation
-    log_file : Path, optional
-        Path to LaTeX log file
-
-    Returns
-    -------
-    tuple
-        (errors, warnings) as lists of strings
-    """
-    error_issues, warning_issues = parse_compilation_output(
-        stdout + stderr, log_file=log_file
-    )
-
-    # Convert LaTeXIssue objects to strings for backward compatibility
-    errors = [str(issue) for issue in error_issues]
-    warnings = [str(issue) for issue in warning_issues]
-
-    return errors, warnings
-
-
-__all__ = ["parse_output"]
-
-# EOF