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

scitex/writer/_dataclasses/results/_CompilationResult.py

@@ -1,165 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: "2025-10-29 06:08:35 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/dataclasses/_CompilationResult.py
-# ----------------------------------------
-from __future__ import annotations
-import os
-
-__FILE__ = "./src/scitex/writer/dataclasses/_CompilationResult.py"
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
-
-"""
-CompilationResult - dataclass for LaTeX compilation results.
-"""
-
-from dataclasses import dataclass
-from dataclasses import field
-from pathlib import Path
-from typing import Optional
-from typing import List
-
-
-@dataclass
-class CompilationResult:
-    """Result of LaTeX compilation."""
-
-    success: bool
-    """Whether compilation succeeded (exit code 0)"""
-
-    exit_code: int
-    """Process exit code"""
-
-    stdout: str
-    """Standard output from compilation"""
-
-    stderr: str
-    """Standard error from compilation"""
-
-    output_pdf: Optional[Path] = None
-    """Path to generated PDF (if successful)"""
-
-    diff_pdf: Optional[Path] = None
-    """Path to diff PDF with tracked changes (if generated)"""
-
-    log_file: Optional[Path] = None
-    """Path to compilation log file"""
-
-    duration: float = 0.0
-    """Compilation duration in seconds"""
-
-    errors: List[str] = field(default_factory=list)
-    """Parsed LaTeX errors (if any)"""
-
-    warnings: List[str] = field(default_factory=list)
-    """Parsed LaTeX warnings (if any)"""
-
-    def __str__(self):
-        """Human-readable summary."""
-        status = "SUCCESS" if self.success else "FAILED"
-        lines = [
-            f"Compilation {status} (exit code: {self.exit_code})",
-            f"Duration: {self.duration:.2f}s",
-        ]
-        if self.output_pdf:
-            lines.append(f"Output: {self.output_pdf}")
-        if self.errors:
-            lines.append(f"Errors: {len(self.errors)}")
-        if self.warnings:
-            lines.append(f"Warnings: {len(self.warnings)}")
-        return "\n".join(lines)
-
-
-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):
-    result = CompilationResult(
-        success=args.success,
-        exit_code=args.exit_code,
-        stdout="Sample stdout",
-        stderr="Sample stderr" if not args.success else "",
-        output_pdf=Path(args.pdf) if args.pdf else None,
-        duration=args.duration,
-        errors=["Error 1", "Error 2"] if not args.success else [],
-        warnings=["Warning 1"] if args.warnings else [],
-    )
-
-    print(result)
-    return 0
-
-
-def parse_args():
-    import argparse
-
-    parser = argparse.ArgumentParser(
-        description="Demonstrate CompilationResult dataclass"
-    )
-    parser.add_argument(
-        "--success",
-        action="store_true",
-        help="Simulate successful compilation",
-    )
-    parser.add_argument(
-        "--exit-code",
-        type=int,
-        default=1,
-        help="Exit code (default: 1)",
-    )
-    parser.add_argument(
-        "--pdf",
-        type=str,
-        help="Output PDF path",
-    )
-    parser.add_argument(
-        "--duration",
-        type=float,
-        default=5.0,
-        help="Compilation duration in seconds (default: 5.0)",
-    )
-    parser.add_argument(
-        "--warnings",
-        action="store_true",
-        help="Include warnings",
-    )
-
-    return parser.parse_args()
-
-
-if __name__ == "__main__":
-    run_session()
-
-
-__all__ = ["CompilationResult"]
-
-# python -m scitex.writer._dataclasses.results._CompilationResult --success --pdf ./manuscript.pdf --duration 10.5
-
-# EOF

scitex/writer/_dataclasses/results/_LaTeXIssue.py

