fix: from camel case to snake case for some params and attribs (breaking)

Author: mdevolde

MANIFEST.in

@@ -19,6 +19,7 @@ prune docs/
 prune tests/
 
 exclude .gitignore
+exclude .readthedocs.yaml
 exclude build_and_publish.sh
 exclude CONTRIBUTING.md
 exclude make.bat

README.md

@@ -71,7 +71,7 @@ If you want to apply a particular suggestion from a `Match`, use `Match.select_r
 >>> tool = language_tool_python.LanguageTool('en-US')
 >>> matches = tool.check(s)
 >>> matches
-[Match({'ruleId': 'MORFOLOGIK_RULE_EN_US', 'message': 'Possible spelling mistake found.', 'replacements': ['BOK', 'OK', 'book', 'box'], 'offsetInContext': 11, 'context': 'There is a bok on the table.', 'offset': 11, 'errorLength': 3, 'category': 'TYPOS', 'ruleIssueType': 'misspelling', 'sentence': 'There is a bok on the table.'})]
+[Match({'rule_id': 'MORFOLOGIK_RULE_EN_US', 'message': 'Possible spelling mistake found.', 'replacements': ['BOK', 'OK', 'book', 'box'], 'offset_in_context': 11, 'context': 'There is a bok on the table.', 'offset': 11, 'error_length': 3, 'category': 'TYPOS', 'rule_issue_type': 'misspelling', 'sentence': 'There is a bok on the table.'})]
 >>> matches[0].select_replacement(2) 
 >>> patched_text = language_tool_python.utils.correct(s, matches)    
 >>> patched_text
@@ -115,9 +115,9 @@ From the interpreter:
 Check out some ``Match`` object attributes:
 
 ```python
->>> matches[0].ruleId, matches[0].replacements # ('EN_A_VS_AN', ['an'])
+>>> matches[0].rule_id, matches[0].replacements # ('EN_A_VS_AN', ['an'])
 ('EN_A_VS_AN', ['an'])
->>> matches[1].ruleId, matches[1].replacements
+>>> matches[1].rule_id, matches[1].replacements
 ('TOT_HE', ['to the'])
 ```
 
@@ -188,7 +188,7 @@ You can run LanguageTool on one host and connect to it from another.  This is us
 >>>
 >>>
 >>> lang_tool.check('helo darknes my old frend')
-[Match({'ruleId': 'UPPERCASE_SENTENCE_START', 'message': 'This sentence does not start with an uppercase letter.', 'replacements': ['Helo'], 'offsetInContext': 0, 'context': 'helo darknes my old frend', 'offset': 0, 'errorLength': 4, 'category': 'CASING', 'ruleIssueType': 'typographical', 'sentence': 'helo darknes my old frend'}), Match({'ruleId': 'MORFOLOGIK_RULE_EN_US', 'message': 'Possible spelling mistake found.', 'replacements': ['darkness', 'darkens', 'darkies'], 'offsetInContext': 5, 'context': 'helo darknes my old frend', 'offset': 5, 'errorLength': 7, 'category': 'TYPOS', 'ruleIssueType': 'misspelling', 'sentence': 'helo darknes my old frend'}), Match({'ruleId': 'MORFOLOGIK_RULE_EN_US', 'message': 'Possible spelling mistake found.', 'replacements': ['friend', 'trend', 'Fred', 'freed', 'Freud', 'Friend', 'fend', 'fiend', 'frond', 'rend', 'fr end'], 'offsetInContext': 20, 'context': 'helo darknes my old frend', 'offset': 20, 'errorLength': 5, 'category': 'TYPOS', 'ruleIssueType': 'misspelling', 'sentence': 'helo darknes my old frend'})]
+[Match({'rule_id': 'UPPERCASE_SENTENCE_START', 'message': 'This sentence does not start with an uppercase letter.', 'replacements': ['Helo'], 'offset_in_Context': 0, 'context': 'helo darknes my old frend', 'offset': 0, 'error_length': 4, 'category': 'CASING', 'rule_issue_type': 'typographical', 'sentence': 'helo darknes my old frend'}), Match({'rule_id': 'MORFOLOGIK_RULE_EN_US', 'message': 'Possible spelling mistake found.', 'replacements': ['darkness', 'darkens', 'darkies'], 'offset_in_context': 5, 'context': 'helo darknes my old frend', 'offset': 5, 'error_length': 7, 'category': 'TYPOS', 'rule_issue_type': 'misspelling', 'sentence': 'helo darknes my old frend'}), Match({'rule_id': 'MORFOLOGIK_RULE_EN_US', 'message': 'Possible spelling mistake found.', 'replacements': ['friend', 'trend', 'Fred', 'freed', 'Freud', 'Friend', 'fend', 'fiend', 'frond', 'rend', 'fr end'], 'offset_in_context': 20, 'context': 'helo darknes my old frend', 'offset': 20, 'error_length': 5, 'category': 'TYPOS', 'rule_issue_type': 'misspelling', 'sentence': 'helo darknes my old frend'})]
 >>>
 ```
 

