rtflite 2.5.3__tar.gz → 2.6.0__tar.gz

{rtflite-2.5.3 → rtflite-2.6.0}/PKG-INFO

@@ -1,38 +1,37 @@
 Metadata-Version: 2.4
 Name: rtflite
-Version: 2.5.3
+Version: 2.6.0
 Summary: Lightweight RTF composer for Python
-Project-URL: Homepage, https://pharmaverse.github.io/rtflite/
-Project-URL: Documentation, https://pharmaverse.github.io/rtflite/
-Project-URL: Repository, https://github.com/pharmaverse/rtflite
-Project-URL: Issues, https://github.com/pharmaverse/rtflite/issues
-Project-URL: Changelog, https://github.com/pharmaverse/rtflite/blob/main/CHANGELOG.md
+Author: Yilong Zhang, Nan Xiao
 Author-email: Yilong Zhang <elong0527@gmail.com>, Nan Xiao <me@nanx.me>
-License-File: LICENSE
-License-File: LICENSES_THIRD_PARTY
+License-Expression: MIT
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Healthcare Industry
 Classifier: Intended Audience :: Information Technology
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Office/Business :: Office Suites
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Classifier: Topic :: Office/Business :: Office Suites
-Classifier: Topic :: Text Processing
-Requires-Python: >=3.10
 Requires-Dist: narwhals>=1.0.0
 Requires-Dist: pillow>=8.0.0
 Requires-Dist: polars>=1.0.0
 Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-docx>=1.0.0 ; extra == 'docx'
+Requires-Dist: pypdf>=5.0.0 ; extra == 'pdf'
+Requires-Python: >=3.10
+Project-URL: Homepage, https://pharmaverse.github.io/rtflite/
+Project-URL: Documentation, https://pharmaverse.github.io/rtflite/
+Project-URL: Repository, https://github.com/pharmaverse/rtflite
+Project-URL: Issues, https://github.com/pharmaverse/rtflite/issues
+Project-URL: Changelog, https://github.com/pharmaverse/rtflite/blob/main/CHANGELOG.md
 Provides-Extra: docx
-Requires-Dist: python-docx>=1.0.0; extra == 'docx'
 Provides-Extra: pdf
-Requires-Dist: pypdf>=5.0.0; extra == 'pdf'
 Description-Content-Type: text/markdown
 
 # rtflite <img src="https://github.com/pharmaverse/rtflite/raw/main/docs/assets/logo.png" align="right" width="120" />

rtflite-2.6.0/pyproject.toml