@@ -1,102 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: "2025-10-29 06:08:41 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/dataclasses/_LaTeXIssue.py
-# ----------------------------------------
-from __future__ import annotations
-import os
-
-__FILE__ = "./src/scitex/writer/dataclasses/_LaTeXIssue.py"
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
-
-"""
-LaTeXIssue - dataclass for LaTeX compilation issues.
-"""
-
-from dataclasses import dataclass
-
-
-@dataclass
-class LaTeXIssue:
-    """Single LaTeX error or warning."""
-
-    type: str  # 'error' or 'warning'
-    message: str
-
-    def __str__(self) -> str:
-        """Human-readable string representation."""
-        return f"{self.type.upper()}: {self.message}"
-
-
-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):
-    issue = LaTeXIssue(
-        type=args.type,
-        message=args.message,
-    )
-
-    print(issue)
-    print(f"\nFormatted: {issue}")
-    return 0
-
-
-def parse_args():
-    import argparse
-
-    parser = argparse.ArgumentParser(description="Demonstrate LaTeXIssue dataclass")
-    parser.add_argument(
-        "--type",
-        type=str,
-        default="error",
-        choices=["error", "warning"],
-        help="Issue type (default: error)",
-    )
-    parser.add_argument(
-        "--message",
-        type=str,
-        default="Undefined control sequence",
-        help="Issue message (default: 'Undefined control sequence')",
-    )
-
-    return parser.parse_args()
-
-
-if __name__ == "__main__":
-    run_session()
-
-
-__all__ = ["LaTeXIssue"]
-
-# python -m scitex.writer._dataclasses.results._LaTeXIssue --type warning --message "Citation not found"
-
-# EOF

scitex/writer/_dataclasses/results/_SaveSectionsResponse.py

@@ -1,118 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/dataclasses/results/_SaveSectionsResponse.py
-# ----------------------------------------
-from __future__ import annotations
-import os
-
-__FILE__ = "./src/scitex/writer/dataclasses/results/_SaveSectionsResponse.py"
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
-
-"""
-SaveSectionsResponse - dataclass for section save operation results.
-Ensures type safety and prevents silent failures.
-"""
-
-from dataclasses import dataclass, field
-from typing import List, Dict, Optional
-
-
-@dataclass
-class SaveSectionsResponse:
-    """Result of saving multiple sections."""
-
-    success: bool
-    """Whether the save operation succeeded"""
-
-    sections_saved: int
-    """Number of sections successfully saved"""
-
-    sections_skipped: int = 0
-    """Number of sections skipped or failed"""
-
-    message: str = ""
-    """Human-readable status message"""
-
-    errors: List[str] = field(default_factory=list)
-    """List of error messages (if any)"""
-
-    error_details: Dict[str, str] = field(default_factory=dict)
-    """Detailed errors per section: {section_id: error_message}"""
-
-    def to_dict(self) -> dict:
-        """Convert to dictionary for JSON serialization."""
-        return {
-            "success": self.success,
-            "sections_saved": self.sections_saved,
-            "sections_skipped": self.sections_skipped,
-            "message": self.message,
-            "errors": self.errors,
-            "error_details": self.error_details,
-        }
-
-    def __str__(self):
-        """Human-readable summary."""
-        status = "SUCCESS" if self.success else "FAILED"
-        lines = [
-            f"Save {status}: {self.sections_saved} saved, {self.sections_skipped} skipped",
-        ]
-        if self.message:
-            lines.append(f"Message: {self.message}")
-        if self.errors:
-            lines.append(f"Errors: {len(self.errors)}")
-            for error in self.errors[:3]:  # Show first 3 errors
-                lines.append(f"  - {error}")
-        return "\n".join(lines)
-
-    @classmethod
-    def create_success(
-        cls, sections_saved: int, message: str = ""
-    ) -> SaveSectionsResponse:
-        """Create a successful response."""
-        return cls(
-            success=True,
-            sections_saved=sections_saved,
-            sections_skipped=0,
-            message=message or f"Saved {sections_saved} sections",
-        )
-
-    @classmethod
-    def create_failure(
-        cls, error_message: str, errors: List[str] = None, sections_saved: int = 0
-    ) -> SaveSectionsResponse:
-        """Create a failed response."""
-        return cls(
-            success=False,
-            sections_saved=sections_saved,
-            sections_skipped=len(errors) if errors else 0,
-            message=error_message,
-            errors=errors or [error_message],
-        )
-
-    def validate(self) -> None:
-        """Validate response data - raises ValueError if invalid."""
-        if self.success and self.sections_saved == 0:
-            raise ValueError(
-                "SaveSectionsResponse marked as success but no sections were saved"
-            )
-
-        if not self.success and not self.errors:
-            raise ValueError(
-                "SaveSectionsResponse marked as failed but no errors provided"
-            )
-
-        if self.sections_saved < 0:
-            raise ValueError(
-                f"Invalid sections_saved: {self.sections_saved} (must be >= 0)"
-            )
-
-        if self.sections_skipped < 0:
-            raise ValueError(
-                f"Invalid sections_skipped: {self.sections_skipped} (must be >= 0)"
-            )
-
-
-__all__ = ["SaveSectionsResponse"]
-
-# EOF

