localizationkit 2.0.0__tar.gz → 3.0.1__tar.gz

{localizationkit-2.0.0 → localizationkit-3.0.1}/PKG-INFO

@@ -1,21 +1,23 @@
 Metadata-Version: 2.1
 Name: localizationkit
-Version: 2.0.0
+Version: 3.0.1
 Summary: String localization tests
 Home-page: https://github.com/Microsoft/localizationkit
 License: MIT
 Keywords: localization,strings,tests
 Author: Dale Myers
 Author-email: dalemy@microsoft.com
-Requires-Python: >=3.8,<4.0
+Requires-Python: >=3.11,<4.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: Utilities
@@ -98,7 +100,7 @@ for result in results:
         print("The following test failed:", result.name)
         print("Failures encountered:")
         for violation in result.violations:
-            print(violation)
+            print(violation[0]) # The other value in the tuple is the language code
 ```
 
 ### Not running the tests

{localizationkit-2.0.0 → localizationkit-3.0.1}/README.md

@@ -73,7 +73,7 @@ for result in results:
         print("The following test failed:", result.name)
         print("Failures encountered:")
         for violation in result.violations:
-            print(violation)
+            print(violation[0]) # The other value in the tuple is the language code
 ```
 
 ### Not running the tests

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/__init__.py

@@ -1,11 +1,10 @@
 """Toolkit for validation of localized strings."""
 
-import abc
-import difflib
 import inspect
-from typing import Any, Dict, List, Optional, Set, Type
+from typing import Type
 
 from localizationkit.configuration import Configuration
+from localizationkit.exceptions import LocalizationKitException
 from localizationkit.localization_types import LocalizedCollection, LocalizedString
 from localizationkit.utility_types import TestResult
 from localizationkit.tests.test_case import LocalizationTestCase
@@ -13,7 +12,7 @@ from localizationkit.tests.test_case import LocalizationTestCase
 from localizationkit import tests
 
 
-def _find_tests() -> List[Type[LocalizationTestCase]]:
+def _find_tests() -> list[Type[LocalizationTestCase]]:
     """Find all the tests."""
 
     test_module_names = [
@@ -21,8 +20,8 @@ def _find_tests() -> List[Type[LocalizationTestCase]]:
     ]
     test_modules = [getattr(tests, name) for name in test_module_names]
 
-    names_seen: Set[str] = set()
-    test_classes: List[Type[LocalizationTestCase]] = []
+    names_seen: set[str] = set()
+    test_classes: list[Type[LocalizationTestCase]] = []
 
     for module in test_modules:
 
@@ -40,7 +39,7 @@ def _find_tests() -> List[Type[LocalizationTestCase]]:
                 continue
 
             if reference.__name__ in names_seen:
