dotstrings 2.0.0__tar.gz → 3.1.0__tar.gz

{dotstrings-2.0.0 → dotstrings-3.1.0}/PKG-INFO

@@ -1,23 +1,25 @@
 Metadata-Version: 2.1
 Name: dotstrings
-Version: 2.0.0
+Version: 3.1.0
 Summary: Tools for dealing with the .strings files for iOS and macOS
 Home-page: https://github.com/Microsoft/dotstrings
 License: MIT
 Keywords: localization,iOS,macOS,strings
 Author: Dale Myers
-Author-email: dalemy@microsoft.com
-Requires-Python: >=3.8,<4.0
+Author-email: dalemyers@microsoft.com
+Requires-Python: >=3.10,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Environment :: MacOS X
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-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: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Topic :: Software Development
 Classifier: Topic :: Utilities
 Project-URL: Repository, https://github.com/Microsoft/dotstrings

{dotstrings-2.0.0 → dotstrings-3.1.0}/dotstrings/__init__.py

@@ -1,11 +1,11 @@
 """Utilities for dealing with .strings files"""
 
 import os
-from typing import Dict, List, Optional, Set
 
 from dotstrings.parser import load, loads, load_dict, loads_dict
 from dotstrings.dot_strings_entry import DotStringsEntry
 from dotstrings.dot_stringsdict_entry import DotStringsDictEntry, Variable
+from dotstrings.exceptions import DotStringsException
 from dotstrings.localized_bundle import LocalizedBundle
 from dotstrings.localized_string import LocalizedString
 
@@ -50,7 +50,7 @@ def stringsdict_file_path(stringsdict_folder: str, language: str, table_name: st
     )
 
 