@@ -0,0 +1,131 @@
+[project]
+name = "rtflite"
+version = "2.6.0"
+description = "Lightweight RTF composer for Python"
+dependencies = [
+    "narwhals>=1.0.0",
+    "pillow>=8.0.0",
+    "polars>=1.0.0",
+    "pydantic>=2.0.0",
+]
+readme = "README.md"
+license = "MIT"
+requires-python = ">= 3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Healthcare Industry",
+    "Intended Audience :: Information Technology",
+    "Topic :: Text Processing",
+    "Topic :: Office/Business :: Office Suites",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+
+[[project.authors]]
+name = "Yilong Zhang"
+email = "elong0527@gmail.com"
+
+[[project.authors]]
+name = "Nan Xiao"
+email = "me@nanx.me"
+
+[project.optional-dependencies]
+docx = ["python-docx>=1.0.0"]
+pdf = ["pypdf>=5.0.0"]
+
+[project.urls]
+Homepage = "https://pharmaverse.github.io/rtflite/"
+Documentation = "https://pharmaverse.github.io/rtflite/"
+Repository = "https://github.com/pharmaverse/rtflite"
+Issues = "https://github.com/pharmaverse/rtflite/issues"
+Changelog = "https://github.com/pharmaverse/rtflite/blob/main/CHANGELOG.md"
+
+[build-system]
+requires = ["uv_build>=0.12.10,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+source-exclude = [
+    "/docs",
+    "/tests",
+    "/scripts",
+    "/example_output",
+    "/htmlcov",
+    "/.github",
+    "/site",
+    "/zensical.toml",
+    "/AGENTS.md",
+    "/CLAUDE.md",
+    "/CONTRIBUTING.md",
+    "/CODE_OF_CONDUCT.md",
+    "/coverage.xml",
+    "/uv.lock",
+    "**/.gitignore",
+    "/.claude",
+    "/.mypy_cache",
+    "/.pytest_cache",
+    "/.ruff_cache",
+    "/.coverage",
+]
+wheel-exclude = [
+    "/docs",
+    "/tests",
+    "/scripts",
+    "/example_output",
+    "/htmlcov",
+    "/.github",
+    "/site",
+    "/zensical.toml",
+    "/AGENTS.md",
+    "/CLAUDE.md",
+    "/CONTRIBUTING.md",
+    "/CODE_OF_CONDUCT.md",
+    "/coverage.xml",
+    "/uv.lock",
+    "**/.gitignore",
+    "/.claude",
+    "/.mypy_cache",
+    "/.pytest_cache",
+    "/.ruff_cache",
+    "/.coverage",
+]
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "UP",
+    "B",
+    "SIM",
+    "I",
+]
+
+[[tool.mypy.overrides]]
+module = [
+    "docx",
+    "docx.*",
+    "pypdf",
+    "pypdf.*",
+]
+ignore_missing_imports = true
+
+[dependency-groups]
+dev = [
+    "griffe-pydantic>=1.1.8",
+    "isort>=5.13.2",
+    "markdown-exec[ansi]>=1.11.0",
+    "matplotlib>=3.10.5",
+    "mkdocstrings-python>=1.12.2",
+    "mypy>=1.17.1",
+    "pytest>=8.3.3",
+    "pytest-cov>=6.0.0",
+    "pytest-r-snapshot>=0.1.0",
+    "ruff>=0.7.4",
+    "zensical>=0.0.15",
+]

rtflite-2.5.3/pyproject.toml → rtflite-2.6.0/pyproject.toml.orig

@@ -1,18 +1,19 @@
 [project]
 name = "rtflite"
-version = "2.5.3"
+version = "2.6.0"
 description = "Lightweight RTF composer for Python"
 authors = [
     { name = "Yilong Zhang", email = "elong0527@gmail.com" },
     { name = "Nan Xiao", email = "me@nanx.me" },
 ]
 dependencies = [
-    "pydantic>=2.0.0",
-    "pillow>=8.0.0",
     "narwhals>=1.0.0",
+    "pillow>=8.0.0",
     "polars>=1.0.0",
+    "pydantic>=2.0.0",
 ]
 readme = "README.md"
