docs: adding typing annotations in the whole project

Author: mdevolde

language_tool_python/__main__.py

@@ -4,8 +4,9 @@
 import locale
 import re
 import sys
-from importlib.metadata import version
+from importlib.metadata import version, PackageNotFoundError
 import toml
+from typing import Any, Optional, Set, Union
 
 from .server import LanguageTool
 from .utils import LanguageToolError
@@ -17,7 +18,7 @@
         __version__ = toml.loads(f.read().decode('utf-8'))["project"]["version"]
 
 
-def parse_args():
+def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(
         description=__doc__.strip() if __doc__ else None,
         prog='language_tool_python')
@@ -69,22 +70,22 @@ def parse_args():
 
 
 class RulesAction(argparse.Action):
-    def __call__(self, parser, namespace, values, option_string=None):
+    def __call__(self, parser: argparse.ArgumentParser, namespace: Any, values: Any, option_string: Optional[str] = None) -> str:
         getattr(namespace, self.dest).update(values)
 
 
-def get_rules(rules: str) -> set:
+def get_rules(rules: str) -> Set[str]:
     return {rule.upper() for rule in re.findall(r"[\w\-]+", rules)}
 
 
-def get_text(filename, encoding, ignore):
+def get_text(filename: Union[str, int], encoding: Optional[str], ignore: Optional[str]) -> str:
     with open(filename, encoding=encoding) as f:
         text = ''.join('\n' if (ignore and re.match(ignore, line)) else line
                        for line in f.readlines())
     return text
 
 
-def main():
+def main() -> int:
     args = parse_args()
 
     status = 0

language_tool_python/console_mode.py

@@ -2,6 +2,7 @@
 """Write to stdout without causing UnicodeEncodeError."""
 
 import sys
+from typing import Any, Tuple
 
 
 if (getattr(sys.stdout, 'errors', '') == 'strict' and
@@ -21,12 +22,12 @@
             0x201d: '"',
         }
 
-        def simplify(s):
+        def simplify(s: str) -> str:
             s = s.translate(TRANSLIT_MAP)
             return ''.join([c for c in unicodedata.normalize('NFKD', s)
                             if not unicodedata.combining(c)])
 
-        def simple_translit_error_handler(error):
+        def simple_translit_error_handler(error: UnicodeEncodeError) -> Tuple[str, int]:
             if not isinstance(error, UnicodeEncodeError):
                 raise error
             chunk = error.object[error.start:error.end]
@@ -40,20 +41,20 @@ class SimpleTranslitStreamFilter:
             """Filter a stream through simple transliteration."""
             errors = 'simple_translit'
 
-            def __init__(self, target):
+            def __init__(self, target: Any) -> None:
                 self.target = target
 
-            def __getattr__(self, name):
+            def __getattr__(self, name: str) -> Any:
                 return getattr(self.target, name)
 
-            def write(self, s):
+            def write(self, s: str) -> None:
                 self.target.write(self.downgrade(s))
 
-            def writelines(self, lines):
+            def writelines(self, lines: Any) -> None:
                 self.target.writelines(
                     [self.downgrade(line) for line in lines])
 
-            def downgrade(self, s):
+            def downgrade(self, s: str) -> str:
                 return (s.encode(self.target.encoding, self.errors)
                         .decode(self.target.encoding))
 

language_tool_python/download_lt.py

@@ -10,7 +10,7 @@
 import sys
 import tempfile
 import tqdm
-from typing import Optional
+from typing import IO, Dict, Optional, Tuple
 import zipfile
 
 from shutil import which
@@ -42,7 +42,7 @@
     r'^(?:java|openjdk) [version ]?(?P<major1>\d+)\.(?P<major2>\d+)',
     re.MULTILINE)
 