language_tool_python/__main__.py

@@ -254,7 +254,7 @@ def main() -> int:
                 remote_server += f":{args.remote_port}"
         with LanguageTool(
             language=args.language,
-            motherTongue=args.mother_tongue,
+            mother_tongue=args.mother_tongue,
             remote_server=remote_server,
         ) as lang_tool:
             try:
@@ -278,7 +278,7 @@ def main() -> int:
                     print(lang_tool.correct(text))
                 else:
                     for match in lang_tool.check(text):
-                        rule_id = match.ruleId
+                        rule_id = match.rule_id
 
                         replacement_text = ", ".join(
                             f"'{word}'" for word in match.replacements

language_tool_python/match.py

@@ -29,28 +29,28 @@ def get_match_ordered_dict() -> OrderedDictType[str, type]:
 
     The keys and their corresponding types are:
 
-    - 'ruleId': str
+    - 'rule_id': str
     - 'message': str
     - 'replacements': list
-    - 'offsetInContext': int
+    - 'offset_in_context': int
     - 'context': str
     - 'offset': int
-    - 'errorLength': int
+    - 'error_length': int
     - 'category': str
-    - 'ruleIssueType': str
+    - 'rule_issue_type': str
     - 'sentence': str
     """
     return OrderedDict(
         [
-            ("ruleId", str),
+            ("rule_id", str),
             ("message", str),
             ("replacements", list),
-            ("offsetInContext", int),
+            ("offset_in_context", int),
             ("context", str),
             ("offset", int),
-            ("errorLength", int),
+            ("error_length", int),
             ("category", str),
-            ("ruleIssueType", str),
+            ("rule_issue_type", str),
             ("sentence", str),
         ],
     )
@@ -147,7 +147,7 @@ class Match:
     """The positions of 4-byte encoded characters in the text, registered by the previous match object
     (kept for optimization purposes if the text is the same)."""
 
-    ruleId: str
+    rule_id: str
     """The ID of the rule that was violated."""
 
     message: str
@@ -156,7 +156,7 @@ class Match:
     replacements: List[str]
     """A list of suggested replacements for the error."""
 
-    offsetInContext: int
+    offset_in_context: int
     """The offset of the error in the context."""
 
     context: str
@@ -165,13 +165,13 @@ class Match:
     offset: int
     """The offset of the error."""
 
-    errorLength: int
+    error_length: int
     """The length of the error."""
 
     category: str
     """The category of the rule that was violated."""
 
-    ruleIssueType: str
+    rule_issue_type: str
     """The issue type of the rule that was violated."""
 
     def __init__(self, attrib: Dict[str, Any], text: str) -> None:
@@ -184,16 +184,16 @@ def __init__(self, attrib: Dict[str, Any], text: str) -> None:
 
         # Process rule.
         attrib["category"] = attrib["rule"]["category"]["id"]
-        attrib["ruleId"] = attrib["rule"]["id"]
-        attrib["ruleIssueType"] = attrib["rule"]["issueType"]
+        attrib["rule_id"] = attrib["rule"]["id"]
+        attrib["rule_issue_type"] = attrib["rule"]["issueType"]
         del attrib["rule"]
         # Process context.
-        attrib["offsetInContext"] = attrib["context"]["offset"]
+        attrib["offset_in_context"] = attrib["context"]["offset"]
         attrib["context"] = attrib["context"]["text"]
         # Process replacements.
         attrib["replacements"] = [r["value"] for r in attrib["replacements"]]
         # Rename error length.
-        attrib["errorLength"] = attrib["length"]
+        attrib["error_length"] = attrib["length"]
         # Normalize unicode
         attrib["message"] = unicodedata.normalize("NFKC", attrib["message"])
         # Store objects on self.
@@ -253,25 +253,25 @@ def __str__(self) -> str:
         :return: A formatted string describing the match object.
         :rtype: str
         """
-        ruleId = self.ruleId
-        s = f"Offset {self.offset}, length {self.errorLength}, Rule ID: {ruleId}"
+        rule_id = self.rule_id
+        s = f"Offset {self.offset}, length {self.error_length}, Rule ID: {rule_id}"
         if self.message:
             s += f"\nMessage: {self.message}"
         if self.replacements:
             s += f"\nSuggestion: {'; '.join(self.replacements)}"
-        s += f"\n{self.context}\n{' ' * self.offsetInContext + '^' * self.errorLength}"
+        s += f"\n{self.context}\n{' ' * self.offset_in_context + '^' * self.error_length}"
         return s
 
     @property
-    def matchedText(self) -> str:
+    def matched_text(self) -> str:
         """
         Returns the substring from the context that corresponds to the matched text.
 
         :return: The matched text from the context.
         :rtype: str
         """
         return self.context[
-            self.offsetInContext : self.offsetInContext + self.errorLength
+            self.offset_in_context : self.offset_in_context + self.error_length
         ]
 
     def get_line_and_column(self, original_text: str) -> Tuple[int, int]:

language_tool_python/server.py

@@ -65,12 +65,12 @@ class LanguageTool:
 
     :param language: The language to be used by the LanguageTool server. If None, it will try to detect the system language.
     :type language: Optional[str]
-    :param motherTongue: The mother tongue of the user.
-    :type motherTongue: Optional[str]
+    :param mother_tongue: The mother tongue of the user.
+    :type mother_tongue: Optional[str]
     :param remote_server: URL of a remote LanguageTool server. If provided, the local server will not be started.
     :type remote_server: Optional[str]
-    :param newSpellings: Custom spellings to be added to the LanguageTool server.
-    :type newSpellings: Optional[List[str]]
+    :param new_spellings: Custom spellings to be added to the LanguageTool server.
+    :type new_spellings: Optional[List[str]]
     :param new_spellings_persist: Whether the new spellings should persist across sessions.
     :type new_spellings_persist: Optional[bool]
     :param host: The host address for the LanguageTool server. Defaults to 'localhost'.
@@ -144,9 +144,9 @@ class LanguageTool:
     def __init__(
         self,
         language: Optional[str] = None,
-        motherTongue: Optional[str] = None,
+        mother_tongue: Optional[str] = None,
         remote_server: Optional[str] = None,
-        newSpellings: Optional[List[str]] = None,
+        new_spellings: Optional[List[str]] = None,
         new_spellings_persist: bool = True,
         host: Optional[str] = None,
         config: Optional[Dict[str, Any]] = None,
@@ -160,8 +160,7 @@ def __init__(
         self._new_spellings = None
         self._new_spellings_persist = new_spellings_persist
         self._host = host or socket.gethostbyname("localhost")
-        self._available_ports = list(range(8081, 8999))
-        random.shuffle(self._available_ports)
+        self._available_ports = random.sample(range(8081, 8999), (8999 - 8081))
         self._port = self._available_ports.pop()
         self._server = None
 
@@ -183,11 +182,11 @@ def __init__(
                 language = get_locale_language()
             except ValueError:
                 language = FAILSAFE_LANGUAGE
-        if newSpellings:
-            self._new_spellings = newSpellings
+        if new_spellings:
+            self._new_spellings = new_spellings
             self._register_spellings()
         self._language = LanguageTag(language, self._get_languages())
-        self._mother_tongue = motherTongue
+        self._mother_tongue = mother_tongue
         self.disabled_rules = set()
         self.enabled_rules = set()
         self.disabled_categories = set()
@@ -255,7 +254,7 @@ def __repr__(self) -> str:
         :return: A string that includes the class name, language, and mother tongue.
         :rtype: str
         """
-        return f"{self.__class__.__name__}(language={self.language!r}, motherTongue={self.motherTongue!r})"
+        return f"{self.__class__.__name__}(language={self.language!r}, motherTongue={self.mother_tongue!r})"
 
     def close(self) -> None:
         """
@@ -297,7 +296,7 @@ def language(self, language: str) -> None:
         self.enabled_rules.clear()
 
     @property
-    def motherTongue(self) -> Optional[LanguageTag]:
+    def mother_tongue(self) -> Optional[LanguageTag]:
         """
         Retrieve the mother tongue language tag.
 
@@ -308,16 +307,16 @@ def motherTongue(self) -> Optional[LanguageTag]:
             return LanguageTag(self._mother_tongue, self._get_languages())
         return None
 
-    @motherTongue.setter
-    def motherTongue(self, motherTongue: Optional[str]) -> None:
+    @mother_tongue.setter
+    def mother_tongue(self, mother_tongue: Optional[str]) -> None:
         """
         Sets the mother tongue for the language tool.
 
-        :param motherTongue: The mother tongue language tag as a string. If None, the mother tongue is set to None.
-        :type motherTongue: Optional[str]
+        :param mother_tongue: The mother tongue language tag as a string. If None, the mother tongue is set to None.
+        :type mother_tongue: Optional[str]
         """
 
-        self._mother_tongue = motherTongue
+        self._mother_tongue = mother_tongue
 
     @property
     def _spell_checking_categories(self) -> Set[str]:
@@ -367,8 +366,8 @@ def _create_params(self, text: str) -> Dict[str, str]:
         - 'level': 'picky' if picky mode is enabled.
         """
         params = {"language": str(self.language), "text": text}
-        if self.motherTongue is not None:
-            params["motherTongue"] = self.motherTongue.tag
+        if self.mother_tongue is not None:
+            params["motherTongue"] = self.mother_tongue.tag
         if self.disabled_rules:
             params["disabledRules"] = ",".join(self.disabled_rules)
         if self.enabled_rules:
@@ -452,9 +451,7 @@ def _register_spellings(self) -> None:
         spelling_file_path = self._get_valid_spelling_file_path()
         logger.debug("Registering new spellings at %s", spelling_file_path)
         with open(spelling_file_path, "r+", encoding="utf-8") as spellings_file:
-            existing_spellings = set(
-                line.strip() for line in spellings_file.readlines()
-            )
+            existing_spellings = {line.strip() for line in spellings_file.readlines()}
             new_spellings = [
                 word for word in self._new_spellings if word not in existing_spellings
             ]

language_tool_python/utils.py

@@ -104,13 +104,13 @@ def correct(text: str, matches: List[Match]) -> str:
     ltext = list(text)
     matches = [match for match in matches if match.replacements]
     errors = [
-        ltext[match.offset : match.offset + match.errorLength] for match in matches
+        ltext[match.offset : match.offset + match.error_length] for match in matches
     ]
     correct_offset = 0
     for n, match in enumerate(matches):
         frompos, topos = (
             correct_offset + match.offset,
-            correct_offset + match.offset + match.errorLength,
+            correct_offset + match.offset + match.error_length,
         )
         if ltext[frompos:topos] != errors[n]:
             continue