scitex 2.14.0__py3-none-any.whl

scitex/writer/_dataclasses/results/_CompilationResult.py

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

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

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

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,121 @@
+<!-- ---
+!-- 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 -->