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

scitex/writer/utils/_parse_latex_logs.py

@@ -1,138 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: "2025-10-28 17:11:22 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/parse_latex.py
-# ----------------------------------------
-from __future__ import annotations
-import os
-
-__FILE__ = "./src/scitex/writer/parse_latex.py"
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
-
-"""
-LaTeX error and warning parsing from compilation output.
-
-Simple parsing of LaTeX errors and warnings from stdout/stderr.
-"""
-
-from pathlib import Path
-from typing import List
-from typing import Tuple
-
-from .._dataclasses import LaTeXIssue
-
-
-def parse_compilation_output(
-    output: str, log_file: Path = None
-) -> Tuple[List[LaTeXIssue], List[LaTeXIssue]]:
-    """
-    Parse errors and warnings from compilation output.
-
-    Args:
-        output: Compilation output (stdout + stderr)
-        log_file: Optional path to .log file (unused, for compatibility)
-
-    Returns:
-        Tuple of (error_issues, warning_issues)
-    """
-    errors = []
-    warnings = []
-
-    for line in output.split("\n"):
-        # LaTeX error pattern: "! Error message"
-        if line.startswith("!"):
-            error_text = line[1:].strip()
-            if error_text:
-                errors.append(LaTeXIssue(type="error", message=error_text))
-
-        # LaTeX warning pattern
-        elif "warning" in line.lower():
-            warnings.append(LaTeXIssue(type="warning", message=line.strip()))
-
-    return errors, warnings
-
-
-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):
-    if args.file:
-        with open(args.file) as f_f:
-            output = f_f.read()
-    else:
-        output = args.text
-
-    errors, warnings = parse_compilation_output(output)
-
-    print(f"Errors: {len(errors)}")
-    for err in errors:
-        print(f"  - {err}")
-
-    print(f"Warnings: {len(warnings)}")
-    for warn in warnings:
-        print(f"  - {warn}")
-
-    return 0
-
-
-def parse_args():
-    import argparse
-
-    parser = argparse.ArgumentParser(
-        description="Parse LaTeX compilation output for errors and warnings"
-    )
-    parser.add_argument(
-        "--file",
-        "-f",
-        type=str,
-        help="File containing compilation output",
-    )
-    parser.add_argument(
-        "--text",
-        "-t",
-        type=str,
-        help="Compilation output text",
-    )
-
-    return parser.parse_args()
-
-
-if __name__ == "__main__":
-    run_session()
-
-
-__all__ = [
-    "parse_compilation_output",
-]
-
-# python -m scitex.writer.utils._parse_latex_logs --file compilation.log
-
-# EOF

scitex/writer/utils/_parse_script_args.py

@@ -1,156 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: "2025-10-28 17:30:00 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/_parse_script_args.py
-# ----------------------------------------
-from __future__ import annotations
-import os
-
-__FILE__ = "./src/scitex/writer/_parse_script_args.py"
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
-
-"""
-Script argument parser - extract available arguments from shell scripts.
-
-Parses shell scripts to extract documented arguments from usage() functions.
-"""
-
-import re
-from pathlib import Path
-from dataclasses import dataclass
-from typing import Optional
-
-
-@dataclass
-class ScriptArgument:
-    """Represents a single script argument."""
-
-    short_flag: Optional[str]  # e.g., "-nf"
-    long_flag: Optional[str]  # e.g., "--no_figs"
-    description: str  # e.g., "Exclude figures for quick compilation"
-    default: Optional[str]  # e.g., "false"
-
-    def __str__(self) -> str:
-        """Format as help text."""
-        flags = ", ".join(f for f in [self.short_flag, self.long_flag] if f)
-        default_str = f" (default: {self.default})" if self.default else ""
-        return f"{flags:20} {self.description}{default_str}"
-
-
-class ScriptArgumentParser:
-    """Extract arguments from shell script usage() functions."""
-
-    @staticmethod
-    def parse(script_path: Path) -> list[ScriptArgument]:
-        """
-        Parse shell script to extract available arguments.
-
-        Looks for usage() function pattern:
-            -flag,  --long-flag  Description (default: value)
-
-        Args:
-            script_path: Path to shell script
-
-        Returns:
-            List of ScriptArgument objects
-        """
-        if not script_path.exists():
-            return []
-
-        content = script_path.read_text()
-
-        # Find usage() function
-        usage_match = re.search(r"usage\s*\(\)\s*{(.*?)exit\s+0", content, re.DOTALL)
-
-        if not usage_match:
-            return []
-
-        usage_text = usage_match.group(1)
-
-        # Extract arguments from usage text (contains echo statements)
-        # Find all lines with option flags (start with "echo" and contain flags)
-        options_text = usage_text
-        args = []
-
-        # Parse each line in usage (will contain echo statements)
-        for line in options_text.split("\n"):
-            # Extract content between quotes in echo statements
-            quote_match = re.search(r'"([^"]*)"', line)
-            if not quote_match:
-                continue
-
-            line_content = quote_match.group(1).strip()
-            if not line_content or line_content.startswith("#"):
-                continue
-
-            # Skip lines without flags
-            if "-" not in line_content:
-                continue
-
-            arg = ScriptArgumentParser._parse_argument_line(line_content)
-            if arg:
-                args.append(arg)
-
-        return args
-
-    @staticmethod
-    def _parse_argument_line(line: str) -> Optional[ScriptArgument]:
-        """
-        Parse single argument line.
-
-        Format: "-nf,  --no_figs       Description (default: value)"
-        """
-        # Extract flags and description
-        flags_match = re.match(r"(.*?)\s{2,}(.*)", line)
-        if not flags_match:
-            return None
-
-        flags_str = flags_match.group(1).strip()
-        rest = flags_match.group(2).strip()
-
-        # Parse flags
-        short_flag = None
-        long_flag = None
-
-        if "," in flags_str:
-            parts = flags_str.split(",")
-            short_flag = parts[0].strip() if parts[0].strip() else None
-            long_flag = (
-                parts[1].strip() if len(parts) > 1 and parts[1].strip() else None
-            )
-        else:
-            # Single flag (short or long)
-            if flags_str.startswith("--"):
-                long_flag = flags_str
-            elif flags_str.startswith("-"):
-                short_flag = flags_str
-            else:
-                return None
-
-        # Parse description and default
-        description = rest
-        default = None
-
-        default_match = re.search(r"\(default:\s*([^)]+)\)", rest)
-        if default_match:
-            default = default_match.group(1).strip()
-            description = rest[: default_match.start()].strip()
-
-        if not description:
-            return None
-
-        return ScriptArgument(
-            short_flag=short_flag,
-            long_flag=long_flag,
-            description=description,
-            default=default,
-        )
-
-
-__all__ = [
-    "ScriptArgument",
-    "ScriptArgumentParser",
-]
-
-# EOF