-                raise Exception(
+                raise LocalizationKitException(
                     "At least 2 classes exist with the same name: " + reference.__name__
                 )
 
@@ -49,7 +48,7 @@ def _find_tests() -> List[Type[LocalizationTestCase]]:
     return test_classes
 
 
-def run_tests(configuration: Configuration, collection: LocalizedCollection) -> List[TestResult]:
+def run_tests(configuration: Configuration, collection: LocalizedCollection) -> list[TestResult]:
     """Run all tests."""
 
     test_classes = _find_tests()

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/configuration.py

@@ -1,6 +1,6 @@
 """Configuration for localization tests."""
 
-from typing import Any, cast, Dict, List
+from typing import Any, cast
 
 import toml
 
@@ -8,9 +8,9 @@ import toml
 class Configuration:
     """Holds all the configuration data."""
 
-    raw_config: Dict[str, Any]
+    raw_config: dict[str, Any]
 
-    def __init__(self, raw_config: Dict[str, Any]) -> None:
+    def __init__(self, raw_config: dict[str, Any]) -> None:
         self.raw_config = raw_config
 
     def default_language(self) -> str:
@@ -22,21 +22,21 @@ class Configuration:
         """
         return self.raw_config.get("default_language", "en")
 
-    def blacklist(self) -> List[str]:
+    def blacklist(self) -> list[str]:
         """Return the list of blacklisted tests.
 
         :returns: The blacklisted tests
         """
         return self.raw_config.get("blacklist", [])
 
-    def opt_in(self) -> List[str]:
+    def opt_in(self) -> list[str]:
         """Return the list of opted in tests.
 
         :returns: The opted in tests
         """
         return self.raw_config.get("opt_in", [])
 
-    def get_test_preferences(self, name: str) -> Dict[str, Any]:
+    def get_test_preferences(self, name: str) -> dict[str, Any]:
         """Get the preferences for a given test.
 
         :param name: The name of the test
@@ -55,4 +55,4 @@ class Configuration:
         """
 
         with open(file_path, encoding="utf-8") as config_file:
-            return Configuration(cast(Dict[str, Any], toml.load(config_file)))
+            return Configuration(cast(dict[str, Any], toml.load(config_file)))

localizationkit-3.0.1/localizationkit/exceptions.py

@@ -0,0 +1,9 @@
+"""Exception types."""
+
+
+class LocalizationKitException(Exception):
+    """Represents an exception from this library."""
+
+
+class DuplicateTestException(LocalizationKitException):
+    """Represents an exception where multiple tests with the same name appear."""

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/localization_types.py

@@ -1,7 +1,7 @@
 """Types for localization."""
 
 import re
-from typing import ClassVar, List, Pattern
+from typing import ClassVar, Pattern
 
 
 class LocalizedString:
@@ -13,9 +13,9 @@ class LocalizedString:
     :param language_code: The language code for the language the string is in
     """
 
-    _TOKEN_REGEX: ClassVar[
-        str
-    ] = r"(%(?:[0-9]+\$)?[0-9]*\.?[0-9]*(?:h|hh|l|ll|q|L|z|t|j){0,2}[dDuUxXoOfFeEgGcCsSaAp@])"
+    _TOKEN_REGEX: ClassVar[str] = (
+        r"(%(?:[0-9]+\$)?[0-9]*\.?[0-9]*(?:h|hh|l|ll|q|L|z|t|j){0,2}[dDuUxXoOfFeEgGcCsSaAp@])"
+    )
     _TOKEN_PATTERN: ClassVar[Pattern] = re.compile(_TOKEN_REGEX, flags=re.DOTALL)
 
     key: str
@@ -29,14 +29,14 @@ class LocalizedString:
         self.comment = comment
         self.language_code = language_code
 
-    def tokens(self) -> List[str]:
+    def tokens(self) -> list[str]:
         """Find and return the tokens in the string.
 
         :returns: The list of tokens in the string
         """
         return LocalizedString._TOKEN_PATTERN.findall(self.value)
 
-    def comment_tokens(self) -> List[str]:
+    def comment_tokens(self) -> list[str]:
         """Find and return the tokens in the comment string.
 
         :returns: The list of tokens in the comment string
@@ -64,12 +64,12 @@ class LocalizedCollection:
     :param localized_strings: The list of localized strings in the collection
     """
 
-    localized_strings: List[LocalizedString]
+    localized_strings: list[LocalizedString]
 
-    def __init__(self, localized_strings: List[LocalizedString]) -> None:
+    def __init__(self, localized_strings: list[LocalizedString]) -> None:
         self.localized_strings = localized_strings
 
-    def strings_for_key(self, key: str) -> List[LocalizedString]:
+    def strings_for_key(self, key: str) -> list[LocalizedString]:
         """Return all the strings matching the key
 
         i.e. This will have a list of strings with identical keys, but different
@@ -79,7 +79,7 @@ class LocalizedCollection:
         """
         return [string for string in self.localized_strings if string.key == key]
 
-    def strings_for_language(self, language_code: str) -> List[LocalizedString]:
+    def strings_for_language(self, language_code: str) -> list[LocalizedString]:
         """Return all the strings matching the language code
 
         :returns: The list of strings with the matching language code
@@ -88,7 +88,7 @@ class LocalizedCollection:
             string for string in self.localized_strings if string.language_code == language_code
         ]
 
-    def languages(self) -> List[str]:
+    def languages(self) -> list[str]:
         """Return the list of languages in the collection.
 
         :returns: The list of langauges in the collection

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/tests/comment_linebreaks.py

@@ -1,6 +1,6 @@
 """Checks for comments."""
 
-from typing import Any, Dict, List
+from typing import Any
 
 from localizationkit.tests.test_case import LocalizationTestCase
 
@@ -13,14 +13,14 @@ class CommentLinebreaks(LocalizationTestCase):
         return "comment_linebreaks"
 
     @classmethod
-    def default_settings(cls) -> Dict[str, Any]:
+    def default_settings(cls) -> dict[str, Any]:
         return {}
 
     @classmethod
     def is_opt_in(cls) -> bool:
         return True
 
-    def run_test(self) -> List[str]:
+    def run_test(self) -> list[tuple[str, str]]:
         violations = []
 
         for string in self.collection.strings_for_language(self.configuration.default_language()):
@@ -29,6 +29,6 @@ class CommentLinebreaks(LocalizationTestCase):
                 continue
 
             if "\n" in string.comment or "\r" in string.comment:
-                violations.append(f"Comment contains linebreaks: {string}")
+                violations.append((f"Comment contains linebreaks: {string}", string.language_code))
 
         return violations

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/tests/comment_similarity.py

@@ -1,7 +1,7 @@
 """Comment similarity."""
 
 import difflib
-from typing import Any, Dict, List
+from typing import Any
 
 from localizationkit.tests.test_case import LocalizationTestCase
 
@@ -14,10 +14,10 @@ class CheckCommentSimilarity(LocalizationTestCase):
         return "comment_similarity"
 
     @classmethod
-    def default_settings(cls) -> Dict[str, Any]:
+    def default_settings(cls) -> dict[str, Any]:
         return {"maximum_similarity_ratio": 0.5}
 
-    def run_test(self) -> List[str]:
+    def run_test(self) -> list[tuple[str, str]]:
 
         maximum_similarity_ratio = self.get_setting("maximum_similarity_ratio")
 
@@ -31,7 +31,10 @@ class CheckCommentSimilarity(LocalizationTestCase):
 
             if similarity > maximum_similarity_ratio:
                 violations.append(
-                    f"Value and comment exceeded similarity ratio of {maximum_similarity_ratio}: {string}"
+                    (
+                        f"Value and comment exceeded similarity ratio of {maximum_similarity_ratio}: {string}",
+                        string.language_code,
+                    )
                 )
                 continue
 

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/tests/duplicate_keys.py

@@ -1,6 +1,6 @@
 """Duplicate keys."""
 
-from typing import Any, Dict, List, Set
+from typing import Any
 
 from localizationkit.tests.test_case import LocalizationTestCase
 
@@ -13,10 +13,10 @@ class DuplicateKeys(LocalizationTestCase):
         return "duplicate_keys"
 
     @classmethod
-    def default_settings(cls) -> Dict[str, Any]:
+    def default_settings(cls) -> dict[str, Any]:
         return {"all_languages": False}
 
-    def run_test(self) -> List[str]:
+    def run_test(self) -> list[tuple[str, str]]:
 
         violations = []
 
@@ -29,13 +29,16 @@ class DuplicateKeys(LocalizationTestCase):
 
         for language in languages_to_check:
 
-            keys: Set[str] = set()
+            keys: set[str] = set()
 
             for string in self.collection.strings_for_language(language):
 
                 if string.key in keys:
                     violations.append(
-                        f"The key '{string.key}' appears for multiple strings. e.g. {string}"
+                        (
+                            f"The key '{string.key}' appears for multiple strings. e.g. {string}",
+                            string.language_code,
+                        )
                     )
                     continue
 

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/tests/has_comments.py

@@ -1,6 +1,6 @@
 """Checks for comments."""
 
-from typing import Any, Dict, List
+from typing import Any
 
 from localizationkit.tests.test_case import LocalizationTestCase
 
@@ -13,10 +13,10 @@ class HasComments(LocalizationTestCase):
         return "has_comments"
 
     @classmethod
-    def default_settings(cls) -> Dict[str, Any]:
+    def default_settings(cls) -> dict[str, Any]:
         return {"minimum_comment_length": 30, "minimum_comment_words": 10}
 
-    def run_test(self) -> List[str]:
+    def run_test(self) -> list[tuple[str, str]]:
 
         minimum_comment_length = self.get_setting("minimum_comment_length")
         minimum_comment_words = self.get_setting("minimum_comment_words")
@@ -26,12 +26,15 @@ class HasComments(LocalizationTestCase):
         for string in self.collection.strings_for_language(self.configuration.default_language()):
 
             if string.comment is None:
-                violations.append(f"Comment was empty: {string}")
+                violations.append((f"Comment was empty: {string}", string.language_code))
                 continue
 
             if minimum_comment_length >= 0 and len(string.comment) < minimum_comment_length:
                 violations.append(
-                    f"Comment did not meet minimum length of {minimum_comment_length}: {string}"
+                    (
+                        f"Comment did not meet minimum length of {minimum_comment_length}: {string}",
+                        string.language_code,
+                    )
                 )
                 continue
 
@@ -40,7 +43,10 @@ class HasComments(LocalizationTestCase):
                 and len(string.comment.split(" ")) < minimum_comment_words
             ):
                 violations.append(
-                    f"Comment did not meet minimum word count of {minimum_comment_words}: {string}"
+                    (
+                        f"Comment did not meet minimum word count of {minimum_comment_words}: {string}",
+                        string.language_code,
+                    )
                 )
                 continue
 

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/tests/has_value.py

