Add type hints

Author: cburgdorf

dopple/__init__.py

@@ -1,3 +1,3 @@
-from .dopple import (
-    main
-)
+from .dopple import (  # noqa: F401
+    main,
+)

dopple/dopple.py

@@ -18,20 +18,24 @@
 """
 
 from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
-from http.server import HTTPServer, BaseHTTPRequestHandler
-from os import path
-from urllib.parse import urlparse
-
 import errno
 import pkg_resources
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from os import path
 import socket
 import sys
 import time
 import threading
+from typing import Any, Optional  # noqa: F401
+from urllib.parse import urlparse
+
 
 if sys.platform == 'win32':
     import win32file
     import pywintypes
+else:
+    win32file: Any = None
+    pywintypes: Any = None
 
 try:
     VERSION = pkg_resources.get_distribution("dopple").version
@@ -40,14 +44,16 @@
 
 BUFSIZE = 32
 DELIMITER = ord('\n')
-BACKEND_CONNECTION_TIMEOUT=30.0
+BACKEND_CONNECTION_TIMEOUT = 30.0
 INFO = """Dopple JSON-RPC Proxy
 
 Version:  {version}
 Proxy:    {proxy_url}
 Backend:  {backend_url} (connected: {connected})
 """
 
+SocketAlias = socket.socket
+
 
 class BackendError(Exception):
     pass
@@ -56,19 +62,19 @@ class BackendError(Exception):
 class UnixSocketConnector(object):
     """Unix Domain Socket connector. Connects to socket lazily."""
 
-    def __init__(self, socket_path):
+    def __init__(self, socket_path: str) -> None:
         self._socket_path = socket_path
-        self._socket = None
+        self._socket: Optional[SocketAlias] = None
 
     @staticmethod
-    def _get_error_message(os_error_number):
+    def _get_error_message(os_error_number: int) -> str:
         if os_error_number == errno.ENOENT:
             return "Unix Domain Socket '{}' does not exist"
         if os_error_number == errno.ECONNREFUSED:
             return "Connection to '{}' refused"
         return "Unknown error when connecting to '{}'"
 
-    def socket(self):
+    def socket(self) -> SocketAlias:
         """Returns connected socket."""
         if self._socket is None:
             try:
@@ -83,16 +89,16 @@ def socket(self):
                 raise err from ex
         return self._socket
 
-    def close(self):
+    def close(self) -> None:
         if self._socket is not None:
             self._socket.shutdown(socket.SHUT_RDWR)
             self._socket.close()
             self._socket = None
 
-    def is_connected(self):
+    def is_connected(self) -> bool:
         return self._socket is not None
 
-    def check_connection(self, timeout):
+    def check_connection(self, timeout: float) -> None:
         SLEEPTIME = 0.1
         wait_time = 0.0
         last_exception = None
@@ -106,12 +112,15 @@ def check_connection(self, timeout):
             time.sleep(SLEEPTIME)
             wait_time += SLEEPTIME
             if wait_time > timeout:
-                raise last_exception if last_exception else TimeoutError
+                if last_exception is not None:
+                    raise last_exception
+                else:
+                    raise TimeoutError()
 
-    def recv(self, max_length):
+    def recv(self, max_length: int) -> bytes:
         return self.socket().recv(max_length)
 
-    def sendall(self, data):
+    def sendall(self, data: bytes) -> None:
         try:
             return self.socket().sendall(data)
         except OSError as ex:
@@ -126,42 +135,44 @@ def sendall(self, data):
 class NamedPipeConnector(object):
     """Windows named pipe simulating socket."""
 
-    def __init__(self, ipc_path):
+    def __init__(self, ipc_path: str) -> None:
         try:
             self.handle = win32file.CreateFile(
                 ipc_path, win32file.GENERIC_READ | win32file.GENERIC_WRITE,
                 0, None, win32file.OPEN_EXISTING, 0, None)
         except pywintypes.error as err:
             raise IOError(err)
 
-    def is_connected(self):
+    def is_connected(self) -> bool:
         return True
 
-    def check_connection(self, timeout):
+    def check_connection(self, timeout: float) -> None:
         pass
 
-    def recv(self, max_length):
+    def recv(self, max_length: int) -> Any:
         (err, data) = win32file.ReadFile(self.handle, max_length)
         if err:
             raise IOError(err)
         return data
 
-    def sendall(self, data):
+    def sendall(self, data: bytes) -> 'win32file.WriteFile':
         return win32file.WriteFile(self.handle, data)
 
-    def close(self):
+    def close(self) -> None:
         self.handle.close()
 
 
-def get_ipc_connector(ipc_path):
+def get_ipc_connector(ipc_path: str) -> Any:
     if sys.platform == 'win32':
         return NamedPipeConnector(ipc_path)
     return UnixSocketConnector(ipc_path)
 
 
 class HTTPRequestHandler(BaseHTTPRequestHandler):
 
-    def do_GET(self):
+    server: 'Proxy'
+
+    def do_GET(self) -> None:
         if self.path != '/':
             self.send_response(404)
             self.end_headers()
@@ -179,14 +190,14 @@ def do_GET(self):
                            connected=self.server.conn.is_connected())
         self.wfile.write(info.encode('utf-8'))
 
-    def do_OPTIONS(self):
+    def do_OPTIONS(self) -> None:
         self.send_response(200)
         self.send_header("Content-type", "text/plain")
         self.addCORS()
         self.end_headers()
 
-    def do_POST(self):
-        request_length = int(self.headers['Content-Length'])
+    def do_POST(self) -> None:
+        request_length = int(self.headers['Content-Length'])  # type: ignore
         request_content = self.rfile.read(request_length)
         # self.log_message("Headers:  {}".format(self.headers))
         # self.log_message("Request:  {}".format(request_content))
@@ -197,7 +208,7 @@ def do_POST(self):
 
             self.send_response(200)
             self.send_header("Content-type", "application/json")
-            self.send_header("Content-length", len(response_content))
+            self.send_header("Content-length", str(len(response_content)))
             self.addCORS()
             self.end_headers()
             self.wfile.write(response_content)
@@ -206,22 +217,22 @@ def do_POST(self):
             error_msg = str(err).encode('utf-8')
             # TODO: Send as JSON-RPC response
             self.send_header("Content-type", "text/plain")
-            self.send_header("Content-length", len(error_msg))
+            self.send_header("Content-length", str(len(error_msg)))
             self.end_headers()
             self.wfile.write(error_msg)
             self.log_message("Backend Error: {}".format(err))
 
         # TODO: Handle other exceptions as error 500.
 
-    def addCORS(self):
+    def addCORS(self) -> None:
         self.send_header("Access-Control-Allow-Origin", "*")
         self.send_header("Access-Control-Allow-Methods", "POST, GET, OPTIONS")
         self.send_header("Access-Control-Allow-Headers", "content-type")
 
 
 class Proxy(HTTPServer):
 
-    def __init__(self, proxy_url, backend_path):
+    def __init__(self, proxy_url: str, backend_path: str) -> None:
         self.proxy_url = proxy_url
         url = urlparse(proxy_url)
         assert url.scheme == 'http'
@@ -231,7 +242,7 @@ def __init__(self, proxy_url, backend_path):
 
         self.backend_address = path.expanduser(backend_path)
 
-    def process(self, request):
+    def process(self, request: Any) -> bytes:
         self.conn.sendall(request)
 
         response = b''
@@ -246,7 +257,7 @@ def process(self, request):
 
         return response
 
-    def run(self):
+    def run(self) -> None:
         self.conn = get_ipc_connector(self.backend_address)
         self.conn.check_connection(timeout=BACKEND_CONNECTION_TIMEOUT)
 
@@ -266,7 +277,7 @@ def run(self):
 PROXY_URL_HELP = "URL for this proxy server"
 
 
-def parse_args():
+def parse_args() -> Any:
     parser = ArgumentParser(
         description='Dopple HTTP Proxy for JSON-RPC servers',
         formatter_class=ArgumentDefaultsHelpFormatter
@@ -281,25 +292,26 @@ def parse_args():
     return parser.parse_args()
 
 
-def run(proxy_url=DEFAULT_PROXY_URL, backend_path=DEFAULT_BACKEND_PATH):
+def run(proxy_url: str=DEFAULT_PROXY_URL, backend_path: str=DEFAULT_BACKEND_PATH) -> None:
     proxy = Proxy(proxy_url, backend_path)
     try:
         proxy.run()
     except KeyboardInterrupt:
         proxy.shutdown()
 
 
-def run_daemon(proxy_url=DEFAULT_PROXY_URL, backend_path=DEFAULT_BACKEND_PATH):
+def run_daemon(proxy_url: str=DEFAULT_PROXY_URL, backend_path: str=DEFAULT_BACKEND_PATH) -> Proxy:
     proxy = Proxy(proxy_url, backend_path)
     th = threading.Thread(name='dopple', target=proxy.run)
     th.daemon = True
     th.start()
     return proxy
 
-def main():
+
+def main() -> None:
     args = parse_args()
     run(args.proxy_url, args.backend_path)
 
+
 if __name__ == '__main__':
     main()
-

dopple/py.typed

@@ -62,6 +62,7 @@
     zip_safe=False,
     keywords='ethereum',
     packages=find_packages(exclude=["tests", "tests.*"]),
+    package_data={'dopple': ['py.typed']},
     classifiers=[
         'Development Status :: 3 - Alpha',
         'Intended Audience :: Developers',

setup.py

@@ -38,7 +38,7 @@ whitelist_externals=make
 basepython=python
 extras=lint
 commands=
-    mypy -p {toxinidir}/dopple --config-file {toxinidir}/mypy.ini
+    mypy -p dopple --config-file {toxinidir}/mypy.ini
     flake8 {toxinidir}/dopple {toxinidir}/tests
     isort --recursive --check-only --diff {toxinidir}/dopple {toxinidir}/tests
     pydocstyle {toxinidir}/dopple {toxinidir}/tests