localizationkit 1.0.1__tar.gz → 3.0.1__tar.gz

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

@@ -1,25 +1,27 @@
 Metadata-Version: 2.1
 Name: localizationkit
-Version: 1.0.1
+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.7.2,<4.0.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.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: Utilities
-Requires-Dist: toml (>=0.10.0,<0.11.0)
+Requires-Dist: toml (>=0.10.2,<0.11.0)
 Project-URL: Repository, https://github.com/Microsoft/localizationkit
 Description-Content-Type: text/markdown
 
@@ -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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → 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-1.0.1 → localizationkit-3.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "localizationkit"
-version = "1.0.1"
+version = "3.0.1"
 description = "String localization tests"
 
 license = "MIT"
@@ -20,28 +20,28 @@ classifiers = [
     'Development Status :: 3 - Alpha',
     'Intended Audience :: Developers',
     'Programming Language :: Python :: 3',
-    'Programming Language :: Python :: 3.7',
     'Programming Language :: Python :: 3.8',
     'Programming Language :: Python :: 3.9',
     'Programming Language :: Python :: 3.10',
+    'Programming Language :: Python :: 3.11',
     'Topic :: Software Development',
     'Topic :: Software Development :: Testing',
     'Topic :: Utilities'
 ]
 
 [tool.poetry.dependencies]
-python = "^3.7.2"
-toml = "^0.10.0"
+python = "^3.11"
+toml = "^0.10.2"
 
 [tool.poetry.dev-dependencies]
-black = "=22.6.0"
-mypy = "=0.971"
-pylint = "=2.14.5"
-pytest = "=7.1.2"
-pytest-cov = "=3.0.0"
-types-toml = "=0.10.8"
+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"
 
 
 [build-system]
-requires = ["poetry>=0.12"]
-build-backend = "poetry.masonry.api"
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

localizationkit-1.0.1/setup.py

