Merge pull request #24 from roskakori/23-fix-po-path-must-be-a-path

#23 Fix `AssertionError`: po_path must be a Path

Author: roskakori

CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+Version 0.2.5, 2025-04-29
+
+- Fix `AssertionError`: po_path must be a Path (#23)
+
 Version 0.2.4, 2025-04-29
 
 - Fix internal handling of default command line arguments (#21)

CONTRIBUTING.md

@@ -30,6 +30,7 @@ uv run pytest
 2. Test and build the distribution archives:
    ```bash
    $ uv run pytest
+   $ rm -rf dist
    $ uv build
    ```
 3. Tag a release (simply replace 0.x.x with the current version number):

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sanpo"
-version = "0.2.4"
+version = "0.2.5"
 description = "Sanitize PO files from gettext for version control"
 authors = [{ name = "Thomas Aglassinger", email = "[email protected]" }]
 requires-python = ">=3.9, <4"

sanpo/sanitize.py

@@ -4,6 +4,7 @@
 import re
 from collections.abc import Iterable
 from pathlib import Path
+from typing import Union
 
 _LINE_PATTERNS_TO_REMOVE = [
     re.compile(line)
@@ -22,16 +23,24 @@
 _log = logging.getLogger("sanpo")
 
 
-def sanitize_file(po_path: Path):
-    assert isinstance(po_path, Path), f"po_path must be a Path: {po_path!r}"
-    _log.info("sanitizing %s", po_path)
-    with po_path.open(encoding="utf-8") as po_file:
+def sanitize_file(po_path: Union[Path, str]):
+    actual_po_path = path_from(po_path)
+    _log.info("sanitizing %s", actual_po_path)
+    with actual_po_path.open(encoding="utf-8") as po_file:
         lines_to_write = list(sanitized_lines(po_file))
-    with po_path.open("w", encoding="utf-8") as po_file:
+    with actual_po_path.open("w", encoding="utf-8") as po_file:
         for line_to_write in lines_to_write:
             po_file.write(line_to_write)
 
 
+def path_from(po_path: Union[Path, str]) -> Path:
+    if isinstance(po_path, Path):
+        return po_path
+    if isinstance(po_path, str):
+        return Path(po_path)
+    raise TypeError(f"po_path must be a Path or str, but is {type(po_path)}: {po_path!r}")
+
+
 def sanitized_lines(source_lines: Iterable[str]) -> Iterable[str]:
     for line in source_lines:
         line_has_to_be_removed = any(

tests/test_command.py

@@ -21,9 +21,9 @@ def test_can_show_version(self):
     def test_can_sanitize_single_file(self):
         self.write_po_file(self.test_can_sanitize_single_file.__name__)
         initial_po_lines = self.po_lines()
-        self.assertEqual(main_without_logging_setup([self.po_path]), 0)
+        assert main_without_logging_setup([self.po_path]) == 0
         sanitized_po_lines = self.po_lines()
-        self.assertNotEqual(initial_po_lines, sanitized_po_lines)
+        assert initial_po_lines != sanitized_po_lines
 
     def test_can_sanitize_multiple_files(self):
         po_path_to_sanitized_po_lines_map = {}
@@ -35,24 +35,26 @@ def test_can_sanitize_multiple_files(self):
             po_path_to_sanitized_po_lines_map[self.po_path] = self.po_lines()
 
         po_paths_to_sanitize = list(po_path_to_sanitized_po_lines_map.keys())
-        self.assertEqual(main_without_logging_setup(po_paths_to_sanitize), 0)
+        assert main_without_logging_setup(po_paths_to_sanitize) == 0
 
         for po_path, initial_po_lines in po_path_to_sanitized_po_lines_map.items():
             sanitized_po_lines = self.po_lines(po_path)
-            self.assertNotEqual(sanitized_po_lines, initial_po_lines)
+            assert sanitized_po_lines != initial_po_lines
 
     def test_can_sanitize_none_arguments(self):
         self.write_po_file(self.test_can_sanitize_none_arguments.__name__)
         with patch("sys.argv", ["sanpo", str(self.po_path)]):
             assert main_without_logging_setup() == 0
 
-    def test_fails_on_non_existent_po_file(self):
-        self.assertEqual(main_without_logging_setup(["no_such.po"]), 1)
 
-    def test_fails_on_no_po_files(self):
-        with (
-            pytest.raises(SystemExit) as error,
-            patch("sys.argv", ["sanpo"]),
-        ):
-            main_without_logging_setup()
-        assert error.value.code == 2
+def test_fails_on_non_existent_po_file():
+    assert main_without_logging_setup(["no_such.po"]) == 1
+
+
+def test_fails_on_no_po_files():
+    with (
+        pytest.raises(SystemExit) as error,
+        patch("sys.argv", ["sanpo"]),
+    ):
+        main_without_logging_setup()
+    assert error.value.code == 2

tests/test_sanitize.py

@@ -1,32 +1,32 @@
 # Copyright (c) 2021, Thomas Aglassinger
 # All rights reserved. Distributed under the BSD 3-Clause License.
-from unittest import TestCase
+import pytest
 
 from sanpo.sanitize import sanitize_file, sanitized_lines
 from tests._common import PoFileTest
 
 
-class SanitizationTest(TestCase):
-    def test_can_remove_pointless_lines(self):
-        source_lines = [
-            r'"Project-Id-Version: PACKAGE VERSION\n"',
-            r'"Report-Msgid-Bugs-To: \n"',
-            r'"POT-Creation-Date: 2021-01-01\\n"',
-            r'"PO-Revision-Date: 2021-01-01\\n"',
-            r'"Last-Translator: FULL NAME EMAIL@ADDRESS\n"',
-            r'"Language-Team: LANGUAGE [email protected]\n"',
-            "PRESERVE",
-        ]
-        self.assertEqual(list(sanitized_lines(source_lines)), ["PRESERVE"])
-
-    def test_can_preserve_metadata_lines(self):
-        source_lines = [
-            r'"Project-Id-Version: some 1.2.3\n"',
-            r'"Report-Msgid-Bugs-To: [email protected]\n"',
-            r'"Last-Translator: John Doe [email protected]\n"',
-            r'"Language-Team: en [email protected]\n"',
-        ]
-        self.assertEqual(list(sanitized_lines(source_lines)), source_lines)
+def test_can_remove_pointless_lines():
+    source_lines = [
+        r'"Project-Id-Version: PACKAGE VERSION\n"',
+        r'"Report-Msgid-Bugs-To: \n"',
+        r'"POT-Creation-Date: 2021-01-01\\n"',
+        r'"PO-Revision-Date: 2021-01-01\\n"',
+        r'"Last-Translator: FULL NAME EMAIL@ADDRESS\n"',
+        r'"Language-Team: LANGUAGE [email protected]\n"',
+        "PRESERVE",
+    ]
+    assert list(sanitized_lines(source_lines)) == ["PRESERVE"]
+
+
+def test_can_preserve_metadata_lines():
+    source_lines = [
+        r'"Project-Id-Version: some 1.2.3\n"',
+        r'"Report-Msgid-Bugs-To: [email protected]\n"',
+        r'"Last-Translator: John Doe [email protected]\n"',
+        r'"Language-Team: en [email protected]\n"',
+    ]
+    assert list(sanitized_lines(source_lines)) == source_lines
 
 
 class TransformFileTest(PoFileTest):
@@ -35,4 +35,16 @@ def test_can_remove_pointless_lines_in_file(self):
         initial_po_lines = self.po_lines()
         sanitize_file(self.po_path)
         transformed_po_lines = self.po_lines()
-        self.assertNotEqual(initial_po_lines, transformed_po_lines)
+        assert initial_po_lines != transformed_po_lines
+
+    def test_can_sanitize_str_path(self):
+        self.write_po_file(self.test_can_sanitize_str_path.__name__)
+        initial_po_lines = self.po_lines()
+        sanitize_file(str(self.po_path))
+        transformed_po_lines = self.po_lines()
+        assert initial_po_lines != transformed_po_lines
+
+
+def test_fails_on_int_po_file():
+    with pytest.raises(TypeError, match="po_path must be a Path or str, but is <class 'int'>: 123"):
+        sanitize_file(123)