-def languages_in_folder(strings_folder: str) -> Set[str]:
+def languages_in_folder(strings_folder: str) -> set[str]:
     """Find all the languages in a folder
 
     This looks for *.lproj folders.
@@ -65,7 +65,7 @@ def languages_in_folder(strings_folder: str) -> Set[str]:
     return {language.replace(".lproj", "") for language in languages}
 
 
-def load_table(strings_folder: str, language: str, table_name: str) -> List[LocalizedString]:
+def load_table(strings_folder: str, language: str, table_name: str) -> list[LocalizedString]:
     """Load the specified .strings table
 
     :param strings_folder: The location of the strings folder (which contains
@@ -83,7 +83,7 @@ def load_table(strings_folder: str, language: str, table_name: str) -> List[Loca
     )
 
 
-def load_language_tables(strings_folder: str, language: str) -> Dict[str, List[LocalizedString]]:
+def load_language_tables(strings_folder: str, language: str) -> dict[str, list[LocalizedString]]:
     """Load the .strings tables for a given language
 
     :param strings_folder: The location of the strings folder (which contains
@@ -129,7 +129,7 @@ def load_all_strings(strings_folder: str) -> LocalizedBundle:
 
 def normalize(
     strings_path: str,
-    output_path: Optional[str] = None,
+    output_path: str | None = None,
     remove_duplicates: bool = True,
     sort_comments: bool = True,
 ) -> None:
@@ -165,7 +165,7 @@ def normalize(
         # If we have duplicate keys but the values don't match, that's an
         # exception, whether or not we are removing duplicates
         if deduped_entries[-1].value != entry.value or not remove_duplicates:
-            raise Exception(f"Found duplicate strings with key: {entry.key}")
+            raise DotStringsException(f"Found duplicate strings with key: {entry.key}")
 
         deduped_entries[-1].comments.extend(entry.comments)
 

{dotstrings-2.0.0 → dotstrings-3.1.0}/dotstrings/dot_strings_entry.py

@@ -1,7 +1,5 @@
 """Base types for the dotstrings library."""
 
-from typing import List
-
 
 class DotStringsEntry:
     """Represents a .strings entry.
@@ -13,9 +11,9 @@ class DotStringsEntry:
 
     key: str
     value: str
-    comments: List[str]
+    comments: list[str]
 
-    def __init__(self, key: str, value: str, comments: List[str]) -> None:
+    def __init__(self, key: str, value: str, comments: list[str]) -> None:
         self.key = key
         self.value = value
         self.comments = comments

{dotstrings-2.0.0 → dotstrings-3.1.0}/dotstrings/dot_stringsdict_entry.py

@@ -1,6 +1,6 @@
 """Base types for the dotstrings library."""
 
-from typing import Optional
+from dotstrings.exceptions import DotStringsException
 
 VARIABLE_VALUE_TYPE_KEY = "NSStringFormatValueTypeKey"
 VARIABLE_VALUE_SPEC_KEY = "NSStringFormatSpecTypeKey"
@@ -21,13 +21,13 @@ class Variable:
     :param other_value: Value for other
     """
 
-    value_type: Optional[str]
-    zero_value: Optional[str]
-    one_value: Optional[str]
-    two_value: Optional[str]
-    few_value: Optional[str]
-    many_value: Optional[str]
-    other_value: Optional[str]
+    value_type: str | None
+    zero_value: str | None
+    one_value: str | None
+    two_value: str | None
+    few_value: str | None
+    many_value: str | None
+    other_value: str | None
 
     def __init__(self) -> None:
         self.value_type = None
@@ -50,14 +50,16 @@ class Variable:
 
         variable = Variable()
         if VARIABLE_VALUE_SPEC_KEY not in contents:
-            raise Exception("NSStringFormatSpecTypeKey missing in entry")
+            raise DotStringsException("NSStringFormatSpecTypeKey missing in entry")
 
         if contents[VARIABLE_VALUE_SPEC_KEY] != VARIABLE_VALUE_SPEC_PLURAL:
-            raise Exception("Value of NSStringFormatSpecTypeKey is not NSStringPluralRuleType")
+            raise DotStringsException(
+                "Value of NSStringFormatSpecTypeKey is not NSStringPluralRuleType"
+            )
 
         # When initializing from a dict (parsing), be sure NSStringFormatValueTypeKey exists
         if VARIABLE_VALUE_TYPE_KEY not in contents:
-            raise Exception("NSStringFormatValueTypeKey missing in entry")
+            raise DotStringsException("NSStringFormatValueTypeKey missing in entry")
 
         variable.value_type = contents[VARIABLE_VALUE_TYPE_KEY]
 
@@ -116,7 +118,7 @@ class DotStringsDictEntry:
 
         :returns: The dict representation of this entry
         """
-        result = {}
+        result: dict[str, str | dict[str, str]] = {}
         result[FORMAT_KEY] = self.value
         for variable_name, variable in self.variables.items():
             variable_dict = {}
@@ -165,7 +167,7 @@ class DotStringsDictEntry:
         :returns: The parsed stringsdict entry
         """
         if FORMAT_KEY not in contents:
-            raise Exception("NSStringLocalizedFormatKey missing in entry")
+            raise DotStringsException("NSStringLocalizedFormatKey missing in entry")
 
         entry_format = contents[FORMAT_KEY]
 

dotstrings-3.1.0/dotstrings/exceptions.py

@@ -0,0 +1,5 @@
+"""Exception types."""
+
+
+class DotStringsException(Exception):
+    """Base class used for dotstrings errors."""

{dotstrings-2.0.0 → dotstrings-3.1.0}/dotstrings/genstrings.py

@@ -4,7 +4,8 @@ import os
 import shutil
 import subprocess
 import tempfile
-from typing import List
+
+from dotstrings.exceptions import DotStringsException
 
 
 def _convert_to_utf8(file_path: str) -> None:
@@ -22,13 +23,13 @@ def _convert_to_utf8(file_path: str) -> None:
     iconv_command = f'iconv -f UTF-16 -t UTF-8 "{file_path}" > "{temp_file_path}"'
 
     if subprocess.run(iconv_command, shell=True, check=False).returncode != 0:
-        raise Exception("Unable to convert from UTF-16 to UTF-8!")
+        raise DotStringsException("Unable to convert from UTF-16 to UTF-8!")
 
     shutil.move(temp_file_path, file_path)
 
 
 def generate_strings(
-    *, output_directory: str, file_paths: List[str], clear_existing: bool = True
+    *, output_directory: str, file_paths: list[str], clear_existing: bool = True
 ) -> None:
     """Run the genstrings command over the files passed in.
 
@@ -53,7 +54,7 @@ def generate_strings(
 
     :param str output_directory: The location to place the output files (this
                                  folder will contain an en.lproj folder after)
-    :param List[str] file_paths: The paths to the files that should be scanned
+    :param list[str] file_paths: The paths to the files that should be scanned
     :param bool clear_existing: Set to True when the existing files in the
                                 output directory should be wiped before
                                 generating the new strings. Defaults to True.
@@ -110,9 +111,9 @@ def generate_strings(
             output = output.strip()
 
             if len(output) > 0:
-                raise Exception(f"Encountered an error generating strings: {output}")
+                raise DotStringsException(f"Encountered an error generating strings: {output}")
         except subprocess.CalledProcessError as ex:
-            raise Exception(f"Unable generate .strings files! {ex}") from ex
+            raise DotStringsException(f"Unable generate .strings files! {ex}") from ex
 
     # Convert all .strings files to UTF-8
     for file_name in os.listdir(english_strings_directory):

{dotstrings-2.0.0 → dotstrings-3.1.0}/dotstrings/localized_bundle.py

@@ -1,7 +1,8 @@
 """Representation of a localized bundle."""
 
-from typing import cast, Dict, List, Set
+from typing import cast
 
+from dotstrings.exceptions import DotStringsException
 from dotstrings.localized_string import LocalizedString
 
 
@@ -11,17 +12,17 @@ class LocalizedBundle:
     :param raw_entries: The raw dictionary entries that were parsed from disk
     """
 
-    def __init__(self, raw_entries: Dict[str, Dict[str, List[LocalizedString]]]) -> None:
+    def __init__(self, raw_entries: dict[str, dict[str, list[LocalizedString]]]) -> None:
         self.raw_entries = raw_entries
 
-    def languages(self) -> List[str]:
+    def languages(self) -> list[str]:
         """Return the languages supported in the bundle
 
         :returns: A list of language codes
         """
         return list(self.raw_entries.keys())
 
-    def table_names(self, validate_identical: bool = False) -> List[str]:
+    def table_names(self, validate_identical: bool = False) -> list[str]:
         """Return the tables in the bundle.
 
         :param validate_identical: Set to True to confirm all languages have the
@@ -34,7 +35,7 @@ class LocalizedBundle:
 
             # Build up a map of languages to table names
 
-            found_tables: Dict[str, Set[str]] = {}
+            found_tables: dict[str, set[str]] = {}
             for language, table_map in self.raw_entries.items():
                 # table_map is a dictionary of names to lists of strings
                 found_tables[language] = set(table_map.keys())
@@ -50,13 +51,13 @@ class LocalizedBundle:
                 missing_tables = base_language_tables - table_names
 
                 if len(extra_tables) > 0:
-                    raise Exception(
+                    raise DotStringsException(
                         f"The following table names were in {language}"
                         + f" but not in {base_language}: {extra_tables}"
                     )
 
                 if len(missing_tables) > 0:
-                    raise Exception(
+                    raise DotStringsException(
                         f"The following table names were in {base_language}"
                         + f" but not in {language}: {missing_tables}"
                     )
@@ -71,7 +72,7 @@ class LocalizedBundle:
 
         return list(all_table_names)
 
-    def tables_for_language(self, language: str) -> Dict[str, List[LocalizedString]]:
+    def tables_for_language(self, language: str) -> dict[str, list[LocalizedString]]:
         """Return the tables for a language.
 
         :param language: The language to get the tables for
@@ -82,13 +83,13 @@ class LocalizedBundle:
         result = self.raw_entries.get(language, sentinel)
 
         if result is sentinel:
-            raise Exception(f"There were no entries for language: {language}")
+            raise DotStringsException(f"There were no entries for language: {language}")
 
-        return cast(Dict[str, List[LocalizedString]], result)
+        return cast(dict[str, list[LocalizedString]], result)
 
     def table_for_languages(
         self, table: str, *, allow_missing: bool = False
-    ) -> Dict[str, List[LocalizedString]]:
+    ) -> dict[str, list[LocalizedString]]:
         """Return a dictionary of languages to strings for a given table.
 
         :param table: The table to load the data for
@@ -106,15 +107,15 @@ class LocalizedBundle:
                 continue
 
             if table_data is sentinel and not allow_missing:
-                raise Exception(f"Could not find table {table} for language {language}")
+                raise DotStringsException(f"Could not find table {table} for language {language}")
 
-            results[language] = cast(List[LocalizedString], table_data)
+            results[language] = cast(list[LocalizedString], table_data)
 
         return results
 
     def tables(
         self, *, validate_missing: bool = True
-    ) -> Dict[str, Dict[str, List[LocalizedString]]]:
+    ) -> dict[str, dict[str, list[LocalizedString]]]:
         """Return the entries in the bundle, first keyed by table, then by language.
 
         :param bool validate_missing: Set to False to disable the check that a table exists for every language

{dotstrings-2.0.0 → dotstrings-3.1.0}/dotstrings/localized_string.py

@@ -2,9 +2,10 @@
 
 import hashlib
 import re
-from typing import ClassVar, List, Optional, Pattern
+from typing import ClassVar, Pattern
 
 from dotstrings.dot_strings_entry import DotStringsEntry
+from dotstrings.exceptions import DotStringsException
 
 
 class LocalizedString:
@@ -20,41 +21,42 @@ class LocalizedString:
     you may wish to automatically generate keys to avoid having to manually
     deal with deduplication.
 
-    :param Optional[str] key: The key for the string. If this is None, they key
+    :param str | None key: The key for the string. If this is None, they key
                               will be automatically derived from the value and
                               the key extension.
     :param str value: The value of the string
     :param str language: The language code of the string
     :param str table: The string table to use
-    :param Optional[str] comment: The comment for the string
-    :param Optional[str] key_extension: The key extension to differentiate
+    :param str | None comment: The comment for the string
+    :param str | None key_extension: The key extension to differentiate
                                         between identical strings with different
                                         meanings
     :param str bundle: The bundle the string can be found in
     """
 
-    _TOKEN_REGEX: ClassVar[
-        str
-    ] = r"(%(?:[0-9]+\$)?[0-9]*\.?[0-9]*[a-zA-Z]{0,2}[dDuUxXoOfFeEgGcCsSaAp@])"
+    _TOKEN_REGEX: ClassVar[str] = (
+        r"(%(?:[0-9]+\$)?[0-9]*\.?[0-9]*[a-zA-Z]{0,2}[dDuUxXoOfFeEgGcCsSaAp@])"
+    )
     _TOKEN_PATTERN: ClassVar[Pattern] = re.compile(_TOKEN_REGEX, flags=re.DOTALL)
 
     key: str
     value: str
     language: str
     table: str
-    comment: Optional[str]
-    key_extension: Optional[str]
+    comment: str | None
+    key_extension: str | None
     bundle: str
 
+    # pylint: disable=too-many-arguments
     def __init__(
         self,
         *,
-        key: Optional[str],
+        key: str | None,
         value: str,
         language: str,
         table: str,
-        comment: Optional[str] = None,
-        key_extension: Optional[str] = None,
+        comment: str | None = None,
+        key_extension: str | None = None,
         bundle: str = "",
     ) -> None:
         self.value = value
@@ -69,8 +71,10 @@ class LocalizedString:
         else:
             self.key = LocalizedString._calculate_key(value=value, key_extension=key_extension)
 
+    # pylint: enable=too-many-arguments
+
     @staticmethod
-    def _calculate_key(*, value: str, key_extension: Optional[str]) -> str:
+    def _calculate_key(*, value: str, key_extension: str | None) -> str:
         """Calculate the unique key to use for this string.
 
         :param value: The value of the localized string
@@ -93,7 +97,7 @@ class LocalizedString:
 
         return key
 
-    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
@@ -108,7 +112,7 @@ class LocalizedString:
         :raises Exception: If the language is not English
         """
         if self.language != "en":
-            raise Exception(f"This should only be called for English strings: {self}")
+            raise DotStringsException(f"This should only be called for English strings: {self}")
         return (
             "NSLocalizedStringWithDefaultValue("
             + f'@"{self.key}", @"{self.table}", @"{self.bundle}", @"{self.value}", @"{self.comment}");'
@@ -186,11 +190,11 @@ class LocalizedString:
 
     @staticmethod
     def from_dotstring_entries(
-        *, entries: List[DotStringsEntry], language: str, table: str
-    ) -> List["LocalizedString"]:
+        *, entries: list[DotStringsEntry], language: str, table: str
+    ) -> list["LocalizedString"]:
         """Convert a list of DotStringsEntry's into a list of LocalizedString's
 
-        :param List[DotStringsEntry] entries: The DotStringsEntry's to convert
+        :param list[DotStringsEntry] entries: The DotStringsEntry's to convert
         :param str language: The language the DotStringsEntry's are in
         :param str table: The table the DotStringsEntry's are from
 

{dotstrings-2.0.0 → dotstrings-3.1.0}/dotstrings/parser.py

@@ -2,8 +2,9 @@
 
 import plistlib
 import re
-from typing import BinaryIO, List, Optional, Pattern, TextIO, Union
+from typing import BinaryIO, Pattern, TextIO
 
+from dotstrings.exceptions import DotStringsException
 from dotstrings.dot_strings_entry import DotStringsEntry
 from dotstrings.dot_stringsdict_entry import DotStringsDictEntry
 
@@ -13,7 +14,8 @@ class Patterns:
 
     comment = re.compile(r"(\'(?:[^\'\\]|\\[\s\S])*\')|//.*|/\*(?:[^*]|\*(?!/))*\*/", re.MULTILINE)
     whitespace = re.compile(r"\s*", re.MULTILINE)
-    entry = re.compile(r'"(.*)" = "(.*)";')
+    entry = re.compile(r'"(.*)"\s*=\s*"(.*)";')
+    quoteless_key_entry = re.compile(r'(.*?)\s*=\s*"(.*)";')
 
 
 class Scanner:
@@ -33,7 +35,7 @@ class Scanner:
         """
         return self.offset < len(self.string)
 
-    def scan(self, pattern: Union[str, Pattern], flags: int = 0) -> Optional[str]:
+    def scan(self, pattern: str | Pattern, flags: int = 0) -> str | None:
         """Scan a string for a pattern and return the string if found.
 
         :param pattern: The pattern to scan for
@@ -56,7 +58,7 @@ class Scanner:
         return None
 
 
-def load(file_details: Union[TextIO, str], encoding: Optional[str] = None) -> List[DotStringsEntry]:
+def load(file_details: TextIO | str, encoding: str | None = None) -> list[DotStringsEntry]:
     """Parse the contents of a .strings file from a file pointer.
 
     :param file_details: The file pointer or a file path
@@ -83,10 +85,10 @@ def load(file_details: Union[TextIO, str], encoding: Optional[str] = None) -> Li
         except UnicodeDecodeError:
             pass
 
-    raise Exception(f"Could not determine encoding for file at path: {file_details}")
+    raise DotStringsException(f"Could not determine encoding for file at path: {file_details}")
 
 
-def loads(contents: str) -> List[DotStringsEntry]:
+def loads(contents: str) -> list[DotStringsEntry]:
     """Parse the contents of a .strings file.
 
     Note: CRLF is not supported in strings.
@@ -98,7 +100,7 @@ def loads(contents: str) -> List[DotStringsEntry]:
     # Sometimes we have CRLF. It's easier to just replace now. This could, in
     # theory, cause issues, but we just don't support it for now.
     if "\r\n" in contents:
-        raise Exception("Strings contain CRLF")
+        raise DotStringsException("Strings contain CRLF")
     contents = contents.replace("\r\n", "\n")
 
     scanner = Scanner(contents)
@@ -136,18 +138,32 @@ def loads(contents: str) -> List[DotStringsEntry]:
             # Pull out any whitespace
             _ = scanner.scan(Patterns.whitespace)
 
-        # Get the entry line
+        # Get the entry line. Always try with quotes first to avoid matching
+        # the "quoteless" style and then including the quotes in the key.
         entry = scanner.scan(Patterns.entry)
+        regular_entry = True
 
         if entry is None:
-            if scanner.has_more():
-                raise Exception(f"Expected an entry at offset {scanner.offset}")
-            break
+            entry = scanner.scan(Patterns.quoteless_key_entry)
+            regular_entry = False
+
+            if entry is None:
+                if scanner.has_more():
+                    raise DotStringsException(
+                        f"Expected an entry at offset {scanner.offset}"
+                    )
+                break
 
         # Now extract the key and value
-        entry_matches = Patterns.entry.search(entry)
+        if regular_entry:
+            entry_matches = Patterns.entry.search(entry)
+        else:
+            entry_matches = Patterns.quoteless_key_entry.search(entry)
+
         if not entry_matches:
-            raise Exception(f"Failed to parse entry at offset {scanner.offset}")
+            raise DotStringsException(
+                f"Failed to parse entry at offset {scanner.offset}"
+            )
 
         key = entry_matches.group(1)
         value = entry_matches.group(2)
@@ -157,7 +173,7 @@ def loads(contents: str) -> List[DotStringsEntry]:
     return strings
 
 
-def load_dict(file_details: Union[BinaryIO, str]) -> List[DotStringsDictEntry]:
+def load_dict(file_details: BinaryIO | str) -> list[DotStringsDictEntry]:
     """Parse the contents of a .stringsdict file from a file pointer.
 
     :param file_details: The file pointer or a file path
@@ -174,7 +190,7 @@ def load_dict(file_details: Union[BinaryIO, str]) -> List[DotStringsDictEntry]:
         return load_dict(stringsdict_file)
 
 
-def loads_dict(contents: bytes) -> List[DotStringsDictEntry]:
+def loads_dict(contents: bytes) -> list[DotStringsDictEntry]:
     """Parse the contents of a .stringsdict file from binary data.
 
     :param contents: The binary data of a .stringsdict file
@@ -185,12 +201,12 @@ def loads_dict(contents: bytes) -> List[DotStringsDictEntry]:
     strings_dict = plistlib.loads(contents)
 
     if not isinstance(strings_dict, dict):
-        raise Exception("stringsdict format is incorrect")
+        raise DotStringsException("stringsdict format is incorrect")
 
     entries = []
     for key, entry in strings_dict.items():
         if not isinstance(entry, dict):
-            raise Exception("stringsdict entry format is incorrect")
+            raise DotStringsException("stringsdict entry format is incorrect")
 
         entries.append(DotStringsDictEntry.parse(key, entry))
 

{dotstrings-2.0.0 → dotstrings-3.1.0}/pyproject.toml

@@ -1,12 +1,12 @@
 [tool.poetry]
 name = "dotstrings"
-version = "2.0.0"
+version = "3.1.0"
 description = "Tools for dealing with the .strings files for iOS and macOS"
 
 license = "MIT"
 
 authors = [
-    "Dale Myers <dalemy@microsoft.com>"
+    "Dale Myers <dalemyers@microsoft.com>"
 ]
 
 readme = 'README.md'
@@ -31,14 +31,14 @@ classifiers = [
 ]
 
 [tool.poetry.dependencies]
-python = "^3.8"
+python = "^3.10"
 
 [tool.poetry.dev-dependencies]
-black = "^22.10.0"
-mypy = "^0.991"
-pylint = "^2.15.6"
-pytest = "^7.2.0"
-pytest-cov = "^4.0.0"
+black = "24.4.0"
+mypy = "1.9.0"
+pylint = "3.1.0"
+pytest = "^8.1.0"
+pytest-cov = "^5.0.0"
 
 
 [build-system]