make fmt

Signed-off-by: Achille Roussel <achille.roussel@gmail.com>

Author: achille-roussel

src/dispatch/__init__.py

@@ -1,22 +1,23 @@
 """The Dispatch SDK for Python."""
+
 from __future__ import annotations
 
 import os
-import dispatch.integrations
-
 from concurrent import futures
 from http.server import HTTPServer
 from typing import Any, Callable, Coroutine, Optional, TypeVar, overload
-from typing_extensions import ParamSpec, TypeAlias
 from urllib.parse import urlsplit
 
+from typing_extensions import ParamSpec, TypeAlias
+
+import dispatch.integrations
 from dispatch.coroutine import all, any, call, gather, race
 from dispatch.function import DEFAULT_API_URL, Client, Function, Registry, Reset
 from dispatch.http import Dispatch
 from dispatch.id import DispatchID
 from dispatch.proto import Call, Error, Input, Output
-from dispatch.status import Status
 from dispatch.sdk.v1 import function_pb2_grpc as function_grpc
+from dispatch.status import Status
 
 __all__ = [
     "Call",
@@ -44,21 +45,26 @@
 
 _registry: Optional[Registry] = None
 
+
 def _default_registry():
     global _registry
     if not _registry:
         _registry = Registry()
     return _registry
 
+
 @overload
 def function(func: Callable[P, Coroutine[Any, Any, T]]) -> Function[P, T]: ...
 
+
 @overload
 def function(func: Callable[P, T]) -> Function[P, T]: ...
 
+
 def function(func):
     return _default_registry().function(func)
 
+
 def run(port: str = os.environ.get("DISPATCH_ENDPOINT_ADDR", "[::]:8000")):
     """Run the default dispatch server on the given port. The default server
     uses a function registry where functions tagged by the `@dispatch.function`
@@ -73,8 +79,7 @@ def run(port: str = os.environ.get("DISPATCH_ENDPOINT_ADDR", "[::]:8000")):
           DISPATCH_ENDPOINT_ADDR environment variable, or '[::]:8000' if it
           wasn't set.
     """
-    parsed_url = urlsplit('//' + port)
+    parsed_url = urlsplit("//" + port)
     server_address = (parsed_url.hostname, parsed_url.port)
     server = HTTPServer(server_address, Dispatch(_default_registry()))
     server.serve_forever()
-

src/dispatch/grpc.py

@@ -14,7 +14,7 @@
 class FunctionService(FunctionServiceServicer):
     """A Dispatch instance to be serviced by a gRPC server."""
 
-    def __init__(        self,            registry: Registry    ):
+    def __init__(self, registry: Registry):
         """Initialize a Dispatch gRPC service.
 
         Args:
@@ -47,4 +47,5 @@ def Run(self, request, context):
 
         return output._message
 
+
 # TODO: interceptor for verification key

src/dispatch/http.py

@@ -3,8 +3,9 @@
 import logging
 import os
 from datetime import timedelta
-from typing import Optional, Union
 from http.server import BaseHTTPRequestHandler
+from typing import Optional, Union
+
 from http_message_signatures import InvalidSignature
 
 from dispatch.function import Registry
@@ -27,7 +28,10 @@ class Dispatch:
     acts as a factory for DispatchHandler objects, by capturing the variables
     that would be shared between all DispatchHandler instances it created."""
 
-    def __init__(        self,            registry: Registry,         verification_key: Optional[Union[Ed25519PublicKey, str, bytes]] = None,
+    def __init__(
+        self,
+        registry: Registry,
+        verification_key: Optional[Union[Ed25519PublicKey, str, bytes]] = None,
     ):
         """Initialize a Dispatch http handler.
 
@@ -38,16 +42,29 @@ def __init__(        self,            registry: Registry,         verification_k
         self.verification_key = parse_verification_key(verification_key)
 
     def __call__(self, request, client_address, server):
-        return FunctionService(request, client_address, server, registry=self.registry, verification_key=self.verification_key)
+        return FunctionService(
+            request,
+            client_address,
+            server,
+            registry=self.registry,
+            verification_key=self.verification_key,
+        )
 
 
 class FunctionService(BaseHTTPRequestHandler):
 
-    def __init__(self, request, client_address, server, registry: Registry, verification_key: Optional[Ed25519PublicKey] = None):
+    def __init__(
+        self,
+        request,
+        client_address,
+        server,
+        registry: Registry,
+        verification_key: Optional[Ed25519PublicKey] = None,
+    ):
         super().__init__(request, client_address, server)
         self.registry = registry
         self.verification_key = verification_key
-        self.error_content_type = 'application/json'
+        self.error_content_type = "application/json"
 
     def send_error_response_invalid_argument(self, message: str):
         self.send_error_response(400, "invalid_argument", message)
@@ -80,8 +97,8 @@ def do_POST(self):
 
         if self.verification_key is not None:
             signed_request = Request(
-                method='POST',
-                url=self.requestline, # TODO: need full URL
+                method="POST",
+                url=self.requestline,  # TODO: need full URL
                 headers=CaseInsensitiveDict(self.headers),
                 body=data,
             )
@@ -108,7 +125,9 @@ def do_POST(self):
             func = self.registry.functions[req.function]
         except KeyError:
             logger.debug("function '%s' not found", req.function)
-            self.send_error_response_not_found(f"function '{req.function}' does not exist")
+            self.send_error_response_not_found(
+                f"function '{req.function}' does not exist"
+            )
             return
 
         logger.info("running function '%s'", req.function)