pseudonymize 0.2.1__tar.gz → 0.3.0__tar.gz

{pseudonymize-0.2.1 → pseudonymize-0.3.0}/.agents/PRIVATE_RELEASE_PLAN.md

@@ -109,7 +109,7 @@ Tag: v0.2.1
 PyPI upload verified: Pending workflow
 7-day metrics: 
 28-day metrics: 
-Status: Ready
+Status: Released
 
 Implementation started: 2026-08-21
 Starting commit: 3205c22ef6143aa8ae38fa2db9eea64fc237777d
@@ -128,3 +128,22 @@ PyPI upload verified: Pending workflow
 28-day metrics: 
 Status: Released
 
+### 0.3.0: Document inspection
+
+Implementation started: 2026-08-22
+Starting commit: 54a8b7d97ef1f61ebae722d902fa2d31797efb0e
+Starting PyPI version: 0.2.1
+Baseline downloads day/week/month: 0/0/0
+Baseline stars/forks/watchers: 0/0/0
+Files changed: 10
+Compatibility tests added: Yes
+Artifact smoke environments: Win local isolated wheel
+Known limitations: Extract-only; no format-preserving rewriting yet.
+Deferred items: Format-preserving rewrite deferred to 0.4.0.
+Release commit: TBD
+Tag: v0.3.0
+PyPI upload verified: Pending workflow
+7-day metrics: 
+28-day metrics: 
+Status: Ready
+

{pseudonymize-0.2.1 → pseudonymize-0.3.0}/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes follow Keep a Changelog and Semantic Versioning.
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-08-22
+
+### Added
+
+- Added `pdf` extra (using `pdfminer.six`) for PDF text and coordinate extraction.
+- Added `office` extra (using `python-docx`, `openpyxl`, `python-pptx`) for DOCX, XLSX, and PPTX inspection.
+- Introduced `CoordinateLocation` and `StructuralLocation` for granular source tracking in complex file formats.
+
 ## [0.2.1] - 2026-08-22
 
 ### Changed

