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

scitex/writer/.legacy/_compile.py

@@ -1,342 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: "2025-10-29 05:43:24 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/_compile.py
-# ----------------------------------------
-from __future__ import annotations
-import os
-
-__FILE__ = "./src/scitex/writer/_compile.py"
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
-
-"""
-LaTeX compilation functions with Python wrappers.
-
-This module provides Python wrappers around scitex-writer shell scripts,
-handling subprocess execution, output parsing, and exit code management.
-"""
-
-from pathlib import Path
-from datetime import datetime
-
-from ._validate_tree_structures import validate_tree_structures
-from .utils._parse_latex_logs import parse_compilation_output
-from .dataclasses.config import DOC_TYPE_DIRS, DOC_TYPE_FLAGS
-from .dataclasses import CompilationResult
-
-from scitex.logging import getLogger
-from scitex._sh import sh
-
-logger = getLogger(__name__)
-
-
-def _run_compile(
-    doc_type: str,
-    project_dir: Path,
-    timeout: int = 300,
-    track_changes: bool = False,
-) -> CompilationResult:
-    """
-    Run compilation script and parse results.
-
-    Args:
-        doc_type: Document type ('manuscript', 'supplementary', 'revision')
-        project_dir: Path to project directory (containing 01_manuscript/, etc.)
-        timeout: Timeout in seconds
-        track_changes: Enable change tracking (revision only)
-
-    Returns:
-        CompilationResult with compilation status and outputs
-    """
-    start_time = datetime.now()
-    project_dir = Path(project_dir).absolute()
-
-    # Validate project structure before compilation
-    validate_tree_structures(project_dir)
-
-    # Get compile script from scripts/shell/ directory
-    script_map = {
-        "manuscript": project_dir / "scripts" / "shell" / "compile_manuscript.sh",
-        "supplementary": project_dir / "scripts" / "shell" / "compile_supplementary.sh",
-        "revision": project_dir / "scripts" / "shell" / "compile_revision.sh",
-    }
-
-    compile_script = script_map.get(doc_type)
-    if not compile_script or not compile_script.exists():
-        error_msg = f"Compilation script not found: {compile_script}"
-        logger.error(error_msg)
-        return CompilationResult(
-            success=False,
-            exit_code=127,
-            stdout="",
-            stderr=error_msg,
-            duration=0.0,
-        )
-
-    # Build command - use absolute path for script
-    script_path = compile_script.absolute()
-    cmd = [str(script_path)]
-    if track_changes and doc_type == "revision":
-        cmd.append("--track-changes")
-
-    logger.info(f"Running compilation: {' '.join(cmd)}")
-    logger.info(f"Working directory: {project_dir}")
-
-    try:
-        import os
-
-        cwd_original = Path.cwd()
-        os.chdir(project_dir)
-
-        try:
-            result_dict = sh(
-                cmd,
-                verbose=True,
-                return_as="dict",
-                timeout=timeout * 1000,
-            )
-
-            result = type(
-                "Result",
-                (),
-                {
-                    "returncode": result_dict["exit_code"],
-                    "stdout": result_dict["stdout"],
-                    "stderr": result_dict["stderr"],
-                },
-            )()
-
-            duration = (datetime.now() - start_time).total_seconds()
-        finally:
-            os.chdir(cwd_original)
-
-        # Determine output paths
-        doc_dir = project_dir / DOC_TYPE_DIRS[doc_type]
-
-        output_pdf = None
-        diff_pdf = None
-        log_file = None
-
-        if result.returncode == 0:
-            # Find generated PDF
-            pdf_name = f"{doc_type}.pdf"
-            potential_pdf = doc_dir / pdf_name
-            if potential_pdf.exists():
-                output_pdf = potential_pdf
-
-            # Check for diff PDF
-            diff_name = f"{doc_type}_diff.pdf"
-            potential_diff = doc_dir / diff_name
-            if potential_diff.exists():
-                diff_pdf = potential_diff
-
-            # Find log file
-            log_dir = doc_dir / "logs"
-            if log_dir.exists():
-                log_files = list(log_dir.glob("*.log"))
-                if log_files:
-                    log_file = max(log_files, key=lambda p: p.stat().st_mtime)
-
-        # Parse errors and warnings using parse_latex_logs module
-        error_issues, warning_issues = parse_compilation_output(
-            result.stdout + result.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]
-
-        compilation_result = CompilationResult(
-            success=(result.returncode == 0),
-            exit_code=result.returncode,
-            stdout=result.stdout,
-            stderr=result.stderr,
-            output_pdf=output_pdf,
-            diff_pdf=diff_pdf,
-            log_file=log_file,
-            duration=duration,
-            errors=errors,
-            warnings=warnings,
-        )
-
-        if compilation_result.success:
-            logger.info(f"Compilation succeeded in {duration:.2f}s")
-            if output_pdf:
-                logger.info(f"Output PDF: {output_pdf}")
-        else:
-            logger.error(f"Compilation failed with exit code {result.returncode}")
-            if errors:
-                logger.error(f"Found {len(errors)} errors")
-
-        return compilation_result
-
-    except Exception as e:
-        duration = (datetime.now() - start_time).total_seconds()
-        logger.error(f"Compilation error: {e}")
-        return CompilationResult(
-            success=False,
-            exit_code=1,
-            stdout="",
-            stderr=str(e),
-            duration=duration,
-        )
-
-
-def compile_manuscript(project_dir: Path, timeout: int = 300) -> CompilationResult:
-    """
-    Compile manuscript document.
-
-    Args:
-        project_dir: Path to writer project directory (containing 01_manuscript/)
-        timeout: Timeout in seconds
-
-    Returns:
-        CompilationResult with compilation status and outputs
-
-    Examples:
-        >>> from pathlib import Path
-        >>> result = compile_manuscript(Path("/path/to/project"))
-        >>> if result.success:
-        ...     print(f"PDF created: {result.output_pdf}")
-        ... else:
-        ...     print(f"Errors: {result.errors}")
-    """
-    return _run_compile("manuscript", project_dir, timeout=timeout)
-
-
-def compile_supplementary(project_dir: Path, timeout: int = 300) -> CompilationResult:
-    """
-    Compile supplementary materials.
-
-    Args:
-        project_dir: Path to writer project directory (containing 02_supplementary/)
-        timeout: Timeout in seconds
-
-    Returns:
-        CompilationResult with compilation status and outputs
-    """
-    return _run_compile("supplementary", project_dir, timeout=timeout)
-
-
-def compile_revision(
-    project_dir: Path, track_changes: bool = False, timeout: int = 300
-) -> CompilationResult:
-    """
-    Compile revision responses.
-
-    Args:
-        project_dir: Path to writer project directory (containing 03_revision/)
-        track_changes: Whether to enable change tracking
-        timeout: Timeout in seconds
-
-    Returns:
-        CompilationResult with compilation status and outputs
-    """
-    return _run_compile(
-        "revision", project_dir, timeout=timeout, track_changes=track_changes
-    )
-
-
-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()
-
-    CONFIG, sys.stdout, sys.stderr, plt, CC, rng = stx.session.start(
-        sys,
-        plt,
-        args=args,
-        file=__FILE__,
-        sdir_suffix=None,
-        verbose=False,
-        agg=True,
-    )
-
-    exit_status = main(args)
-
-    stx.session.close(
-        CONFIG,
-        verbose=False,
-        notify=False,
-        message="",
-        exit_status=exit_status,
-    )
-
-
-def main(args):
-    project_dir = Path(args.dir) if args.dir else Path.cwd()
-
-    if args.document == "manuscript":
-        result = compile_manuscript(project_dir, timeout=args.timeout)
-    elif args.document == "supplementary":
-        result = compile_supplementary(project_dir, timeout=args.timeout)
-    elif args.document == "revision":
-        result = compile_revision(
-            project_dir, track_changes=args.track_changes, timeout=args.timeout
-        )
-
-    if result.success:
-        print(f"Compilation successful: {result.output_pdf}")
-        return 0
-    else:
-        print(f"Compilation failed (exit code {result.exit_code})")
-        if result.errors:
-            print(f"Errors: {len(result.errors)}")
-        return result.exit_code
-
-
-def parse_args():
-    import argparse
-
-    parser = argparse.ArgumentParser(
-        description="Compile LaTeX documents for scitex writer project"
-    )
-    parser.add_argument(
-        "--dir",
-        "-d",
-        type=str,
-        default=None,
-        help="Project directory (default: current directory)",
-    )
-    parser.add_argument(
-        "--document",
-        "-t",
-        type=str,
-        choices=["manuscript", "supplementary", "revision"],
-        default="manuscript",
-        help="Document type to compile (default: manuscript)",
-    )
-    parser.add_argument(
-        "--timeout",
-        type=int,
-        default=300,
-        help="Compilation timeout in seconds (default: 300)",
-    )
-    parser.add_argument(
-        "--track-changes",
-        action="store_true",
-        help="Enable change tracking for revision (revision only)",
-    )
-
-    return parser.parse_args()
-
-
-if __name__ == "__main__":
-    run_session()
-
-
-__all__ = [
-    "CompilationResult",
-    "compile_manuscript",
-    "compile_supplementary",
-    "compile_revision",
-]
-
-# python -m scitex.writer._compile --dir ./my_paper --document manuscript
-
-# EOF