-def parse_java_version(version_text):
+def parse_java_version(version_text: str) -> Tuple[int, int]:
     """Return Java version (major1, major2).
 
     >>> parse_java_version('''java version "1.6.0_65"
@@ -70,7 +70,7 @@ def parse_java_version(version_text):
     return (major1, major2)
 
 
-def confirm_java_compatibility():
+def confirm_java_compatibility() -> bool:
     """ Confirms Java major version >= 8. """
     java_path = which('java')
     if not java_path:
@@ -97,15 +97,15 @@ def confirm_java_compatibility():
         raise SystemError(f'Detected java {major_version}.{minor_version}. LanguageTool requires Java >= 8.')
 
 
-def get_common_prefix(z):
+def get_common_prefix(z: zipfile.ZipFile) -> Optional[str]:
     """Get common directory in a zip file if any."""
     name_list = z.namelist()
     if name_list and all(n.startswith(name_list[0]) for n in name_list[1:]):
         return name_list[0]
     return None
 
 
-def http_get(url, out_file, proxies=None):
+def http_get(url: str, out_file: IO[bytes], proxies: Optional[Dict[str, str]] = None) -> None:
     """ Get contents of a URL and save to a file.
     """
     req = requests.get(url, stream=True, proxies=proxies)
@@ -123,14 +123,14 @@ def http_get(url, out_file, proxies=None):
     progress.close()
 
 
-def unzip_file(temp_file, directory_to_extract_to):
+def unzip_file(temp_file: str, directory_to_extract_to: str) -> None:
     """ Unzips a .zip file to folder path. """
     logger.info(f'Unzipping {temp_file.name} to {directory_to_extract_to}.')
     with zipfile.ZipFile(temp_file.name, 'r') as zip_ref:
         zip_ref.extractall(directory_to_extract_to)
 
 
-def download_zip(url, directory):
+def download_zip(url: str, directory: str) -> None:
     """ Downloads and unzips zip file from `url` to `directory`. """
     # Download file.
     downloaded_file = tempfile.NamedTemporaryFile(suffix='.zip', delete=False)
@@ -145,7 +145,7 @@ def download_zip(url, directory):
     logger.info(f'Downloaded {url} to {directory}.')
 
 
-def download_lt(language_tool_version: Optional[str] = LTP_DOWNLOAD_VERSION):
+def download_lt(language_tool_version: Optional[str] = LTP_DOWNLOAD_VERSION) -> None:
     confirm_java_compatibility()
 
     download_folder = get_language_tool_download_path()

language_tool_python/language_tag.py

@@ -1,30 +1,30 @@
 import re
-
+from typing import Iterable, Any
 from functools import total_ordering
 
 @total_ordering
 class LanguageTag:
     """Language tag supported by LanguageTool."""
     _LANGUAGE_RE = re.compile(r"^([a-z]{2,3})(?:[_-]([a-z]{2}))?$", re.I)
 
-    def __init__(self, tag, languages):
+    def __init__(self, tag: str, languages: Iterable[str]) -> None:
         self.tag = tag
         self.languages = languages
         self.normalized_tag = self._normalize(tag)
 
-    def __eq__(self, other_tag):
+    def __eq__(self, other: Any) -> bool:
         return self.normalized_tag == self._normalize(other_tag)
 
-    def __lt__(self, other_tag):
+    def __lt__(self, other: Any) -> bool:
         return str(self) < self._normalize(other)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.normalized_tag
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f'<LanguageTag "{str(self)}">'
 
-    def _normalize(self, tag):
+    def _normalize(self, tag: str) -> str:
         if not tag:
             raise ValueError('empty language tag')
         languages = {language.lower().replace('-', '_'): language

language_tool_python/match.py

@@ -1,8 +1,9 @@
 import unicodedata
 from collections import OrderedDict
+from typing import Any, Dict, Iterator, OrderedDict as OrderedDictType
 from functools import total_ordering
 
-def get_match_ordered_dict():
+def get_match_ordered_dict() -> OrderedDictType[str, type]:
     slots = OrderedDict([
         ('ruleId', str), 
         ('message', str),
@@ -32,7 +33,7 @@ def get_match_ordered_dict():
     }
 
 """
-def auto_type(obj):
+def auto_type(obj: Any) -> Any:
     try:
         return int(obj)
     except ValueError:
@@ -44,7 +45,7 @@ def auto_type(obj):
 @total_ordering
 class Match:
     """Hold information about where a rule matches text."""
-    def __init__(self, attrib):
+    def __init__(self, attrib: Dict[str, Any]) -> None:
         # Process rule.
         attrib['category'] = attrib['rule']['category']['id']
         attrib['ruleId'] = attrib['rule']['id']
@@ -63,8 +64,8 @@ def __init__(self, attrib):
         for k, v in attrib.items():
             setattr(self, k, v)
 
-    def __repr__(self):
-        def _ordered_dict_repr():
+    def __repr__(self) -> str:
+        def _ordered_dict_repr() -> str:
             slots = list(get_match_ordered_dict())
             slots += list(set(self.__dict__).difference(slots))
             attrs = [slot for slot in slots
@@ -73,7 +74,7 @@ def _ordered_dict_repr():
 
         return f'{self.__class__.__name__}({_ordered_dict_repr()})'
 
-    def __str__(self):
+    def __str__(self) -> str:
         ruleId = self.ruleId
         s = f'Offset {self.offset}, length {self.errorLength}, Rule ID: {ruleId}'
         if self.message:
@@ -84,7 +85,7 @@ def __str__(self):
         return s
 
     @property
-    def matchedText(self):
+    def matchedText(self) -> str:
         """ Returns the text that garnered the error (without its surrounding context).
         """
         return self.context[self.offsetInContext:self.offsetInContext+self.errorLength]
@@ -98,22 +99,22 @@ def select_replacement(self, index: int) -> None:
             raise ValueError(f'This Match\'s suggestions are numbered from 0 to {len(self.replacements) - 1}')
         self.replacements = [self.replacements[index]]
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         return list(self) == list(other)
 
-    def __lt__(self, other):
+    def __lt__(self, other: Any) -> bool:
         return list(self) < list(other)
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[Any]:
         return iter(getattr(self, attr) for attr in get_match_ordered_dict())
 
-    def __setattr__(self, key, value):
+    def __setattr__(self, key: str, value: Any) -> None:
         try:
             value = get_match_ordered_dict()[key](value)
         except KeyError:
             return
         super().__setattr__(key, value)
 
-    def __getattr__(self, name):
+    def __getattr__(self, name: str) -> Any:
         if name not in get_match_ordered_dict():
             raise AttributeError(f'{self.__class__.__name__!r} object has no attribute {name!r}')