scitex/writer/_dataclasses/results/_SectionReadResponse.py

@@ -1,131 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/dataclasses/results/_SectionReadResponse.py
-# ----------------------------------------
-from __future__ import annotations
-import os
-
-__FILE__ = "./src/scitex/writer/dataclasses/results/_SectionReadResponse.py"
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
-
-"""
-SectionReadResponse - dataclass for section read operation results.
-Ensures type safety and prevents silent failures.
-"""
-
-from dataclasses import dataclass
-from typing import Optional
-from pathlib import Path
-
-
-@dataclass
-class SectionReadResponse:
-    """Result of reading a section."""
-
-    success: bool
-    """Whether the read operation succeeded"""
-
-    content: str
-    """Section content (LaTeX code)"""
-
-    section_name: str
-    """Section name (e.g., 'abstract', 'introduction')"""
-
-    section_id: str
-    """Full hierarchical section ID (e.g., 'manuscript/abstract')"""
-
-    doc_type: str
-    """Document type: 'manuscript', 'supplementary', 'revision', or 'shared'"""
-
-    file_path: Optional[Path] = None
-    """Absolute path to the section .tex file"""
-
-    error: Optional[str] = None
-    """Error message if read failed"""
-
-    def to_dict(self) -> dict:
-        """Convert to dictionary for JSON serialization."""
-        return {
-            "success": self.success,
-            "content": self.content,
-            "section_name": self.section_name,
-            "section_id": self.section_id,
-            "doc_type": self.doc_type,
-            "file_path": str(self.file_path) if self.file_path else None,
-            "error": self.error,
-        }
-
-    def __str__(self):
-        """Human-readable summary."""
-        if self.success:
-            return f"Read {self.section_id}: {len(self.content)} chars"
-        else:
-            return f"Failed to read {self.section_id}: {self.error}"
-
-    @classmethod
-    def create_success(
-        cls,
-        content: str,
-        section_name: str,
-        section_id: str,
-        doc_type: str,
-        file_path: Optional[Path] = None,
-    ) -> SectionReadResponse:
-        """Create a successful response."""
-        return cls(
-            success=True,
-            content=content,
-            section_name=section_name,
-            section_id=section_id,
-            doc_type=doc_type,
-            file_path=file_path,
-            error=None,
-        )
-
-    @classmethod
-    def create_failure(cls, section_id: str, error_message: str) -> SectionReadResponse:
-        """Create a failed response."""
-        parts = section_id.split("/")
-        doc_type = parts[0] if len(parts) > 1 else "manuscript"
-        section_name = parts[1] if len(parts) > 1 else section_id
-
-        return cls(
-            success=False,
-            content="",
-            section_name=section_name,
-            section_id=section_id,
-            doc_type=doc_type,
-            file_path=None,
-            error=error_message,
-        )
-
-    def validate(self) -> None:
-        """Validate response data - raises ValueError if invalid."""
-        if (
-            self.success
-            and not self.content
-            and self.section_name not in ["compiled_pdf", "compiled_tex"]
-        ):
-            raise ValueError(
-                f"SectionReadResponse marked as success but content is empty for {self.section_id}"
-            )
-
-        if not self.success and not self.error:
-            raise ValueError(
-                f"SectionReadResponse marked as failed but no error message for {self.section_id}"
-            )
-
-        if not self.section_name:
-            raise ValueError("section_name cannot be empty")
-
-        if not self.section_id:
-            raise ValueError("section_id cannot be empty")
-
-        if self.doc_type not in ["manuscript", "supplementary", "revision", "shared"]:
-            raise ValueError(f"Invalid doc_type: {self.doc_type}")
-
-
-__all__ = ["SectionReadResponse"]
-
-# EOF

scitex/writer/_dataclasses/results/__init__.py