{pseudonymize-0.2.1 → pseudonymize-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pseudonymize
-Version: 0.2.1
+Version: 0.3.0
 Summary: Local-first PII pseudonymization for text, structured data, and LLM payloads.
 Project-URL: Homepage, https://github.com/ma2za/pseudonymize
 Project-URL: Documentation, https://ma2za.github.io/pseudonymize/
@@ -28,6 +28,12 @@ Provides-Extra: ml
 Requires-Dist: huggingface-hub>=1.28.0; extra == 'ml'
 Requires-Dist: onnxruntime>=1.29.0; extra == 'ml'
 Requires-Dist: tokenizers>=0.23.1; extra == 'ml'
+Provides-Extra: office
+Requires-Dist: openpyxl>=3.1.0; extra == 'office'
+Requires-Dist: python-docx>=1.1.0; extra == 'office'
+Requires-Dist: python-pptx>=1.0.0; extra == 'office'
+Provides-Extra: pdf
+Requires-Dist: pdfminer-six>=20240706; extra == 'pdf'
 Description-Content-Type: text/markdown
 
 # Pseudonymize

{pseudonymize-0.2.1 → pseudonymize-0.3.0}/ROADMAP.md

@@ -13,7 +13,8 @@ publishable without requiring unfinished later layers.
 | `0.1.0b1` | Published | Core API freeze and production-oriented examples |
 | `0.1.0rc1` | Published | External installation and release validation |
 | `0.1.0` | Published | First stable text and machine-readable release |
-| `0.2.0` | Next | Optional local machine learning identification for PII |
+| `0.2.0` | Published | Optional local machine learning identification for PII |
+| `0.3.0` | Next | Document inspection (PDF, DOCX, XLSX, PPTX) |
 
 Alpha releases optimize for the cleanest safe architecture, not backward compatibility. They may
 remove, rename, or replace public APIs without aliases or shims. Material changes are documented,

{pseudonymize-0.2.1 → pseudonymize-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pseudonymize"
-version = "0.2.1"
+version = "0.3.0"
 description = "Local-first PII pseudonymization for text, structured data, and LLM payloads."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -43,12 +43,20 @@ ml = [
     "onnxruntime>=1.29.0",
     "tokenizers>=0.23.1",
 ]
+office = [
+    "openpyxl>=3.1.0",
+    "python-docx>=1.1.0",
+    "python-pptx>=1.0.0",
+]
+pdf = [
+    "pdfminer.six>=20240706",
+]
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/pseudonymize"]
 
 [dependency-groups]
-test = ["hypothesis>=6", "pytest>=8", "pytest-benchmark>=5", "pytest-cov>=5"]
+test = ["hypothesis>=6", "pytest>=8", "pytest-benchmark>=5", "pytest-cov>=5", "fpdf2>=2.7.9"]
 quality = ["mypy>=1.11", "pre-commit>=4", "ruff>=0.9"]
 docs = ["mkdocs-material>=9", "mkdocstrings[python]>=1.0.6"]
 release = ["build>=1", "twine>=6"]
@@ -81,7 +89,11 @@ files = ["src", "tests", "scripts"]
 module = [
     "numpy.*",
     "onnxruntime.*",
-    "tokenizers.*"
+    "tokenizers.*",
+    "pdfminer.*",
+    "docx.*",
+    "pptx.*",
+    "openpyxl.*"
 ]
 ignore_missing_imports = true
 follow_imports = "skip"

{pseudonymize-0.2.1 → pseudonymize-0.3.0}/src/pseudonymize/document.py

@@ -68,7 +68,43 @@ class CSVCellLocation:
             raise ValueError("CSV row and column indexes must be non-negative")
 
 
-SourceLocation: TypeAlias = TextOffsetLocation | JSONPathLocation | CSVCellLocation
+@dataclass(frozen=True, slots=True)
+class CoordinateLocation:
+    page: int
+    x0: float
+    y0: float
+    x1: float
+    y1: float
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.page, int) or isinstance(self.page, bool) or self.page < 0:
+            raise ValueError("page must be a non-negative integer")
+        for val in (self.x0, self.y0, self.x1, self.y1):
+            if not isinstance(val, (int, float)) or isinstance(val, bool) or not isfinite(val):
+                raise TypeError("coordinates must be finite numbers")
+        if self.x0 > self.x1 or self.y0 > self.y1:
+            raise ValueError("coordinates must describe a valid bounding box")
+
+
+@dataclass(frozen=True, slots=True)
+class StructuralLocation:
+    path: tuple[str | int, ...]
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "path", tuple(self.path))
+        if any(not isinstance(part, (str, int)) or isinstance(part, bool) for part in self.path):
+            raise TypeError("structural path parts must be strings or integers")
+        if any(isinstance(part, int) and part < 0 for part in self.path):
+            raise ValueError("structural path indexes must be non-negative")
+
+
+SourceLocation: TypeAlias = (
+    TextOffsetLocation
+    | JSONPathLocation
+    | CSVCellLocation
+    | CoordinateLocation
+    | StructuralLocation
+)
 
 
 @dataclass(frozen=True, slots=True)
@@ -83,7 +119,16 @@ class ContentBlock:
             raise ValueError("block id must not be empty")
         if not isinstance(self.text, str):
             raise TypeError("block text must be a string")
-        if not isinstance(self.location, (TextOffsetLocation, JSONPathLocation, CSVCellLocation)):
+        if not isinstance(
+            self.location,
+            (
+                TextOffsetLocation,
+                JSONPathLocation,
+                CSVCellLocation,
+                CoordinateLocation,
+                StructuralLocation,
+            ),
+        ):
             raise TypeError("block location must be a supported source location")
         object.__setattr__(self, "metadata", _metadata(self.metadata))
 

{pseudonymize-0.2.1 → pseudonymize-0.3.0}/src/pseudonymize/engine.py

@@ -467,8 +467,20 @@ def _processing_adapters(
     output_adapter: OutputAdapter | None,
 ) -> tuple[InputAdapter[Path], OutputAdapter]:
     if input_adapter is None and output_adapter is None:
-        adapter = BuiltinFileAdapter(select_file_format(source, format), encoding)
-        return adapter, adapter
+        selected_format = select_file_format(source, format)
+        if selected_format == FileFormat.PDF:
+            from pseudonymize.inspection.pdf import PDFInspectionAdapter
+
+            pdf_adapter = PDFInspectionAdapter()
+            return pdf_adapter, pdf_adapter
+        elif selected_format in (FileFormat.DOCX, FileFormat.XLSX, FileFormat.PPTX):
+            from pseudonymize.inspection.office import OfficeInspectionAdapter
+
+            office_adapter = OfficeInspectionAdapter(selected_format)
+            return office_adapter, office_adapter
+        else:
+            builtin_adapter = BuiltinFileAdapter(selected_format, encoding)
+            return builtin_adapter, builtin_adapter
     if input_adapter is None or output_adapter is None:
         raise ValueError("custom file processing requires input and output adapters")
     if format is not None or encoding is not None:
