2.2.2: fix remote connections, enable spell-checking and custom rules, more refactoring

Author: jxmorris12

language_tool_python/__main__.py

@@ -5,10 +5,12 @@
 import re
 import sys
 
-from . import __version__
 from .server import LanguageTool
 from .utils import LanguageToolError
 
+import pkg_resources 
+__version__ = pkg_resources.require("language_tool_python")[0].version
+
 
 def parse_args():
     parser = argparse.ArgumentParser(
@@ -138,8 +140,8 @@ def main():
         if not args.spell_check:
             lang_tool.disable_spellchecking()
 
-        lang_tool.disabled.update(args.disable)
-        lang_tool.enabled.update(args.enable)
+        lang_tool.disabled_rules.update(args.disable)
+        lang_tool.enabled_rules.update(args.enable)
         lang_tool.enabled_only = args.enabled_only
 
         try:

language_tool_python/language_tag.py

@@ -1,43 +1,35 @@
 import re
 
-from .utils import get_languages
-
 from functools import total_ordering
 
 @total_ordering
-class LanguageTag(str):
-
+class LanguageTag:
     """Language tag supported by LanguageTool."""
     _LANGUAGE_RE = re.compile(r"^([a-z]{2,3})(?:[_-]([a-z]{2}))?$", re.I)
 
-    def __new__(cls, tag):
-        # Can't use super() here because of 3to2.
-        return str.__new__(cls, cls._normalize(tag))
+    def __init__(self, tag, languages):
+        self.tag = tag
+        self.languages = languages
+        self.normalized_tag = self._normalize(tag)
 
-    def __eq__(self, other):
-        try:
-            other = self._normalize(other)
-        except ValueError:
-            pass
-        return str(self) == other
+    def __eq__(self, other_tag):
+        return self.normalized_tag == self._normalize(other_tag)
 
-    def __lt__(self, other):
-        try:
-            other = self._normalize(other)
-        except ValueError:
-            pass
-        return str(self) < other
+    def __lt__(self, other_tag):
+        return str(self) < self._normalize(other)
+
+    def __str__(self):
+        return self.normalized_tag
 
-    @classmethod
-    def _normalize(cls, tag):
+    def _normalize(self, tag):
         if not tag:
             raise ValueError('empty language tag')
         languages = {language.lower().replace('-', '_'): language
-                     for language in get_languages()}
+                     for language in self.languages}
         try:
             return languages[tag.lower().replace('-', '_')]
         except KeyError:
             try:
-                return languages[cls._LANGUAGE_RE.match(tag).group(1).lower()]
+                return languages[self._LANGUAGE_RE.match(tag).group(1).lower()]
             except (KeyError, AttributeError):
                 raise ValueError('unsupported language: {!r}'.format(tag))