+license = "MIT"
 requires-python = ">= 3.10"
 classifiers = [
     "Development Status :: 3 - Alpha",
@@ -25,8 +26,6 @@ classifiers = [
     "Topic :: Text Processing",
     "Topic :: Office/Business :: Office Suites",
 
-    "License :: OSI Approved :: MIT License",
-
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
@@ -47,11 +46,11 @@ Issues = "https://github.com/pharmaverse/rtflite/issues"
 Changelog = "https://github.com/pharmaverse/rtflite/blob/main/CHANGELOG.md"
 
 [build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
+requires = ["uv_build>=0.12.10,<0.13.0"]
+build-backend = "uv_build"
 
-[tool.hatch.build.targets.sdist]
-exclude = [
+[tool.uv.build-backend]
+source-exclude = [
     "/docs",
     "/tests",
     "/scripts",
@@ -73,9 +72,7 @@ exclude = [
     "/.ruff_cache",
     "/.coverage",
 ]
-
-[tool.hatch.build.targets.wheel]
-exclude = [
+wheel-exclude = [
     "/docs",
     "/tests",
     "/scripts",
@@ -100,20 +97,17 @@ exclude = [
 
 [dependency-groups]
 dev = [
+    "griffe-pydantic>=1.1.8",
+    "isort>=5.13.2",
+    "markdown-exec[ansi]>=1.11.0",
+    "matplotlib>=3.10.5",
+    "mkdocstrings-python>=1.12.2",
+    "mypy>=1.17.1",
     "pytest>=8.3.3",
     "pytest-cov>=6.0.0",
     "pytest-r-snapshot>=0.1.0",
-    "zensical>=0.0.15",
-    "mkdocstrings-python>=1.12.2",
-    "markdown-exec[ansi]>=1.11.0",
-    "griffe-pydantic>=1.1.8",
     "ruff>=0.7.4",
-    "isort>=5.13.2",
-    "mypy>=1.17.1",
-    "matplotlib>=3.10.5",
-    "pandas>=2.2.3",
-    "pyarrow >= 21.0.0; python_version < '3.14'",
-    "pyarrow >= 22.0.0; python_version >= '3.14'",
+    "zensical>=0.0.15",
 ]
 
 [tool.ruff.lint]

{rtflite-2.5.3 → rtflite-2.6.0}/src/rtflite/convert.py

@@ -3,11 +3,11 @@ import platform
 import re
 import shutil
 import subprocess
+import tempfile
 from collections.abc import Sequence
+from math import isfinite
 from pathlib import Path
 
-from packaging import version
-
 from .dictionary.libreoffice import DEFAULT_PATHS, MIN_VERSION
 
 
@@ -27,17 +27,28 @@ class LibreOfficeConverter:
         This makes it suitable for server environments and automated workflows.
     """
 
-    def __init__(self, executable_path: str | Path | None = None):
+    def __init__(
+        self,
+        executable_path: str | Path | None = None,
+        *,
+        timeout: float | None = 120,
+    ) -> None:
         """Initialize converter with optional executable path.
 
         Args:
             executable_path: Path (or executable name) to LibreOffice. If None,
                 searches standard installation locations for each platform.
+            timeout: Maximum seconds for each LibreOffice process, including
+                the version check. Defaults to 120. Use None to disable.
 
         Raises:
             FileNotFoundError: If LibreOffice executable cannot be found.
-            ValueError: If LibreOffice version is below minimum requirement.
+            ValueError: If timeout is invalid or the version cannot be parsed.
+            RuntimeError: If LibreOffice is too old, fails to start, or times out.
         """
+        if timeout is not None and (not isfinite(timeout) or timeout <= 0):
+            raise ValueError("timeout must be a positive finite number or None.")
+        self.timeout = timeout
         self.executable_path = self._resolve_executable_path(executable_path)
 
         self._verify_version()
@@ -53,15 +64,15 @@ class LibreOfficeConverter:
         executable = os.fspath(executable_path)
         expanded = os.path.expanduser(executable)
         candidate = Path(expanded)
-        candidate_str = str(candidate)
         looks_like_path = (
-            candidate.is_absolute()
-            or os.sep in candidate_str
-            or (os.altsep is not None and os.altsep in candidate_str)
+            isinstance(executable_path, Path)
+            or candidate.is_absolute()
+            or os.sep in expanded
+            or (os.altsep is not None and os.altsep in expanded)
         )
         if looks_like_path:
             if candidate.is_file():
-                return candidate
+                return candidate.absolute()
             raise FileNotFoundError(
                 f"LibreOffice executable not found at: {candidate}."
             )
@@ -69,16 +80,20 @@ class LibreOfficeConverter:
         resolved_executable = shutil.which(executable)
         if resolved_executable is None:
             raise FileNotFoundError(f"Can't find LibreOffice executable: {executable}.")
-        return Path(resolved_executable)
+        return Path(resolved_executable).absolute()
 
     def _find_executable(self) -> Path | None:
         """Find LibreOffice executable in default locations."""
-        for name in ("soffice", "libreoffice"):
+        system = platform.system()
+        # Windows needs the console launcher to capture output and wait for exit.
+        names: tuple[str, ...] = ("soffice", "libreoffice")
+        if system == "Windows":
+            names = ("soffice.com", *names)
+        for name in names:
             resolved = shutil.which(name)
             if resolved is not None:
-                return Path(resolved)
+                return Path(resolved).absolute()
 
-        system = platform.system()
         if system not in DEFAULT_PATHS:
             raise RuntimeError(f"Unsupported operating system: {system}.")
 
@@ -88,34 +103,53 @@ class LibreOfficeConverter:
                 return candidate
         return None
 
-    def _verify_version(self):
-        """Verify LibreOffice version meets minimum requirement."""
+    def _run_command(
+        self, cmd: list[str], action: str
+    ) -> subprocess.CompletedProcess[str]:
+        """Run LibreOffice with bounded execution and useful diagnostics."""
         try:
-            result = subprocess.run(
-                [str(self.executable_path), "--version"],
+            return subprocess.run(
+                cmd,
                 capture_output=True,
                 text=True,
+                errors="replace",
                 check=True,
+                timeout=self.timeout,
             )
-            version_str = result.stdout.strip()
-            # Extract version number (for example, "24.8.3.2" from the output)
-            match = re.search(r"LibreOffice (\d+\.\d+)", version_str)
-            if not match:
-                raise ValueError(
-                    f"Can't parse LibreOffice version from: {version_str}."
-                )
-
-            current_version = version.parse(match.group(1))
-            min_version = version.parse(MIN_VERSION)
-
-            if current_version < min_version:
-                raise RuntimeError(
-                    "LibreOffice version "
-                    f"{current_version} is below minimum required "
-                    f"version {min_version}."
-                )
+        except subprocess.TimeoutExpired as e:
+            raise RuntimeError(
+                f"LibreOffice {action} timed out after {self.timeout} seconds."
+            ) from e
         except subprocess.CalledProcessError as e:
-            raise RuntimeError(f"Failed to get LibreOffice version: {e}.") from e
+            raise RuntimeError(
+                f"LibreOffice {action} failed (exit code {e.returncode}):\n"
+                f"Command output: {e.stdout}\n"
+                f"Error output: {e.stderr}"
+            ) from e
+        except OSError as e:
+            raise RuntimeError(
+                f"Failed to run LibreOffice at {self.executable_path}: {e}"
+            ) from e
+
+    def _verify_version(self) -> None:
+        """Verify LibreOffice version meets minimum requirement."""
+        result = self._run_command(
+            [str(self.executable_path), "--version"], "version check"
+        )
+        version_str = result.stdout.strip()
+        match = re.search(r"LibreOffice\s+(\d+\.\d+(?:\.\d+)*)", version_str)
+        if not match:
+            raise ValueError(f"Can't parse LibreOffice version from: {version_str}.")
+
+        # LibreOffice uses numeric versions, including calendar versions (24+).
+        # Compare numerically without requiring the optional packaging library.
+        current_version = tuple(int(part) for part in match.group(1).split("."))
+        min_version = tuple(int(part) for part in MIN_VERSION.split("."))
+        if current_version < min_version:
+            raise RuntimeError(
+                f"LibreOffice version {match.group(1)} is below minimum required "
+                f"version {MIN_VERSION}."
+            )
 
     def convert(
         self,
@@ -142,16 +176,30 @@ class LibreOfficeConverter:
                 - `'html'`: HTML Document
                 - `'odt'`: OpenDocument Text
                 - `'txt'`: Plain Text
+
+                Also accepts LibreOffice's `extension:filter[:options]` syntax,
+                for example `'pdf:writer_pdf_Export'` or
+                `'txt:Text (encoded):UTF8'`. Filter names and options are passed
+                through unchanged; the extension determines the output filename.
             overwrite: If `True`, overwrites existing files in output directory.
-                If `False`, raises error if output file already exists.
+                If `False`, raises error if output file already exists. Existing
+                output is preserved if LibreOffice fails to convert the input.
 
         Returns:
             Path | Sequence[Path]: For single file input, returns Path to the
                 converted file. For multiple files, returns list of Paths.
 
         Raises:
+            FileNotFoundError: If an input file is missing or is not a file.
             FileExistsError: If output file exists and overwrite=False.
-            RuntimeError: If LibreOffice conversion fails.
+            ValueError: If format does not start with a valid file extension.
+            RuntimeError: If LibreOffice conversion fails or times out.
+
+        Note:
+            Each file is converted with a temporary, isolated LibreOffice user
+            profile, independent of an open desktop session or other conversions.
+            Personal LibreOffice settings and extensions are not used. Batch
+            inputs are processed sequentially, with a new process for each file.
 
         Examples:
             Single file conversion:
@@ -178,21 +226,26 @@ class LibreOfficeConverter:
                 print(f"Converted: {path}")
             ```
         """
-        output_dir = Path(os.path.expanduser(str(output_dir)))
-        if not output_dir.exists():
-            output_dir.mkdir(parents=True)
+        extension = format.split(":", 1)[0]
+        if not re.fullmatch(r"[A-Za-z0-9]+", extension):
+            raise ValueError(
+                "format must be an extension or extension:filter[:options], "
+                f"got {format!r}."
+            )
+        output_dir = Path(output_dir).expanduser()
+        output_dir.mkdir(parents=True, exist_ok=True)
 
         # Handle single input file
         if isinstance(input_files, (str, Path)):
-            input_path = Path(os.path.expanduser(str(input_files)))
-            if not input_path.exists():
+            input_path = Path(input_files).expanduser()
+            if not input_path.is_file():
                 raise FileNotFoundError(f"Input file not found: {input_path}.")
             return self._convert_single_file(input_path, output_dir, format, overwrite)
 
         # Handle multiple input files
-        input_paths = [Path(os.path.expanduser(str(f))) for f in input_files]
+        input_paths = [Path(f).expanduser() for f in input_files]
         for path in input_paths:
-            if not path.exists():
+            if not path.is_file():
                 raise FileNotFoundError(f"Input file not found: {path}.")
 
         return [
@@ -204,7 +257,8 @@ class LibreOfficeConverter:
         self, input_file: Path, output_dir: Path, format: str, overwrite: bool
     ) -> Path:
         """Convert a single file using LibreOffice."""
-        output_file = output_dir / f"{input_file.stem}.{format}"
+        extension = format.split(":", 1)[0]
+        output_file = output_dir / f"{input_file.stem}.{extension}"
 
         if output_file.exists() and not overwrite:
             raise FileExistsError(
@@ -212,33 +266,51 @@ class LibreOfficeConverter:
                 "Use overwrite=True to force."
             )
 
-        cmd = [
-            str(self.executable_path),
-            "--invisible",
-            "--headless",
-            "--nologo",
-            "--convert-to",
-            format,
-            "--outdir",
-            str(output_dir),
-            str(input_file),
-        ]
-
-        try:
-            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-
-            if not output_file.exists():
+        # Stage output so an old file cannot be mistaken for a successful export.
+        # Keep it on the destination filesystem for the final file replacement.
+        with tempfile.TemporaryDirectory(prefix=".rtflite-", dir=output_dir) as tmpdir:
+            work_dir = Path(tmpdir).resolve()
+            converted_dir = work_dir / "output"
+            converted_dir.mkdir()
+            cmd = [
+                str(self.executable_path),
+                f"-env:UserInstallation={(work_dir / 'profile').as_uri()}",
+                "--headless",
+                "--nologo",
+                "--norestore",
+                "--convert-to",
+                format,
+                "--outdir",
+                str(converted_dir),
+                str(input_file.absolute()),
+            ]
+            result = self._run_command(cmd, "conversion")
+            converted_file = converted_dir / output_file.name
+            if not converted_file.is_file():
                 raise RuntimeError(
                     f"Conversion failed: Output file not created.\n"
                     f"Command output: {result.stdout}\n"
                     f"Error output: {result.stderr}"
                 )
 
-            return output_file
-
-        except subprocess.CalledProcessError as e:
-            raise RuntimeError(
-                f"LibreOffice conversion failed:\n"
-                f"Command output: {e.stdout}\n"
-                f"Error output: {e.stderr}"
-            ) from e
+            # Include companion files/directories created by formats such as HTML.
+            generated_paths = list(converted_dir.iterdir())
+            if not overwrite:
+                for path in generated_paths:
+                    destination = output_dir / path.name
+                    if destination.exists():
+                        raise FileExistsError(
+                            f"Output file already exists: {destination}. "
+                            "Use overwrite=True to force."
+                        )
+            for path in generated_paths:
+                if path == converted_file:
+                    continue
+                destination = output_dir / path.name
+                if path.is_dir():
+                    shutil.copytree(path, destination, dirs_exist_ok=overwrite)
+                else:
+                    path.replace(destination)
+            converted_file.replace(output_file)
+
+        return output_file

{rtflite-2.5.3 → rtflite-2.6.0}/src/rtflite/encode.py

@@ -168,7 +168,7 @@ class RTFDocument(BaseModel):
             "header for that section."
         ),
     )
-    rtf_body: RTFBody | Sequence[RTFBody] | None = Field(
+    rtf_body: RTFBody | list[RTFBody] | None = Field(
         default_factory=lambda: RTFBody(),
         description=(
             "Table body section settings including column widths and "
@@ -196,6 +196,17 @@ class RTFDocument(BaseModel):
             return [v]
         return v
 
+    @field_validator("rtf_body", mode="before")
+    def normalize_rtf_body_sequence(cls, v):
+        """Convert non-list body sequences to lists before validation."""
+        if (
+            v is not None
+            and not isinstance(v, (RTFBody, list, str, bytes, bytearray))
+            and isinstance(v, Sequence)
+        ):
+            return list(v)
+        return v
+
     @model_validator(mode="before")
     @classmethod
     def validate_dataframe(cls, values):
@@ -301,6 +312,15 @@ class RTFDocument(BaseModel):
             ):
                 self._validate_section_columns(section_df, section_body, i)
         else:
+            if self.rtf_body is None:
+                raise ValueError("When df is a single DataFrame, rtf_body is required")
+            if isinstance(self.rtf_body, list):
+                if len(self.rtf_body) != 1:
+                    raise ValueError(
+                        "When df is a single DataFrame, rtf_body must be a "
+                        "single RTFBody"
+                    )
+                self.rtf_body = self.rtf_body[0]
             # Single section validation (existing logic)
             self._validate_section_columns(self.df, self.rtf_body, 0)
 
@@ -554,9 +574,9 @@ class RTFDocument(BaseModel):
             ```
 
         Note:
-            LibreOffice may create a companion directory (for example
-            `report.html_files`) for embedded resources. When present, it is moved
-            alongside the requested output path.
+            LibreOffice may create companion image files or directories for
+            embedded resources. These are saved alongside the requested output
+            path and must be kept with the HTML file.
         """
         target_path = Path(file_path).expanduser()
         target_path.parent.mkdir(parents=True, exist_ok=True)
@@ -582,12 +602,13 @@ class RTFDocument(BaseModel):
                         f"{type(converted)!r} with value {converted!r}."
                     )
                 html_path = converted
-                resources_dir = html_path.with_name(f"{html_path.name}_files")
                 shutil.move(str(html_path), target_path)
-                if resources_dir.is_dir():
-                    shutil.move(
-                        str(resources_dir), target_path.parent / resources_dir.name
-                    )
+                for resource in Path(convert_tmpdir).iterdir():
+                    destination = target_path.parent / resource.name
+                    if resource.is_dir():
+                        shutil.copytree(resource, destination, dirs_exist_ok=True)
+                    else:
+                        shutil.move(str(resource), destination)
 
         print(target_path)