@@ -1,11 +0,0 @@
-from ._CompilationResult import CompilationResult
-from ._LaTeXIssue import LaTeXIssue
-from ._SaveSectionsResponse import SaveSectionsResponse
-from ._SectionReadResponse import SectionReadResponse
-
-__all__ = [
-    "CompilationResult",
-    "LaTeXIssue",
-    "SaveSectionsResponse",
-    "SectionReadResponse",
-]

scitex/writer/_dataclasses/tree/MINIMUM_FILES.md

@@ -1,121 +0,0 @@
-<!-- ---
-!-- Timestamp: 2025-10-28 16:37:52
-!-- Author: ywatanabe
-!-- File: /home/ywatanabe/proj/scitex-code/src/scitex/writer/necessary_structure.md
-!-- --- -->
-
-test-writer-project/
-├── 01_manuscript
-│   ├── archive
-│   ├── base.tex
-│   ├── contents
-│   │   ├── abstract.tex
-│   │   ├── additional_info.tex
-│   │   ├── authors.tex
-│   │   ├── bibliography.bib
-│   │   ├── data_availability.tex
-│   │   ├── discussion.tex
-│   │   ├── figures
-│   │   ├── graphical_abstract.tex
-│   │   ├── highlights.tex
-│   │   ├── introduction.tex
-│   │   ├── journal_name.tex
-│   │   ├── keywords.tex
-│   │   ├── latex_styles
-│   │   ├── methods.tex
-│   │   ├── results.tex
-│   │   ├── tables
-│   │   ├── title.tex
-│   │   └── wordcount.tex
-│   └── README.md
-├── 02_supplementary
-│   ├── archive
-│   ├── base.tex
-│   ├── contents
-│   │   ├── authors.tex
-│   │   ├── bibliography.bib
-│   │   ├── figures
-│   │   ├── journal_name.tex
-│   │   ├── keywords.tex
-│   │   ├── latex_styles
-│   │   ├── methods.tex
-│   │   ├── results.tex
-│   │   ├── tables
-│   │   ├── title.tex
-│   │   └── wordcount.tex
-│   ├── README.md
-│   ├── supplementary_diff.tex
-│   └── supplementary.tex
-├── 03_revision
-│   ├── archive
-│   ├── base.tex
-│   ├── contents
-│   │   ├── authors.tex
-│   │   ├── bibliography.bib
-│   │   ├── conclusion.tex
-│   │   ├── editor
-│   │   ├── figures
-│   │   ├── introduction.tex
-│   │   ├── journal_name.tex
-│   │   ├── keywords.tex
-│   │   ├── latex_styles
-│   │   ├── README.md
-│   │   ├── references.tex
-│   │   ├── reviewer1
-│   │   ├── reviewer2
-│   │   ├── tables
-│   │   └── title.tex
-│   ├── docs
-│   │   └── email.md
-│   ├── README.md
-│   └── revision.tex
-├── compile
-├── config
-│   ├── config_manuscript.yaml
-│   ├── config_revision.yaml
-│   ├── config_supplementary.yaml
-│   └── load_config.sh
-├── Makefile
-├── README.md
-├── scripts
-│   ├── examples
-│   │   └── link_project_assets.sh
-│   ├── installation
-│   │   ├── check_requirements.sh
-│   │   ├── download_containers.sh
-│   │   └── install_on_ubuntu.sh
-│   ├── powershell
-│   │   └── pptx2tiff.ps1
-│   ├── python
-│   │   ├── crop_tif.py
-│   │   ├── csv2latex.py
-│   │   ├── explore_bibtex.py
-│   │   ├── generate_ai2_prompt.py
-│   │   ├── optimize_figure.py
-│   │   ├── pptx2tif.py
-│   │   └── tile_panels.py
-│   └── shell
-│       ├── compile_manuscript.sh
-│       ├── compile_revision.sh
-│       ├── compile_supplementary.sh
-│       ├── modules
-│       └── watch_compile.sh
-├── shared
-│   ├── authors.tex
-│   ├── bib_files
-│   │   ├── bibliography.bib
-│   ├── bibliography.bib
-│   ├── journal_name.tex
-│   ├── keywords.tex
-│   ├── latex_styles
-│   │   ├── bibliography.tex
-│   │   ├── columns.tex
-│   │   ├── formatting.tex
-│   │   ├── linker.tex
-│   │   └── packages.tex
-│   ├── README.md
-│   ├── templates
-│   │   └── tables
-│   └── title.tex
-
-<!-- EOF -->