@@ -1,6 +1,6 @@
 """Checks that the value is set."""
 
-from typing import Any, Dict, List
+from typing import Any
 
 from localizationkit.tests.test_case import LocalizationTestCase
 
@@ -13,12 +13,12 @@ class HasValue(LocalizationTestCase):
         return "has_value"
 
     @classmethod
-    def default_settings(cls) -> Dict[str, Any]:
+    def default_settings(cls) -> dict[str, Any]:
         return {"default_language_only": False}
 
-    def run_test(self) -> List[str]:
+    def run_test(self) -> list[tuple[str, str]]:
 
-        violations: List[str] = []
+        violations: list[tuple[str, str]] = []
 
         if self.get_setting("default_language_only"):
             test_collection = self.collection.strings_for_language(
@@ -29,7 +29,7 @@ class HasValue(LocalizationTestCase):
 
         for string in test_collection:
             if string.value is None or len(string.value) == 0:
-                violations.append(f"Value was empty: {string}")
+                violations.append((f"Value was empty: {string}", string.language_code))
                 continue
 
         return violations

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/tests/invalid_tokens.py

@@ -1,7 +1,7 @@
 """Invalid tokens."""
 
 import re
-from typing import Any, Dict, List
+from typing import Any
 
 from localizationkit.tests.test_case import LocalizationTestCase
 
@@ -14,20 +14,25 @@ class InvalidTokens(LocalizationTestCase):
         return "invalid_tokens"
 
     @classmethod
-    def default_settings(cls) -> Dict[str, Any]:
+    def default_settings(cls) -> dict[str, Any]:
         return {}
 
-    def run_test(self) -> List[str]:
+    def run_test(self) -> list[tuple[str, str]]:
 
         violations = []
 
-        invalid_token_pattern = re.compile(r"(%[^@%\.a-z0-9 ]+)", flags=re.DOTALL)
+        invalid_token_pattern = re.compile(r"(%[^@%\.a-zA-Z0-9 ]+)", flags=re.DOTALL)
 
         for string in self.collection.localized_strings:
             matches = invalid_token_pattern.findall(string.value)
 
             # Any matches are a bad thing
             if matches and len(matches) > 0:
-                violations.append(f"Translation contains invalid tokens ({matches}): {string}")
+                violations.append(
+                    (
+                        f"Translation contains invalid tokens ({matches}): {string}",
+                        string.language_code,
+                    )
+                )
 
         return violations

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/tests/key_length.py

@@ -1,6 +1,6 @@
 """Checks key length."""
 
-from typing import Any, Dict, List
+from typing import Any
 
 from localizationkit.tests.test_case import LocalizationTestCase
 
@@ -13,15 +13,15 @@ class KeyLength(LocalizationTestCase):
         return "key_length"
 
     @classmethod
-    def default_settings(cls) -> Dict[str, Any]:
+    def default_settings(cls) -> dict[str, Any]:
         return {"minimum": -1, "maximum": -1}
 
-    def run_test(self) -> List[str]:
+    def run_test(self) -> list[tuple[str, str]]:
 
         minimum_length = self.get_setting("minimum")
         maximum_length = self.get_setting("maximum")
 
-        violations: List[str] = []
+        violations: list[tuple[str, str]] = []
 
         # Short circuit for the non-bound case
         if minimum_length < 0 and maximum_length < 0:
@@ -32,13 +32,23 @@ class KeyLength(LocalizationTestCase):
             key = string.key
 
             if key is None:
-                violations.append(f"Key was empty: {string}")
+                violations.append((f"Key was empty: {string}", string.language_code))
                 continue
 
             if len(key) < minimum_length >= 0:
-                violations.append(f"Key is shorter than minimum of {minimum_length}: {string}")
+                violations.append(
+                    (
+                        f"Key is shorter than minimum of {minimum_length}: {string}",
+                        string.language_code,
+                    )
+                )
 
             if len(key) > maximum_length >= 0:
-                violations.append(f"Key is longer than maximum of {maximum_length}: {string}")
+                violations.append(
+                    (
+                        f"Key is longer than maximum of {maximum_length}: {string}",
+                        string.language_code,
+                    )
+                )
 
         return violations

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/tests/objectivec_alternative_tokens.py

@@ -1,7 +1,7 @@
 """Objective-C alternative tokens."""
 
 import re
-from typing import Any, Dict, List
+from typing import Any
 
 from localizationkit.tests.test_case import LocalizationTestCase
 
@@ -19,14 +19,14 @@ class ObjectivecAlternativeTokens(LocalizationTestCase):
         return "objectivec_alternative_tokens"
 
     @classmethod
-    def default_settings(cls) -> Dict[str, Any]:
+    def default_settings(cls) -> dict[str, Any]:
         return {}
 
     @classmethod
     def is_opt_in(cls) -> bool:
         return True
 
-    def run_test(self) -> List[str]:
+    def run_test(self) -> list[tuple[str, str]]:
 
         violations = []
 
@@ -35,7 +35,12 @@ class ObjectivecAlternativeTokens(LocalizationTestCase):
         for string in self.collection.localized_strings:
 
             if pattern.findall(string.value):
-                violations.append(f"Objective-C alternative tokens were found in string: {string}")
+                violations.append(
+                    (
+                        f"Objective-C alternative tokens were found in string: {string}",
+                        string.language_code,
+                    )
+                )
                 continue
 
         return violations

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/tests/placeholder_token_explanation.py

@@ -1,6 +1,6 @@
 """Placeholder token explanation."""
 
-from typing import Any, Dict, List
+from typing import Any
 
 from localizationkit.tests.test_case import LocalizationTestCase
 
@@ -13,14 +13,14 @@ class PlaceholderTokenExplanation(LocalizationTestCase):
         return "placeholder_token_explanation"
 
     @classmethod
-    def default_settings(cls) -> Dict[str, Any]:
+    def default_settings(cls) -> dict[str, Any]:
         return {}
 
     @classmethod
     def is_opt_in(cls) -> bool:
         return True
 
-    def run_test(self) -> List[str]:
+    def run_test(self) -> list[tuple[str, str]]:
 
         violations = []
 
@@ -33,12 +33,18 @@ class PlaceholderTokenExplanation(LocalizationTestCase):
 
             if len(extra_in_tokens) != 0:
                 violations.append(
-                    f"Tokens are not described in the comment ({extra_in_tokens}): {string}"
+                    (
+                        f"Tokens are not described in the comment ({extra_in_tokens}): {string}",
+                        string.language_code,
+                    )
                 )
 
             if len(extra_in_comments) != 0:
                 violations.append(
-                    f"Extra tokens appear in the comment ({extra_in_comments}): {string}"
+                    (
+                        f"Extra tokens appear in the comment ({extra_in_comments}): {string}",
+                        string.language_code,
+                    )
                 )
 
         return violations

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/tests/swift_interpolation.py

@@ -1,7 +1,7 @@
 """Swift interpolation."""
 
 import re
-from typing import Any, Dict, List
+from typing import Any
 
 from localizationkit.tests.test_case import LocalizationTestCase
 
@@ -14,14 +14,14 @@ class SwiftInterpolation(LocalizationTestCase):
         return "swift_interpolation"
 
     @classmethod
-    def default_settings(cls) -> Dict[str, Any]:
+    def default_settings(cls) -> dict[str, Any]:
         return {}
 
     @classmethod
     def is_opt_in(cls) -> bool:
         return True
 
-    def run_test(self) -> List[str]:
+    def run_test(self) -> list[tuple[str, str]]:
 
         violations = []
 
@@ -30,7 +30,12 @@ class SwiftInterpolation(LocalizationTestCase):
         for string in self.collection.localized_strings:
 
             if pattern.findall(string.value):
-                violations.append(f"Swift string interpolation found in string: {string}")
+                violations.append(
+                    (
+                        f"Swift string interpolation found in string: {string}",
+                        string.language_code,
+                    )
+                )
                 continue
 
         return violations

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/tests/test_case.py

@@ -1,9 +1,10 @@
 """Base type for localization."""
 
 import abc
-from typing import Any, Dict, List
+from typing import Any
 
 from localizationkit.configuration import Configuration
+from localizationkit.exceptions import LocalizationKitException
 from localizationkit.localization_types import LocalizedCollection
 from localizationkit.utility_types import TestResult
 
@@ -18,7 +19,7 @@ class LocalizationTestCase(abc.ABC):
 
     configuration: Configuration
     collection: LocalizedCollection
-    test_settings: Dict[str, Any]
+    test_settings: dict[str, Any]
 
     def __init__(self, configuration: Configuration, collection: LocalizedCollection):
         self.configuration = configuration
@@ -45,7 +46,7 @@ class LocalizationTestCase(abc.ABC):
 
     @classmethod
     @abc.abstractmethod
-    def default_settings(cls) -> Dict[str, Any]:
+    def default_settings(cls) -> dict[str, Any]:
         """Get the default settings for the test.
 
         :returns: The default settings for the test
@@ -64,7 +65,7 @@ class LocalizationTestCase(abc.ABC):
         return False
 
     @abc.abstractmethod
-    def run_test(self) -> List[str]:
+    def run_test(self) -> list[tuple[str, str]]:
         """Run the test
 
         :returns: The list of violations encountered
@@ -80,11 +81,13 @@ class LocalizationTestCase(abc.ABC):
             violations = self.run_test()
 
             if violations is None:
-                raise Exception(f"Failed to get exceptions from test: {self.__class__.name()}")
+                raise LocalizationKitException(
+                    f"Failed to get exceptions from test: {self.__class__.name()}"
+                )
 
             if len(violations):
                 return TestResult.failure(self.__class__.name(), violations)
 
             return TestResult.success(self.__class__.name())
         except Exception as ex:
-            return TestResult.failure(self.__class__.name(), [str(ex)])
+            return TestResult.failure(self.__class__.name(), [(str(ex), "unknown")])

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/tests/token_matching.py

@@ -1,6 +1,6 @@
 """Token matching."""
 
-from typing import Any, Dict, List
+from typing import Any
 
 from localizationkit.tests.test_case import LocalizationTestCase
 
@@ -13,10 +13,10 @@ class TokenMatching(LocalizationTestCase):
         return "token_matching"
 
     @classmethod
-    def default_settings(cls) -> Dict[str, Any]:
+    def default_settings(cls) -> dict[str, Any]:
         return {"allow_missing_defaults": False}
 
-    def run_test(self) -> List[str]:
+    def run_test(self) -> list[tuple[str, str]]:
 
         violations = []
 
@@ -46,7 +46,10 @@ class TokenMatching(LocalizationTestCase):
                 translation_tokens = sorted(string.tokens())
                 if default_tokens != translation_tokens:
                     violations.append(
-                        f"The tokens for {language_code} do not match the default language: {string.key}"
+                        (
+                            f"The tokens for {language_code} do not match the default language: {string.key}",
+                            string.language_code,
+                        )
                     )
 
         return violations

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/tests/token_position_identifiers.py

@@ -1,6 +1,6 @@
 """Token position identifiers."""
 
-from typing import Any, Dict, List, Set
+from typing import Any
 
 from localizationkit.tests.test_case import LocalizationTestCase
 
@@ -13,10 +13,10 @@ class TokenPositionIdentifiers(LocalizationTestCase):
         return "token_position_identifiers"
 
     @classmethod
-    def default_settings(cls) -> Dict[str, Any]:
+    def default_settings(cls) -> dict[str, Any]:
         return {"always": False}
 
-    def run_test(self) -> List[str]:
+    def run_test(self) -> list[tuple[str, str]]:
 
         violations = []
 
@@ -34,23 +34,33 @@ class TokenPositionIdentifiers(LocalizationTestCase):
                 continue
 
             # Track the positions we've seen
-            positional_tokens: Set[int] = set()
+            positional_tokens: set[int] = set()
 
             for token in tokens:
                 if "$" not in token:
-                    violations.append(f"String missing positional tokens: {string}")
+                    violations.append(
+                        (
+                            f"String missing positional tokens: {string}",
+                            string.language_code,
+                        )
+                    )
                     continue
 
                 position = int((token.split("$")[0]).replace("%", ""))
 
                 if position in positional_tokens:
-                    violations.append(f"Duplicate token position: {string}")
+                    violations.append((f"Duplicate token position: {string}", string.language_code))
                     continue
 
                 positional_tokens.add(position)
 
             for i in range(1, len(tokens) + 1):
                 if i not in positional_tokens:
-                    violations.append(f"Token position index skipped: {string}")
+                    violations.append(
+                        (
+                            f"Token position index skipped: {string}",
+                            string.language_code,
+                        )
+                    )
 
         return violations

{localizationkit-2.0.0 → localizationkit-3.0.1}/localizationkit/utility_types.py

@@ -1,7 +1,5 @@
 """Utility types for tests."""
 
-from typing import List, Optional
-
 
 class TestResult:
     """A simple result type
@@ -12,9 +10,9 @@ class TestResult:
 
     _success: bool
     name: str
-    violations: Optional[List[str]]
+    violations: list[tuple[str, str]] | None
 
-    def __init__(self, success: bool, name: str, violations: Optional[List[str]]):
+    def __init__(self, success: bool, name: str, violations: list[tuple[str, str]] | None):
         self._success = success
         self.name = name
         self.violations = violations
@@ -37,7 +35,7 @@ class TestResult:
         return TestResult(True, name, None)
 
     @staticmethod
-    def failure(name: str, violations: Optional[List[str]]) -> "TestResult":
+    def failure(name: str, violations: list[tuple[str, str]] | None) -> "TestResult":
         """Create a new failure result.
 
         :param name: The name of the test

{localizationkit-2.0.0 → localizationkit-3.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "localizationkit"
-version = "2.0.0"
+version = "3.0.1"
 description = "String localization tests"
 
 license = "MIT"
@@ -30,15 +30,15 @@ classifiers = [
 ]
 
 [tool.poetry.dependencies]
-python = "^3.8"
+python = "^3.11"
 toml = "^0.10.2"
 
 [tool.poetry.dev-dependencies]
-black = "^22.12.0"
-mypy = "^0.971"
-pylint = "^2.17.5"
-pytest = "^7.4.0"
-pytest-cov = "^3.0.0"
+black = "25.1.0"
+mypy = "1.15.0"
+pylint = "3.3.4"
+pytest = "^8.1.1"
+pytest-cov = "^4.1.0"
 types-toml = "^0.10.8.7"