@@ -1,30 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-packages = \
-['localizationkit', 'localizationkit.tests']
-
-package_data = \
-{'': ['*']}
-
-install_requires = \
-['toml>=0.10.0,<0.11.0']
-
-setup_kwargs = {
-    'name': 'localizationkit',
-    'version': '1.0.1',
-    'description': 'String localization tests',
-    'long_description': '# localizationkit\n\n`localizationkit` is a toolkit for ensuring that your localized strings are the best that they can be.\n\nIncluded are tests for various things such as:\n\n* Checking that all strings have comments\n* Checking that the comments don\'t just match the value\n* Check that tokens have position specifiers\n* Check that no invalid tokens are included\n\nwith lots more to come. \n\n## Getting started\n\n### Configuration\n\nTo use the library, first off, create a configuration file that is in the TOML format. Here\'s an example:\n\n```toml\ndefault_language = "en"\n\n[has_comments]\nminimum_comment_length = 25\nminimum_comment_words = 8\n\n[token_matching]\nallow_missing_defaults = true\n\n[token_position_identifiers]\nalways = false\n```\n\nThis configuration file sets that `en` is the default language (so this is the language that will be checked for comments, etc. and all tests will run relative to it). Then it sets various settings for each test. Every instance of `[something_here]` specifies that the following settings are for that test. For example, the test `has_comments` will now make sure that not only are there comments, but that they are at least 25 characters in length and 8 words in length. \n\nYou can now load in your configuration:\n\n```python\nfrom localizationkit import Configuration\n\nconfiguration = Configuration.from_file("/path/to/config.toml")\n```\n\n### Localization Collections\n\nNow we need to prepare the strings that will go in. Here\'s how you can create an individual string:\n\n```python\nfrom localizationkit import LocalizedString\n\nmy_string = LocalizedString("My string\'s key", "My string\'s value", "My string\'s comment", "en")\n```\n\nThis creates a single string with a key, value and comment, with its language code set to `en`. Once you\'ve created some more (usually for different languages too), you can bundle them into a collection:\n\n```python\nfrom localizationkit import LocalizedCollection\n\ncollection = LocalizedCollection(list_of_my_strings)\n```\n\n### Running the tests\n\nAt this point, you are ready to run the tests:\n\n```python\nimport localizationkit\n\nresults = localizationkit.run_tests(configuration, collection)\n\nfor result in results:\n    if not result.succeeded():\n        print("The following test failed:", result.name)\n        print("Failures encountered:")\n        for violation in result.violations:\n            print(violation)\n```\n\n### Not running the tests\n\nSome tests don\'t make sense for everyone. To skip a test you can add the following to your config file at the root:\n\n```toml\nblacklist = ["test_identifier_1", "test_identifier_2"]\n```\n\n# Rule documentation\n\nMost tests have configurable rules. If a rule is not specified, it will use the default instead.\n\nSome tests are opt in only. These will be marked as such.\n\n## Comment Linebreaks\n\nIdentifier: `comment_linebreaks`\nOpt-In: `true`\n\nChecks that comments for strings do not contain linebreaks. Comments which contain linebreaks can interfere with parsing in other tools such as [dotstrings](https://github.com/microsoft/dotstrings).\n\n## Comment Similarity\n\nIdentifier: `comment_similarity`\n\nChecks the similarity between a comment and the string\'s value in the default language. This is achieved via `difflib`\'s `SequenceMatcher`. More details can be found [here](https://docs.python.org/3/library/difflib.html#difflib.SequenceMatcher.ratio)\n\n<details>\n    <summary>Configuration</summary>\n\n| Parameter | Type | Acceptable Values | Default | Details | \n| --- | --- | --- | --- | --- |\n| `maximum_similarity_ratio` | float | Between 0 and 1 | 0.5 | Set the maximum similarity ratio between the comment and the string value. The higher the value, the more similar they are. The longer the string the more accurate this will be. |\n\n</details>\n\n## Duplicate Keys\n\nIdentifier: `duplicate_keys`\n\nChecks that there are no duplicate keys in the collection.\n\n<details>\n    <summary>Configuration</summary>\n\n| Parameter | Type | Acceptable Values | Default | Details | \n| --- | --- | --- | --- | --- |\n| `all_languages` | boolean | `true` or `false` | `false` | Set to `true` to check that every language has unique keys, not just the default language. |\n\n</details>\n\n## Has Comments\n\nIdentifier: `has_comments`\n\nChecks that strings have comments.\n\n_Note: Only languages that have Latin style scripts are really supported for the words check due to splitting on spaces to check._\n\n<details>\n    <summary>Configuration</summary>\n\n| Parameter | Type | Acceptable Values | Default | Details | \n| --- | --- | --- | --- | --- |\n| `minimum_comment_length` | int | Any integer | 30 | Set the minimum allowable length for a comment. Set the value to negative to not check. |\n| `minimum_comment_words` | int | Any integer | 10 | Set the minimum allowable number of words for a comment. Set the value to negative to not check. |\n\n</details>\n\n## Has Value\n\nIdentifier: `has_value`\n\nChecks that strings have values. Since any value is enough for some strings, it simply makes sure that the string isn\'t None/null and isn\'t empty.\n\n<details>\n    <summary>Configuration</summary>\n\n| Parameter | Type | Acceptable Values | Default | Details | \n| --- | --- | --- | --- | --- |\n| `default_language_only` | boolean | `true` or `false` | `false` | Set to true to only check the default language for missing values. Otherwise all languages will be checked. |\n\n</details>\n\n## Invalid Tokens\n\nIdentifier: `invalid_tokens`\n\nChecks that all format tokens in a string are valid.\n\n_Note: This check is not language specific. It only works very broadly._\n\n## Key Length\n\nIdentifier: `key_length`\n\nChecks the length of the keys.\n\n_Note: By default this test doesn\'t check anything. It needs to have parameters set to positive values to do anything._\n\n<details>\n    <summary>Configuration</summary>\n\n| Parameter | Type | Acceptable Values | Default | Details | \n| --- | --- | --- | --- | --- |\n| `minimum` | int | Any integer | -1 | Set the minimum allowable length for a key. Set the value to negative to not check. |\n| `maximum` | int | Any integer | -1 | Set the maximum allowable length for a key. Set the value to negative to not check. |\n\n</details>\n\n## Objective-C Alternative Tokens\n\nIdentifier: `objectivec_alternative_tokens`\nOpt-In: `true`\n\nChecks that strings do not contain Objective-C style alternative position tokens.\n\nObjective-C seems to be allows positional tokens of the form `%1@` rather than `%1$@`. While not illegal, it is preferred that all tokens between languages are consistent so that tools don\'t experience unexpected failures, etc.\n\n## Placeholder token explanation\n\nIdentifier: `placeholder_token_explanation`\nOpt-In: `true`\n\nChecks that if a placeholder is used in a string, the comment explicitly explains what it is replaced with.\n\nPrecondition: Each placeholder in the string and its explanation in comment is expected to follow `token_position_identifiers` rule.\n\n## Swift Interpolation\n\nIdentifier: `swift_interpolation`\nOpt-In: `true`\n\nChecks that strings do not contain Swift style interpolation values since these cannot be localized.\n\n## Token Matching\n\nIdentifier: `token_matching`\n\nChecks that the tokens in a string match across all languages. e.g. If your English string is "Hello %s" but your French string is "Bonjour", this would flag that there is a missing token in the French string.\n\n<details>\n    <summary>Configuration</summary>\n\n| Parameter | Type | Acceptable Values | Default | Details | \n| --- | --- | --- | --- | --- |\n| `allow_missing_defaults` | boolean | `true` or `false` | `false` | Due to the way that automated localization works, usually there will be a default language, and then other translations will come in over time. If a translation is deleted, it isn\'t always deleted from all languages immediately. Setting this parameter to true will allow any strings in your non-default language to be ignored if that string is missing from your default language. |\n\n</details>\n\n## Token Position Identifiers\n\nIdentifier: `token_position_identifiers`\n\nCheck that each token has a position specifier with it. e.g. `%s` is not allowed, but `%1$s` is. Tokens can move around in different languages, so position specifiers are extremely important.\n\n<details>\n    <summary>Configuration</summary>\n\n| Parameter | Type | Acceptable Values | Default | Details | \n| --- | --- | --- | --- | --- |\n| `always` | boolean | `true` or `false` | `false` | If a string only has a single token, it doesn\'t need a position specifier. Set this to `true` to require it even in those cases.\n\n</details>\n\n# Contributing\n\nThis project welcomes contributions and suggestions.  Most contributions require you to agree to a\nContributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us\nthe rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.\n\nWhen you submit a pull request, a CLA bot will automatically determine whether you need to provide\na CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions\nprovided by the bot. You will only need to do this once across all repos using our CLA.\n\nThis project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).\nFor more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or\ncontact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.\n',
-    'author': 'Dale Myers',
-    'author_email': 'dalemy@microsoft.com',
-    'maintainer': None,
-    'maintainer_email': None,
-    'url': 'https://github.com/Microsoft/localizationkit',
-    'packages': packages,
-    'package_data': package_data,
-    'install_requires': install_requires,
-    'python_requires': '>=3.7.2,<4.0.0',
-}
-
-
-setup(**setup_kwargs)