@@ -483,7 +495,17 @@ def _inspection_adapter(
     input_adapter: InputAdapter[Path] | None,
 ) -> InputAdapter[Path]:
     if input_adapter is None:
-        return BuiltinFileAdapter(select_file_format(source, format), encoding)
+        selected_format = select_file_format(source, format)
+        if selected_format == FileFormat.PDF:
+            from pseudonymize.inspection.pdf import PDFInspectionAdapter
+
+            return PDFInspectionAdapter()
+        elif selected_format in (FileFormat.DOCX, FileFormat.XLSX, FileFormat.PPTX):
+            from pseudonymize.inspection.office import OfficeInspectionAdapter
+
+            return OfficeInspectionAdapter(selected_format)
+        else:
+            return BuiltinFileAdapter(selected_format, encoding)
     if format is not None or encoding is not None:
         raise ValueError("custom adapters cannot be combined with format or encoding")
     return input_adapter

{pseudonymize-0.2.1 → pseudonymize-0.3.0}/src/pseudonymize/formats.py

@@ -32,6 +32,10 @@ class FileFormat(StrEnum):
     JSON = "json"
     JSONL = "jsonl"
     CSV = "csv"
+    PDF = "pdf"
+    DOCX = "docx"
+    XLSX = "xlsx"
+    PPTX = "pptx"
 
 
 _SUFFIX_FORMATS = {
@@ -43,6 +47,10 @@ _SUFFIX_FORMATS = {
     ".jsonl": FileFormat.JSONL,
     ".ndjson": FileFormat.JSONL,
     ".csv": FileFormat.CSV,
+    ".pdf": FileFormat.PDF,
+    ".docx": FileFormat.DOCX,
+    ".xlsx": FileFormat.XLSX,
+    ".pptx": FileFormat.PPTX,
 }
 _CSV_LIMIT_LOCK = threading.Lock()
 

pseudonymize-0.3.0/src/pseudonymize/inspection/__init__.py

@@ -0,0 +1,4 @@
+from pseudonymize.inspection.office import OfficeInspectionAdapter
+from pseudonymize.inspection.pdf import PDFInspectionAdapter
+
+__all__ = ["OfficeInspectionAdapter", "PDFInspectionAdapter"]

pseudonymize-0.3.0/src/pseudonymize/inspection/office.py

@@ -0,0 +1,112 @@
+from pathlib import Path
+
+from pseudonymize.document import ContentBlock, Document, StructuralLocation
+from pseudonymize.exceptions import AdapterContractError, AdapterExecutionError
+
+try:
+    import docx
+    import openpyxl
+    import pptx
+
+    HAS_OFFICE = True
+except ImportError:
+    HAS_OFFICE = False
+
+
+class OfficeInspectionAdapter:
+    """Extracts text from Office documents (DOCX, XLSX, PPTX) for inspection."""
+
+    def __init__(self, format_hint: str) -> None:
+        if not HAS_OFFICE:
+            raise RuntimeError(
+                "The Office adapter requires the 'office' extra. "
+                "Install it with `pip install pseudonymize[office]`."
+            )
+        self.format_hint = format_hint.lower()
+        if self.format_hint not in ("docx", "xlsx", "pptx"):
+            raise ValueError(f"Unsupported Office format hint: {format_hint}")
+
+    def extract(self, source: Path) -> Document:
+        blocks: list[ContentBlock] = []
+        try:
+            if self.format_hint == "docx":
+                self._extract_docx(source, blocks)
+            elif self.format_hint == "xlsx":
+                self._extract_xlsx(source, blocks)
+            elif self.format_hint == "pptx":
+                self._extract_pptx(source, blocks)
+        except Exception as e:
+            raise AdapterExecutionError(f"Failed to read Office document: {e}") from e
+
+        metadata = {"format": self.format_hint}
+        return Document("file", tuple(blocks), metadata)
+
+    def _extract_docx(self, source: Path, blocks: list[ContentBlock]) -> None:
+        doc = docx.Document(str(source))
+        for para_index, para in enumerate(doc.paragraphs):
+            text = para.text.strip()
+            if text:
+                blocks.append(
+                    ContentBlock(
+                        id=f"para-{para_index:06d}",
+                        text=text,
+                        location=StructuralLocation(("paragraph", para_index)),
+                    )
+                )
+        # We can also extract tables if needed, for simplicity we stick to paragraphs and tables
+        for table_index, table in enumerate(doc.tables):
+            for row_index, row in enumerate(table.rows):
+                for col_index, cell in enumerate(row.cells):
+                    text = cell.text.strip()
+                    if text:
+                        blocks.append(
+                            ContentBlock(
+                                id=f"table-{table_index:06d}-row-{row_index:06d}-col-{col_index:06d}",
+                                text=text,
+                                location=StructuralLocation(
+                                    ("table", table_index, "row", row_index, "column", col_index)
+                                ),
+                            )
+                        )
+
+    def _extract_xlsx(self, source: Path, blocks: list[ContentBlock]) -> None:
+        wb = openpyxl.load_workbook(filename=source, data_only=True)
+        for sheet_index, sheet_name in enumerate(wb.sheetnames):
+            sheet = wb[sheet_name]
+            for row_index, row in enumerate(sheet.iter_rows(values_only=True)):
+                for col_index, cell_value in enumerate(row):
+                    if cell_value is not None:
+                        text = str(cell_value).strip()
+                        if text:
+                            blocks.append(
+                                ContentBlock(
+                                    id=f"sheet-{sheet_index:06d}-row-{row_index:06d}-col-{col_index:06d}",
+                                    text=text,
+                                    location=StructuralLocation(
+                                        ("sheet", sheet_name, "row", row_index, "column", col_index)
+                                    ),
+                                )
+                            )
+
+    def _extract_pptx(self, source: Path, blocks: list[ContentBlock]) -> None:
+        prs = pptx.Presentation(str(source))
+        for slide_index, slide in enumerate(prs.slides):
+            for shape_index, shape in enumerate(slide.shapes):
+                if hasattr(shape, "text") and shape.text:
+                    text = shape.text.strip()
+                    if text:
+                        blocks.append(
+                            ContentBlock(
+                                id=f"slide-{slide_index:06d}-shape-{shape_index:06d}",
+                                text=text,
+                                location=StructuralLocation(
+                                    ("slide", slide_index, "shape", shape_index)
+                                ),
+                            )
+                        )
+
+    def render(self, document: Document) -> bytes:
+        raise AdapterContractError(
+            f"{self.format_hint.upper()} format-preserving rendering is not yet supported. "
+            "Office extraction is for inspection only."
+        )

pseudonymize-0.3.0/src/pseudonymize/inspection/pdf.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+
+from pseudonymize.document import ContentBlock, CoordinateLocation, Document
+from pseudonymize.exceptions import AdapterContractError, AdapterExecutionError
+
+try:
+    from pdfminer.high_level import extract_pages
+    from pdfminer.layout import LTTextContainer
+
+    HAS_PDF = True
+except ImportError:
+    HAS_PDF = False
+
+
+class PDFInspectionAdapter:
+    """Extracts text from PDF documents for inspection-only pipelines."""
+
+    def __init__(self) -> None:
+        if not HAS_PDF:
+            raise RuntimeError(
+                "The PDF adapter requires the 'pdf' extra. "
+                "Install it with `pip install pseudonymize[pdf]`."
+            )
+
+    def extract(self, source: Path) -> Document:
+        blocks: list[ContentBlock] = []
+        try:
+            with source.open("rb") as f:
+                for page_index, page_layout in enumerate(extract_pages(f)):
+                    for element in page_layout:
+                        if isinstance(element, LTTextContainer):
+                            text = element.get_text().strip()
+                            if text:
+                                # PDFMiner bounding box is (x0, y0, x1, y1)
+                                # where y0 is distance from bottom
+                                x0, y0, x1, y1 = element.bbox
+                                location = CoordinateLocation(
+                                    page=page_index,
+                                    x0=float(x0),
+                                    y0=float(y0),
+                                    x1=float(x1),
+                                    y1=float(y1),
+                                )
+                                blocks.append(
+                                    ContentBlock(
+                                        id=f"page-{page_index}-box-{len(blocks):06d}",
+                                        text=text,
+                                        location=location,
+                                    )
+                                )
+        except Exception as e:
+            raise AdapterExecutionError(f"Failed to read PDF: {e}") from e
+
+        metadata = {"format": "pdf"}
+        return Document("file", tuple(blocks), metadata)
+
+    def render(self, document: Document) -> bytes:
+        raise AdapterContractError(
+            "PDF format-preserving rendering is not yet supported. "
+            "PDF extraction is for inspection only."
+        )

{pseudonymize-0.2.1 → pseudonymize-0.3.0}/tests/compatibility/test_b1_contract.py

@@ -117,6 +117,10 @@ def test_frozen_enums_and_data_models() -> None:
         "json",
         "jsonl",
         "csv",
+        "pdf",
+        "docx",
+        "xlsx",
+        "pptx",
     ]
     expected_fields = {
         Document: ("id", "blocks", "metadata"),

pseudonymize-0.3.0/tests/integration/test_inspection_adapters.py

@@ -0,0 +1,141 @@
+from pathlib import Path
+
+import pytest
+
+from pseudonymize.engine import Pseudonymizer
+from pseudonymize.formats import FileFormat
+from pseudonymize.policy import Policy
+
+# Optional imports for generators
+try:
+    import fpdf
+
+    HAS_FPDF = True
+except ImportError:
+    HAS_FPDF = False
+
+try:
+    import docx
+    import openpyxl
+    import pptx
+
+    HAS_OFFICE = True
+except ImportError:
+    HAS_OFFICE = False
+
+pytestmark = pytest.mark.integration
+
+
+@pytest.fixture
+def test_pdf_path(tmp_path: Path) -> Path:
+    if not HAS_FPDF:
+        pytest.skip("fpdf2 not installed")
+    path = tmp_path / "test.pdf"
+    pdf = fpdf.FPDF()
+    pdf.add_page()
+    pdf.set_font("helvetica", size=12)
+    pdf.cell(text="Contact me at alice@example.com for more info.")
+    pdf.ln()
+    pdf.cell(text="   ")
+    pdf.output(str(path))
+    return path
+
+
+@pytest.fixture
+def test_docx_path(tmp_path: Path) -> Path:
+    if not HAS_OFFICE:
+        pytest.skip("python-docx not installed")
+    path = tmp_path / "test.docx"
+    doc = docx.Document()
+    doc.add_paragraph("Hello, my email is bob@example.com.")
+    doc.add_paragraph("   ")  # Empty text
+    table = doc.add_table(rows=2, cols=2)
+    table.rows[0].cells[0].text = "Header"
+    table.rows[0].cells[1].text = "Value"
+    table.rows[1].cells[0].text = "Data"
+    table.rows[1].cells[1].text = "   "  # Empty text
+    doc.save(str(path))
+    return path
+
+
+@pytest.fixture
+def test_xlsx_path(tmp_path: Path) -> Path:
+    if not HAS_OFFICE:
+        pytest.skip("openpyxl not installed")
+    path = tmp_path / "test.xlsx"
+    wb = openpyxl.Workbook()
+    ws = wb.active
+    ws["A1"] = "User Email"
+    ws["B1"] = "charlie@example.com"
+    ws["C1"] = None
+    ws["D1"] = "   "
+    wb.save(path)
+    return path
+
+
+@pytest.fixture
+def test_pptx_path(tmp_path: Path) -> Path:
+    if not HAS_OFFICE:
+        pytest.skip("python-pptx not installed")
+    path = tmp_path / "test.pptx"
+    prs = pptx.Presentation()
+    slide = prs.slides.add_slide(prs.slide_layouts[0])
+    slide.shapes.title.text = "Presentation"
+    slide.placeholders[1].text = "Reach us at diana@example.com"
+    slide.shapes.add_shape(pptx.enum.shapes.MSO_SHAPE.RECTANGLE, 0, 0, 100, 100)  # No text
+    tb = slide.shapes.add_textbox(0, 0, 100, 100)
+    tb.text = "   "  # Empty text
+    prs.save(str(path))
+    return path
+
+
+def test_inspect_pdf(test_pdf_path: Path) -> None:
+    engine = Pseudonymizer(
+        policy=Policy.default(),
+    )
+    result = engine.inspect_file(test_pdf_path, format=FileFormat.PDF)
+    assert result.statistics.detections_found >= 1
+    assert any(d.entity_type == "EMAIL" for d in result.detections)
+
+
+def test_inspect_docx(test_docx_path: Path) -> None:
+    engine = Pseudonymizer(
+        policy=Policy.default(),
+    )
+    result = engine.inspect_file(test_docx_path, format=FileFormat.DOCX)
+    assert result.statistics.detections_found >= 1
+    assert any(d.entity_type == "EMAIL" for d in result.detections)
+
+
+def test_inspect_xlsx(test_xlsx_path: Path) -> None:
+    engine = Pseudonymizer(
+        policy=Policy.default(),
+    )
+    result = engine.inspect_file(test_xlsx_path, format=FileFormat.XLSX)
+    assert result.statistics.detections_found >= 1
+    assert any(d.entity_type == "EMAIL" for d in result.detections)
+
+
+def test_inspect_pptx(test_pptx_path: Path) -> None:
+    engine = Pseudonymizer(
+        policy=Policy.default(),
+    )
+    result = engine.inspect_file(test_pptx_path, format=FileFormat.PPTX)
+    assert result.statistics.detections_found >= 1
+    assert any(d.entity_type == "EMAIL" for d in result.detections)
+
+
+def test_process_pdf_fails(test_pdf_path: Path, tmp_path: Path) -> None:
+    engine = Pseudonymizer(policy=Policy.default())
+    from pseudonymize.exceptions import AdapterExecutionError
+
+    with pytest.raises(AdapterExecutionError, match="output adapter failed during rendering"):
+        engine.process_file(test_pdf_path, tmp_path / "out.pdf", format=FileFormat.PDF)
+
+
+def test_process_docx_fails(test_docx_path: Path, tmp_path: Path) -> None:
+    engine = Pseudonymizer(policy=Policy.default())
+    from pseudonymize.exceptions import AdapterExecutionError
+
+    with pytest.raises(AdapterExecutionError, match="output adapter failed during rendering"):
+        engine.process_file(test_docx_path, tmp_path / "out.docx", format=FileFormat.DOCX)

{pseudonymize-0.2.1 → pseudonymize-0.3.0}/tests/unit/test_document.py

@@ -4,11 +4,13 @@ from typing import Any, cast
 
 import pytest
 
-from pseudonymize import (
+from pseudonymize.document import (
     ContentBlock,
+    CoordinateLocation,
     CSVCellLocation,
     Document,
     JSONPathLocation,
+    StructuralLocation,
     TextOffsetLocation,
 )
 
@@ -79,6 +81,9 @@ def test_location_values_are_immutable_and_validated() -> None:
         "content",
     )
     assert CSVCellLocation(0, 0).row == 0
+    assert CoordinateLocation(1, 0.0, 0.0, 10.0, 10.0).page == 1
+    assert StructuralLocation(("section", 1)).path == ("section", 1)
+
     with pytest.raises((TypeError, ValueError)):
         TextOffsetLocation(cast(int, True), 1)
     with pytest.raises(ValueError):
@@ -94,6 +99,18 @@ def test_location_values_are_immutable_and_validated() -> None:
     with pytest.raises(ValueError):
         CSVCellLocation(0, -1)
 
+    with pytest.raises(ValueError):
+        CoordinateLocation(-1, 0.0, 0.0, 1.0, 1.0)
+    with pytest.raises(TypeError):
+        CoordinateLocation(1, float("inf"), 0.0, 1.0, 1.0)
+    with pytest.raises(ValueError):
+        CoordinateLocation(1, 10.0, 10.0, 0.0, 0.0)
+
+    with pytest.raises(TypeError):
+        StructuralLocation(("doc", cast(Any, True)))
+    with pytest.raises(ValueError):
+        StructuralLocation(("doc", -1))
+
 
 def test_content_block_rejects_invalid_text_location_and_document_blocks() -> None:
     with pytest.raises(TypeError, match="text"):

{pseudonymize-0.2.1 → pseudonymize-0.3.0}/tests/unit/test_formats.py

@@ -44,7 +44,7 @@ def test_format_selection_rejects_unknown_values_without_guessing() -> None:
     with pytest.raises(UnsupportedFormatError, match="pass format explicitly"):
         select_file_format(Path("input.unknown"), None)
     with pytest.raises(UnsupportedFormatError, match="unsupported file format"):
-        select_file_format(Path("input.txt"), "pdf")
+        select_file_format(Path("input.txt"), "unknown")
 
 
 @pytest.mark.parametrize("format", [FileFormat.TEXT, FileFormat.MARKDOWN, FileFormat.LOG])