revert cls change

Author: jxmorris12

language_tool_python/server.py

@@ -31,7 +31,6 @@ class LanguageTool:
     _PORT_RE = re.compile(r"(?:https?://.*:|port\s+)(\d+)", re.I)
 
     def __init__(self, language=None, motherTongue=None, remote_server=None):
-        print('__init__', remote_server)
         if remote_server is not None:
             self._remote = True
             if remote_server[-1] == '/': remote_server = remote_server[:-1]
@@ -135,38 +134,42 @@ def disable_spellchecking(self):
         """Disable spell-checking rules."""
         self.disabled_rules.update(self._spell_checking_rules)
 
-    def _get_languages(self) -> set:
+    @classmethod
+    def _get_languages(cls) -> set:
         """Get supported languages (by querying the server)."""
-        import pdb; pdb.set_trace()
-        self._start_server_if_needed()
-        url = urllib.parse.urljoin(self._url, 'languages')
+        cls._start_server_if_needed()
+        url = urllib.parse.urljoin(cls._url, 'languages')
         languages = set()
-        for e in self._get_root(url, num_tries=1):
+        for e in cls._get_root(url, num_tries=1):
             languages.add(e.get('code'))
             languages.add(e.get('longCode'))
         return languages
 
-    def _get_attrib(self):
+    @classmethod
+    def _get_attrib(cls):
         """Get matches element attributes."""
-        self._start_server_if_needed()
+        cls._start_server_if_needed()
         params = {'language': FAILSAFE_LANGUAGE, 'text': ''}
         data = urllib.parse.urlencode(params).encode()
-        root = self._get_root(self._url, data, num_tries=1)
+        root = cls._get_root(cls._url, data, num_tries=1)
         return root.attrib
 
-    def _start_server_if_needed(self):
+    @classmethod
+    def _start_server_if_needed(cls):
         # Start server.
-        if not self._server_is_alive() and self._remote is False:
-            self._start_server_on_free_port()
+        if not cls._server_is_alive() and cls._remote is False:
+            cls._start_server_on_free_port()
 
-    def _update_remote_server_config(self, url):
-        self._url = url
-        self._remote = True
+    @classmethod
+    def _update_remote_server_config(cls, url):
+        cls._url = url
+        cls._remote = True
 
-    def _get_root(self, url, data=None, num_tries=2):
+    @classmethod
+    def _get_root(cls, url, data=None, num_tries=2):
         for n in range(num_tries):
             try:
-                with urlopen(url, data, self._TIMEOUT) as f:
+                with urlopen(url, data, cls._TIMEOUT) as f:
                     raw_data = f.read().decode('utf-8')
                     try:
                         return json.loads(raw_data)
@@ -175,38 +178,39 @@ def _get_root(self, url, data=None, num_tries=2):
                         print(raw_data)
                         raise e
             except (IOError, http.client.HTTPException) as e:
-                if self._remote is False:
-                    self._terminate_server()
-                    self._start_local_server()
+                if cls._remote is False:
+                    cls._terminate_server()
+                    cls._start_local_server()
                 if n + 1 >= num_tries:
-                    raise LanguageToolError('{}: {}'.format(self._url, e))
+                    raise LanguageToolError('{}: {}'.format(cls._url, e))
 
-    def _start_server_on_free_port(self):
+    @classmethod
+    def _start_server_on_free_port(cls):
         while True:
-            self._url = 'http://{}:{}/v2/'.format(self._HOST, self._port)
+            cls._url = 'http://{}:{}/v2/'.format(cls._HOST, cls._port)
             try:
-                self._start_local_server()
+                cls._start_local_server()
                 break
             except ServerError:
-                if self._MIN_PORT <= self._port < self._MAX_PORT:
-                    self._port += 1
+                if cls._MIN_PORT <= cls._port < cls._MAX_PORT:
+                    cls._port += 1
                 else:
                     raise
 
-
-    def _start_local_server(self):
+    @classmethod
+    def _start_local_server(cls):
         # Before starting local server, download language tool if needed.
         download_lt()
 
         err = None
         try:
-            server_cmd = get_server_cmd(self._port)
+            server_cmd = get_server_cmd(cls._port)
         except PathError as e:
             # Can't find path to LanguageTool.
             err = e
         else:
             # Need to PIPE all handles: http://bugs.python.org/issue3905