scitex/writer/utils/_verify_tree_structure.py

@@ -1,205 +0,0 @@
-#!/usr/bin/env python3
-# Timestamp: "2025-10-29 06:13:05 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/_verify_tree_structure.py
-# ----------------------------------------
-from __future__ import annotations
-
-import os
-
-__FILE__ = "./src/scitex/writer/_verify_tree_structure.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 (
-    ConfigTree,
-    ManuscriptTree,
-    RevisionTree,
-    ScriptsTree,
-    SharedTree,
-    SupplementaryTree,
-)
-
-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 verify_tree_structure(
-    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()
-    verify_tree_structure(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._verify_tree_structure --dir ./my_paper
-
-# EOF

scitex/writer/utils/_watch.py

@@ -1,96 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/watch.py
-
-"""
-Watch mode for auto-recompilation.
-
-Monitors file changes and triggers automatic recompilation.
-"""
-
-import subprocess
-from pathlib import Path
-from typing import Optional, Callable
-
-from scitex.logging import getLogger
-
-logger = getLogger(__name__)
-
-
-def watch_manuscript(
-    project_dir: Path,
-    interval: int = 2,
-    on_compile: Optional[Callable] = None,
-    timeout: Optional[int] = None,
-) -> None:
-    """
-    Watch and auto-recompile manuscript on file changes.
-
-    Args:
-        project_dir: Path to writer project directory
-        interval: Check interval in seconds
-        on_compile: Callback function called after each compilation
-        timeout: Optional timeout in seconds (None = infinite)
-
-    Examples:
-        >>> from pathlib import Path
-        >>> def on_change():
-        ...     print("Recompiled!")
-        >>> watch_manuscript(Path("/path/to/project"), on_compile=on_change)
-    """
-    # Get compile script from project directory
-    compile_script = project_dir / "compile"
-
-    if not compile_script.exists():
-        logger.error(f"compile script not found: {compile_script}")
-        return
-
-    # Build watch command
-    cmd = [str(compile_script), "-m", "-w"]
-
-    logger.info(f"Starting watch mode for {project_dir}")
-    logger.info("Press Ctrl+C to stop")
-
-    try:
-        # Run watch script
-        process = subprocess.Popen(
-            cmd,
-            cwd=project_dir,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            text=True,
-            bufsize=1,  # Line-buffered
-        )
-
-        # Stream output
-        for line in iter(process.stdout.readline, ""):
-            if line:
-                print(line.rstrip())
-
-                # Call callback on compilation events
-                if on_compile and "Compilation" in line:
-                    try:
-                        on_compile()
-                    except Exception as e:
-                        logger.error(f"Callback error: {e}")
-
-        process.wait(timeout=timeout)
-
-    except KeyboardInterrupt:
-        logger.info("\nWatch mode stopped by user")
-        if process:
-            process.terminate()
-            try:
-                process.wait(timeout=5)
-            except subprocess.TimeoutExpired:
-                process.kill()
-
-    except Exception as e:
-        logger.error(f"Watch mode error: {e}")
-        if process:
-            process.terminate()
-
-
-__all__ = ["watch_manuscript"]
-
-# EOF