scitex/writer/_compile_async.py

@@ -1,126 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# 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 functools import wraps
-from pathlib import Path
-from typing import Callable
-from typing import Any
-from concurrent.futures import ThreadPoolExecutor
-from scitex.logging import getLogger
-
-from ._compile import compile_manuscript
-from ._compile import compile_supplementary
-from ._compile import compile_revision
-from ._compile import CompilationResult
-
-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()
-        return await loop.run_in_executor(_executor, sync_func, *args, **kwargs)
-
-    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/_validate_tree_structures.py

@@ -1,197 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: "2025-10-29 06:13:05 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/_validate_tree_structures.py
-# ----------------------------------------
-from __future__ import annotations
-import os
-
-__FILE__ = "./src/scitex/writer/_validate_tree_structures.py"
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
-
-import argparse
-
-"""Project structure validation for writer module.
-
-Leverages dataclass verify_structure() methods for validation."""
-
-from pathlib import Path
-from scitex.logging import getLogger
-from .dataclasses import ManuscriptTree
-from .dataclasses import SupplementaryTree
-from .dataclasses import RevisionTree
-from .dataclasses import ConfigTree
-from .dataclasses import ScriptsTree
-from .dataclasses import SharedTree
-
-logger = getLogger(__name__)
-
-# Parameters
-TREE_VALIDATORS = {
-    "config": {"dir_name": "config", "tree_class": ConfigTree},
-    "00_shared": {"dir_name": "00_shared", "tree_class": SharedTree},
-    "01_manuscript": {
-        "dir_name": "01_manuscript",
-        "tree_class": ManuscriptTree,
-    },
-    "02_supplementary": {
-        "dir_name": "02_supplementary",
-        "tree_class": SupplementaryTree,
-    },
-    "03_revision": {"dir_name": "03_revision", "tree_class": RevisionTree},
-    "scripts": {"dir_name": "scripts", "tree_class": ScriptsTree},
-}
-
-
-# Exception classes
-class ProjectValidationError(Exception):
-    """Raised when project structure is invalid."""
-
-    pass
-
-
-# 2. Public validation functions
-def validate_tree_structures(
-    project_dir: Path, func_name="validate_tree_structures"
-) -> None:
-    """Validates all tree structures in the project directory."""
-    logger.info(
-        f"{func_name}: Validating tree structures: {Path(project_dir).absolute()}..."
-    )
-    project_dir = Path(project_dir)
-    for dir_name, (dir_path, tree_class) in TREE_VALIDATORS.items():
-        validator_func_name = f"_validate_{dir_name}_structure"
-        eval(validator_func_name)(project_dir)
-    logger.success(
-        f"{func_name}: Validated tree structures: {Path(project_dir).absolute()}"
-    )
-    return True
-
-
-# 3. Internal validation functions
-def _validate_01_manuscript_structure(project_dir: Path) -> bool:
-    """Validates manuscript structure."""
-    return _validate_tree_structure_base(
-        project_dir, **TREE_VALIDATORS["01_manuscript"]
-    )
-
-
-def _validate_02_supplementary_structure(project_dir: Path) -> bool:
-    """Validates supplementary structure."""
-    return _validate_tree_structure_base(
-        project_dir, **TREE_VALIDATORS["02_supplementary"]
-    )
-
-
-def _validate_03_revision_structure(project_dir: Path) -> bool:
-    """Validates revision structure."""
-    return _validate_tree_structure_base(project_dir, **TREE_VALIDATORS["03_revision"])
-
-
-def _validate_config_structure(project_dir: Path) -> bool:
-    """Validates config structure."""
-    return _validate_tree_structure_base(project_dir, **TREE_VALIDATORS["config"])
-
-
-def _validate_scripts_structure(project_dir: Path) -> bool:
-    """Validates scripts structure."""
-    return _validate_tree_structure_base(project_dir, **TREE_VALIDATORS["scripts"])
-
-
-def _validate_00_shared_structure(project_dir: Path) -> bool:
-    """Validates shared structure."""
-    return _validate_tree_structure_base(project_dir, **TREE_VALIDATORS["00_shared"])
-
-
-# 4. Helper functions
-def _validate_tree_structure_base(
-    project_dir: Path, dir_name: str, tree_class: type = None
-) -> bool:
-    """Base validation function that checks directory existence and verifies structure using tree class.
-
-    Args:
-        project_dir: Root project directory
-        dir_name: Name of directory to validate
-        tree_class: Tree class with verify_structure method
-
-    Returns:
-        True if structure is valid
-
-    Raises:
-        ProjectValidationError: If directory missing or structure invalid
-    """
-    project_dir = Path(project_dir)
-    target_dir = project_dir / dir_name
-    if not target_dir.exists():
-        raise ProjectValidationError(f"Required directory missing: {target_dir}")
-    if tree_class is not None:
-        doc = tree_class(target_dir, git_root=project_dir)
-        is_valid, issues = doc.verify_structure()
-        if not is_valid:
-            raise ProjectValidationError(
-                f"{dir_name} structure invalid:\n"
-                + "\n".join(f"  - {issue}" for issue in issues)
-            )
-    logger.debug(f"{dir_name} structure valid: {project_dir}")
-    return True
-
-
-# 1. Main entry point
-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()
-
-    CONFIG, sys.stdout, sys.stderr, plt, CC, rng = stx.session.start(
-        sys,
-        plt,
-        args=args,
-        file=__FILE__,
-        sdir_suffix=None,
-        verbose=False,
-        agg=True,
-    )
-
-    exit_status = main(args)
-
-    stx.session.close(
-        CONFIG,
-        verbose=False,
-        notify=False,
-        message="",
-        exit_status=exit_status,
-    )
-
-
-def main(args):
-    project_dir = Path(args.dir) if args.dir else Path.cwd()
-    validate_tree_structures(project_dir)
-    return 0
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Validate scitex writer project structure"
-    )
-    parser.add_argument(
-        "--dir",
-        "-d",
-        type=str,
-        default=None,
-        help="Project directory to validate (default: current directory)",
-    )
-    args = parser.parse_args()
-    return args
-
-
-if __name__ == "__main__":
-    run_session()
-
-# python -m scitex.writer._validate_tree_structures --dir ./my_paper
-
-# EOF