-            self._server = subprocess.Popen(
+            cls._server = subprocess.Popen(
                 server_cmd,
                 stdin=subprocess.PIPE,
                 stdout=subprocess.PIPE,
@@ -215,84 +219,86 @@ def _start_local_server(self):
                 startupinfo=startupinfo
             )
             # Python 2.7 compatibility
-            # for line in self._server.stdout:
+            # for line in cls._server.stdout:
             match = None
             while True:
-                line = self._server.stdout.readline()
+                line = cls._server.stdout.readline()
                 if not line:
                     break
-                match = self._PORT_RE.search(line)
+                match = cls._PORT_RE.search(line)
                 if match:
                     port = int(match.group(1))
-                    if port != self._port:
+                    if port != cls._port:
                         raise LanguageToolError('requested port {}, but got {}'.format(
-                            self._port, port))
+                            cls._port, port))
                     break
             if not match:
-                err_msg = self._terminate_server()
-                match = self._PORT_RE.search(err_msg)
+                err_msg = cls._terminate_server()
+                match = cls._PORT_RE.search(err_msg)
                 if not match:
                     raise LanguageToolError(err_msg)
                 port = int(match.group(1))
-                if port != self._port:
+                if port != cls._port:
                     raise LanguageToolError(err_msg)
 
-        if self._server:
-            self._consumer_thread = threading.Thread(
-                target=lambda: _consume(self._server.stdout))
-            self._consumer_thread.daemon = True
-            self._consumer_thread.start()
+        if cls._server:
+            cls._consumer_thread = threading.Thread(
+                target=lambda: _consume(cls._server.stdout))
+            cls._consumer_thread.daemon = True
+            cls._consumer_thread.start()
         else:
             # Couldn't start the server, so maybe there is already one running.
             params = {'language': FAILSAFE_LANGUAGE, 'text': ''}
             data = urllib.parse.urlencode(params).encode()
             try:
-                with urlopen(self._url, data, self._TIMEOUT) as f:
+                with urlopen(cls._url, data, cls._TIMEOUT) as f:
                     tree = ElementTree.parse(f)
             except (IOError, http.client.HTTPException) as e:
                 if err:
                     raise err
-                raise ServerError('{}: {}'.format(self._url, e))
+                raise ServerError('{}: {}'.format(cls._url, e))
             root = tree.getroot()
 
             # LanguageTool 1.9+
             if root.get('software') != 'LanguageTool':
                 raise ServerError('unexpected software from {}: {!r}'
-                                  .format(self._url, root.get('software')))
+                                  .format(cls._url, root.get('software')))
             raise ServerError('Server running; don\'t start a server here.')
 
-    def _server_is_alive(self):
-        return self._server and self._server.poll() is None
+    @classmethod
+    def _server_is_alive(cls):
+        return cls._server and cls._server.poll() is None
 
-    def _terminate_server(self):
+    @classmethod
+    def _terminate_server(cls):
         LanguageToolError_message = ''
 
         try:
-            self._server.terminate()
+            cls._server.terminate()
         except OSError:
             pass
 
         try:
-            LanguageToolError_message = self._server.communicate()[1].strip()
+            LanguageToolError_message = cls._server.communicate()[1].strip()
         except (IOError, ValueError):
             pass
 
         try:
-            self._server.stdout.close()
+            cls._server.stdout.close()
         except IOError:
             pass
 
         try:
-            self._server.stdin.close()
+            cls._server.stdin.close()
         except IOError:
             pass
 
         try:
-            self._server.stderr.close()
+            cls._server.stderr.close()
         except IOError:
             pass
 
-        self._server = None
+        cls._server = None
 
         return LanguageToolError_message
 
@@ -302,11 +308,11 @@ class LanguageToolPublicAPI(LanguageTool):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, remote_server='https://api.languagetool.org', **kwargs)
 
-# @atexit.register
-# def terminate_server():
-#     """Terminate the server."""
-#     if LanguageTool._server_is_alive():
-#         LanguageTool._terminate_server()
+@atexit.register
+def terminate_server():
+    """Terminate the server."""
+    if LanguageTool._server_is_alive():
+        LanguageTool._terminate_server()