twirpy 0.1.0.dev4__tar.gz → 0.3.0.dev2__tar.gz

{twirpy-0.1.0.dev4 → twirpy-0.3.0.dev2}/PKG-INFO

@@ -1,12 +1,13 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: twirpy
-Version: 0.1.0.dev4
+Version: 0.3.0.dev2
 Summary: Twirp runtime library for Python
 Project-URL: repository, https://github.com/cryptact/twirpy
 License-Expression: BSD-3-Clause
 License-File: LICENSE
 Keywords: protobuf,rpc,twirp
-Requires-Python: >=3.10
+Requires-Python: >=3.12
+Requires-Dist: asgiref
 Requires-Dist: protobuf
 Requires-Dist: requests
 Requires-Dist: structlog
@@ -54,7 +55,7 @@ Unzip the archive and move the binary to a directory in your PATH.
 On macOS, you can use the following commands:
 ```sh
 curl -L -o- \
-  https://github.com/Cryptact/twirpy/releases/latest/download/protoc-gen-twirpy_Darwin_arm64.tar.gz \
+  https://github.com/Cryptact/twirpy/releases/latest/download/protoc-gen-twirpy-darwin-arm64.tar.gz \
   | tar xz -C ~/.local/bin protoc-gen-twirpy
 ````
 
@@ -74,6 +75,8 @@ We use [`hatch`](https://hatch.pypa.io/latest/) to manage the development proces
 To open a shell with the development environment, run: `hatch shell`.
 To run the linter, run: `hatch fmt --check` or `hatch fmt` to fix the issues.
 
+To run the type checker, run: `hatch run types:check`.
+
 ## Standing on the shoulders of giants
 
 - The initial version of twirpy was made from an internal copy of https://github.com/daroot/protoc-gen-twirp_python_srv

{twirpy-0.1.0.dev4 → twirpy-0.3.0.dev2}/README.md

@@ -38,7 +38,7 @@ Unzip the archive and move the binary to a directory in your PATH.
 On macOS, you can use the following commands:
 ```sh
 curl -L -o- \
-  https://github.com/Cryptact/twirpy/releases/latest/download/protoc-gen-twirpy_Darwin_arm64.tar.gz \
+  https://github.com/Cryptact/twirpy/releases/latest/download/protoc-gen-twirpy-darwin-arm64.tar.gz \
   | tar xz -C ~/.local/bin protoc-gen-twirpy
 ````
 
@@ -58,6 +58,8 @@ We use [`hatch`](https://hatch.pypa.io/latest/) to manage the development proces
 To open a shell with the development environment, run: `hatch shell`.
 To run the linter, run: `hatch fmt --check` or `hatch fmt` to fix the issues.
 
+To run the type checker, run: `hatch run types:check`.
+
 ## Standing on the shoulders of giants
 
 - The initial version of twirpy was made from an internal copy of https://github.com/daroot/protoc-gen-twirp_python_srv

{twirpy-0.1.0.dev4 → twirpy-0.3.0.dev2}/pyproject.toml

@@ -10,7 +10,7 @@ name = "twirpy"
 dynamic = ["version"]
 description = "Twirp runtime library for Python"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.12"
 license = "BSD-3-Clause"
 keywords = [
   "protobuf",
@@ -18,6 +18,7 @@ keywords = [
   "twirp",
 ]
 dependencies = [
+    "asgiref",
     "protobuf",
     "requests",
     "structlog",
@@ -42,11 +43,18 @@ include = ["/twirp"]
 packages = ["twirp"]
 
 [tool.hatch.envs.default]
-python = "3.12"
+python = "3.13"
 dependencies = [
     "aiohttp",
 ]
 
+[tool.hatch.envs.types]
+extra-dependencies = [
+  "mypy>=1.0.0",
+]
+[tool.hatch.envs.types.scripts]
+check = "mypy --install-types --non-interactive twirp"
+
 [tool.ruff]
 line-length = 120
 lint.select = [

twirpy-0.3.0.dev2/twirp/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0-dev.2"

{twirpy-0.1.0.dev4 → twirpy-0.3.0.dev2}/twirp/asgi.py

@@ -1,43 +1,27 @@
-import asyncio
-import functools
-import typing
 import traceback
 
+from asgiref.typing import (
+    ASGIReceiveCallable,
+    ASGISendCallable,
+    Scope,
+    HTTPResponseStartEvent,
+    HTTPResponseBodyEvent,
+    ASGIReceiveEvent,
+)
+from google.protobuf.message import Message
+
+from twirp.endpoint import Endpoint, TwirpMethod
 from . import base
 from . import exceptions
 from . import errors
 from . import ctxkeys
+from . import context
 
-try:
-    import contextvars  # Python 3.7+ only.
-except ImportError:  # pragma: no cover
-    contextvars = None  # type: ignore
-
-
-# Lifted from starlette.concurrency
-async def run_in_threadpool(func: typing.Callable, *args: typing.Any, **kwargs: typing.Any) -> typing.Any:
-    loop = asyncio.get_event_loop()
-    if contextvars is not None:  # pragma: no cover
-        # Ensure we run in the same context
-        child = functools.partial(func, *args, **kwargs)
-        context = contextvars.copy_context()
-        func = context.run
-        args = (child,)
-    elif kwargs:  # pragma: no cover
-        # loop.run_in_executor doesn't accept 'kwargs', so bind them in here
-        func = functools.partial(func, **kwargs)
-    return await loop.run_in_executor(None, func, *args)
-
-
-def thread_pool_runner(func):
-    async def run(ctx, request):
-        return await run_in_threadpool(func, ctx, request)
-
-    return run
+Headers = dict[str, str]
 
 
 class TwirpASGIApp(base.TwirpBaseApp):
-    async def __call__(self, scope, receive, send):
+    async def __call__(self, scope: Scope, receive: ASGIReceiveCallable, send: ASGISendCallable) -> None:
         assert scope["type"] == "http"
         ctx = self._ctx_class()
         try:
@@ -54,7 +38,7 @@ class TwirpASGIApp(base.TwirpBaseApp):
             ctx.set(ctxkeys.RAW_HEADERS, headers)
             self._hook.request_received(ctx=ctx)
 
-            endpoint = self._get_endpoint(scope["path"])
+            endpoint: Endpoint = self._get_endpoint(scope["path"])
             headers = {k.decode("utf-8"): v.decode("utf-8") for (k, v) in scope["headers"]}
             self.validate_content_length(headers=headers)
             encoder, decoder = self._get_encoder_decoder(endpoint, headers)
@@ -66,7 +50,7 @@ class TwirpASGIApp(base.TwirpBaseApp):
             self._hook.request_routed(ctx=ctx)
             raw_receive = await self._recv_all(receive)
             request = decoder(raw_receive)
-            response_data = await self._with_middlewares(func=endpoint.function, ctx=ctx, request=request)
+            response_data: Message = await self._with_middlewares(func=endpoint.function, ctx=ctx, request=request)
             self._hook.response_prepared(ctx=ctx)
 
             body_bytes, headers = encoder(response_data)
@@ -77,28 +61,27 @@ class TwirpASGIApp(base.TwirpBaseApp):
         except Exception as e:
             await self.handle_error(ctx, e, scope, receive, send)
 
-    def _with_middlewares(self, *args, func, ctx, request):
-        chain = iter(self._middlewares + (func,))
+    async def _with_middlewares(self, *, func: TwirpMethod, ctx: context.Context, request: Message) -> Message:
+        chain = iter(self._middlewares)
 
-        def bind(fn):
-            if not asyncio.iscoroutinefunction(fn):
-                fn = thread_pool_runner(fn)
+        def _bind_next() -> TwirpMethod:
+            try:
+                middleware = next(chain)
 
-            async def nxt(ctx, request):
-                try:
-                    cur = next(chain)
-                    return await fn(ctx, request, bind(cur))
-                except StopIteration:
-                    pass
-                return await fn(ctx, request)
+                async def _next(ctx_: context.Context, request_: Message) -> Message:
+                    return await middleware(ctx_, request_, _bind_next())
 
-            return nxt
+                return _next
+            except StopIteration:
+                return func
 
-        return bind(next(chain))(ctx, request)
+        fn = _bind_next()
+        return await fn(ctx, request)
 
-    async def handle_error(self, ctx, exc, scope, receive, send):
+    async def handle_error(
+        self, ctx: context.Context, exc: Exception, scope_: Scope, receive_: ASGIReceiveCallable, send: ASGISendCallable
+    ) -> None:
         status = 500
-        body_bytes = b"{}"
         logger = ctx.get_logger()
         error_data = {}
         ctx.set(ctxkeys.ORIGINAL_EXCEPTION, exc)
@@ -128,28 +111,36 @@ class TwirpASGIApp(base.TwirpBaseApp):
         )
         self._hook.response_sent(ctx=ctx)
 
-    async def _respond(self, *args, send, status, headers, body_bytes):
+    @staticmethod
+    async def _respond(*, send: ASGISendCallable, status: int, headers: Headers, body_bytes: bytes) -> None:
         headers["Content-Length"] = str(len(body_bytes))
         resp_headers = [(k.encode("utf-8"), v.encode("utf-8")) for (k, v) in headers.items()]
         await send(
-            {
-                "type": "http.response.start",
-                "status": status,
-                "headers": resp_headers,
-            }
+            HTTPResponseStartEvent(
+                type="http.response.start",
+                status=status,
+                headers=resp_headers,
+                trailers=False,
+            )
         )
         await send(
-            {
-                "type": "http.response.body",
-                "body": body_bytes,
-            }
+            HTTPResponseBodyEvent(
+                type="http.response.body",
+                body=body_bytes,
+                more_body=False,
+            )
         )
 
-    async def _recv_all(self, receive):
+    async def _recv_all(self, receive: ASGIReceiveCallable) -> bytes:
         body = b""
         more_body = True
         while more_body:
-            message = await receive()
+            message: ASGIReceiveEvent = await receive()
+            if message["type"] != "http.request":
+                raise exceptions.TwirpServerException(
+                    code=errors.Errors.Internal,
+                    message="expected http.request message type, got " + message["type"],
+                )
             body += message.get("body", b"")
             more_body = message.get("more_body", False)
 
@@ -165,9 +156,12 @@ class TwirpASGIApp(base.TwirpBaseApp):
 
     # we will check content-length header value and make sure it is
     # below the limit set
-    def validate_content_length(self, headers):
+    def validate_content_length(self, headers: Headers) -> None:
         try:
-            content_length = int(headers.get("content-length"))
+            raw_value = headers.get("content-length", None)
+            if not raw_value:
+                return
+            content_length = int(raw_value)
         except (ValueError, TypeError):
             return
 

{twirpy-0.1.0.dev4 → twirpy-0.3.0.dev2}/twirp/async_client.py

@@ -1,10 +1,13 @@
-import asyncio
 import json
+from typing import Any
 
 import aiohttp
+from aiohttp.typedefs import StrOrURL
+from google.protobuf.message import Message
 
 from . import exceptions
 from . import errors
+from . import context
 
 
 class AsyncTwirpClient:
@@ -12,7 +15,16 @@ class AsyncTwirpClient:
         self._address = address
         self._session = session
 
-    async def _make_request(self, *, url, ctx, request, response_obj, session=None, **kwargs):
+    async def _make_request[RQ: Message, RP: Message](
+        self,
+        *,
+        url: StrOrURL,
+        ctx: context.Context,
+        request: RQ,
+        response_obj: type[RP],
+        session: aiohttp.ClientSession | None = None,
+        **kwargs: Any,
+    ) -> RP:
         headers = ctx.get_headers()
         if "headers" in kwargs:
             headers.update(kwargs["headers"])
@@ -36,7 +48,7 @@ class AsyncTwirpClient:
                     raise exceptions.twirp_error_from_intermediary(
                         resp.status, resp.reason, resp.headers, await resp.text()
                     ) from None
-        except asyncio.TimeoutError as e:
+        except TimeoutError as e:
             raise exceptions.TwirpServerException(
                 code=errors.Errors.DeadlineExceeded,
                 message=str(e) or "request timeout",

{twirpy-0.1.0.dev4 → twirpy-0.3.0.dev2}/twirp/base.py

@@ -1,10 +1,11 @@
 import functools
-from collections import namedtuple
+from collections.abc import Awaitable
+from typing import Any
+from collections.abc import Callable
 
-from google.protobuf import json_format
-from google.protobuf import message
+from google.protobuf import json_format, message
 from google.protobuf import symbol_database as _symbol_database
-
+from google.protobuf.message import Message
 
 from . import context
 
@@ -12,31 +13,39 @@ from . import server
 from . import exceptions
 from . import errors
 from . import hook as vtwirp_hook
+from .endpoint import Endpoint, TwirpMethod
 
 _sym_lookup = _symbol_database.Default().GetSymbol
 
-Endpoint = namedtuple("Endpoint", ["service_name", "name", "function", "input", "output"])
+Middleware = Callable[[context.Context, Message, TwirpMethod], Awaitable[Message]]
 
 
 class TwirpBaseApp:
-    def __init__(self, *middlewares, hook=None, prefix="", max_receive_message_length=1024 * 100 * 100, ctx_class=None):
-        self._prefix = prefix
-        self._services = {}
-        self._max_receive_message_length = max_receive_message_length
+    def __init__(
+        self,
+        *middlewares: Middleware,
+        hook: vtwirp_hook.TwirpHook | None = None,
+        prefix: str = "",
+        max_receive_message_length: int = 1024 * 100 * 100,
+        ctx_class: type[context.Context] | None = None,
+    ) -> None:
+        self._prefix: str = prefix
+        self._services: dict[str, server.TwirpServer] = {}
+        self._max_receive_message_length: int = max_receive_message_length
         if ctx_class is None:
             ctx_class = context.Context
         assert issubclass(ctx_class, context.Context)
-        self._ctx_class = ctx_class
-        self._middlewares = middlewares
+        self._ctx_class: type[context.Context] = ctx_class
+        self._middlewares: tuple[Middleware, ...] = middlewares
         if hook is None:
             hook = vtwirp_hook.TwirpHook()
         assert isinstance(hook, vtwirp_hook.TwirpHook)
-        self._hook = hook
+        self._hook: vtwirp_hook.TwirpHook = hook
 
-    def add_service(self, svc: server.TwirpServer):
+    def add_service(self, svc: server.TwirpServer) -> None:
         self._services[self._prefix + svc.prefix] = svc
 
-    def _get_endpoint(self, path):
+    def _get_endpoint(self, path: str) -> Endpoint:
         svc = self._services.get(path.rsplit("/", 1)[0], None)
         if svc is None:
             raise exceptions.TwirpServerException(code=errors.Errors.NotFound, message="not found")
@@ -44,7 +53,7 @@ class TwirpBaseApp:
         return svc.get_endpoint(path[len(self._prefix) :])
 
     @staticmethod
-    def json_decoder(body, data_obj=None):
+    def json_decoder(body: bytes, data_obj: type[Message]) -> Message:
         data = data_obj()
         try:
             json_format.Parse(body, data)
@@ -56,7 +65,7 @@ class TwirpBaseApp:
         return data
 
     @staticmethod
-    def json_encoder(value, data_obj=None):
+    def json_encoder(value: Any, data_obj: type[Message]) -> tuple[bytes, dict[str, str]]:
         if not isinstance(value, data_obj):
             raise exceptions.TwirpServerException(
                 code=errors.Errors.Internal,
@@ -70,7 +79,7 @@ class TwirpBaseApp:
         }
 
     @staticmethod
-    def proto_decoder(body, data_obj=None):
+    def proto_decoder(body: bytes, data_obj: type[Message]) -> Message:
         data = data_obj()
         try:
             data.ParseFromString(body)
@@ -82,7 +91,7 @@ class TwirpBaseApp:
         return data
 
     @staticmethod
-    def proto_encoder(value, data_obj=None):
+    def proto_encoder(value: Any, data_obj: type[Message]) -> tuple[bytes, dict[str, str]]:
         if not isinstance(value, data_obj):
             raise exceptions.TwirpServerException(
                 code=errors.Errors.Internal,
@@ -93,7 +102,9 @@ class TwirpBaseApp:
 
         return value.SerializeToString(), {"Content-Type": "application/protobuf"}
 
-    def _get_encoder_decoder(self, endpoint, headers):
+    def _get_encoder_decoder(
+        self, endpoint: Endpoint, headers: dict[str, str]
+    ) -> tuple[Callable[[Any], tuple[bytes, dict[str, str]]], Callable[[bytes], Message]]:
         ctype = headers.get("content-type", None)
         if "application/json" == ctype:
             decoder = functools.partial(self.json_decoder, data_obj=endpoint.input)

{twirpy-0.1.0.dev4 → twirpy-0.3.0.dev2}/twirp/client.py

@@ -1,15 +1,21 @@
+from typing import Any
+
 import requests
+from google.protobuf.message import Message
 
+from . import context
 from . import exceptions
 from . import errors
 
 
 class TwirpClient:
-    def __init__(self, address, timeout=5):
+    def __init__(self, address: str, timeout: int = 5) -> None:
         self._address = address
         self._timeout = timeout
 
-    def _make_request(self, *args, url, ctx, request, response_obj, **kwargs):
+    def _make_request[Req: Message, Resp: Message](
+        self, *, url: str, ctx: context.Context, request: Req, response_obj: type[Resp], **kwargs: Any
+    ) -> Resp:
         if "timeout" not in kwargs:
             kwargs["timeout"] = self._timeout
         headers = ctx.get_headers()
@@ -20,7 +26,7 @@ class TwirpClient:
         try:
             resp = requests.post(url=self._address + url, data=request.SerializeToString(), **kwargs)
             if resp.status_code == 200:
-                response = response_obj()
+                response: Resp = response_obj()
                 response.ParseFromString(resp.content)
                 return response
             try:

{twirpy-0.1.0.dev4 → twirpy-0.3.0.dev2}/twirp/context.py

@@ -1,3 +1,7 @@
+from typing import Any
+
+from structlog.stdlib import BoundLogger
+
 from . import logging
 
 
@@ -6,23 +10,23 @@ class Context:
     request currently being processed.
     """
 
-    def __init__(self, *args, logger=None, headers=None):
+    def __init__(self, *, logger: BoundLogger | None = None, headers: dict[str, Any] | None = None):
         """Create a new Context object
 
         Keyword arguments:
         logger: Logger that will be used for logging.
         headers: Headers for the request.
         """
-        self._values = {}
+        self._values: dict[str, Any] = {}
         if logger is None:
             logger = logging.get_logger()
-        self._logger = logger
+        self._logger: BoundLogger = logger
         if headers is None:
             headers = {}
-        self._headers = headers
-        self._response_headers = {}
+        self._headers: dict[str, Any] = headers
+        self._response_headers: dict[str, Any] = {}
 
-    def set(self, key, value):
+    def set(self, key: str, value: Any) -> None:
         """Set a Context value
 
         Arguments:
@@ -31,7 +35,7 @@ class Context:
         """
         self._values[key] = value
 
-    def get(self, key):
+    def get(self, key: str) -> Any:
         """Get a Context value
 
         Arguments:
@@ -39,11 +43,11 @@ class Context:
         """
         return self._values[key]
 
-    def get_logger(self):
+    def get_logger(self) -> BoundLogger:
         """Get current logger used by Context."""
         return self._logger
 
-    def set_logger(self, logger):
+    def set_logger(self, logger: BoundLogger) -> None:
         """Set logger for this Context
 
         Arguments:
@@ -51,11 +55,11 @@ class Context:
         """
         self._logger = logger
 
-    def get_headers(self):
+    def get_headers(self) -> dict[str, Any]:
         """Get request headers that are currently stored."""
         return self._headers
 
-    def set_header(self, key, value):
+    def set_header(self, key: str, value: Any) -> None:
         """Set a request header
 
         Arguments:
@@ -64,11 +68,11 @@ class Context:
         """
         self._headers[key] = value
 
-    def get_response_headers(self):
+    def get_response_headers(self) -> dict[str, Any]:
         """Get response headers that are currently stored."""
         return self._response_headers
 
-    def set_response_header(self, key, value):
+    def set_response_header(self, key: str, value: Any) -> None:
         """Set a response header
 
         Arguments:

twirpy-0.3.0.dev2/twirp/endpoint.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from collections.abc import Callable, Awaitable
+
+from google.protobuf.message import Message
+
+from twirp import context
+
+TwirpMethod = Callable[[context.Context, Message], Awaitable[Message]]
+
+
+@dataclass
+class Endpoint:
+    service_name: str
+    name: str
+    function: TwirpMethod
+    input: type[Message]
+    output: type[Message]

{twirpy-0.1.0.dev4 → twirpy-0.3.0.dev2}/twirp/errors.py

@@ -1,4 +1,5 @@
 from enum import Enum
+from typing import Self
 
 
 class Errors(Enum):
@@ -22,8 +23,8 @@ class Errors(Enum):
     Malformed = "malformed"
     NoError = ""
 
-    @staticmethod
-    def get_status_code(code):
+    @classmethod
+    def get_status_code(cls, code: Self) -> int:
         return {
             Errors.Canceled: 408,
             Errors.Unknown: 500,

{twirpy-0.1.0.dev4 → twirpy-0.3.0.dev2}/twirp/exceptions.py

@@ -1,12 +1,21 @@
 import json
 from http.client import HTTPException
-from typing import Any
+from typing import Any, TypedDict, Self
+
+from multidict import CIMultiDictProxy
+from requests.structures import CaseInsensitiveDict
 
 from . import errors
 
 
+class TwirpServerExceptionDict(TypedDict, total=False):
+    code: str
+    msg: str
+    meta: dict[str, Any]
+
+
 class TwirpServerException(HTTPException):
-    def __init__(self, *args, code, message, meta: dict[str, Any] | None = None):
+    def __init__(self, *, code: errors.Errors | str, message: str, meta: dict[str, Any] | None = None):
         try:
             self._code = errors.Errors(code)
         except ValueError:
@@ -16,50 +25,52 @@ class TwirpServerException(HTTPException):
         super().__init__(message)
 
     @property
-    def code(self):
+    def code(self) -> errors.Errors:
         if isinstance(self._code, errors.Errors):
             return self._code
         return errors.Errors.Unknown
 
     @property
-    def message(self):
+    def message(self) -> str:
         return self._message
 
     @property
-    def meta(self):
+    def meta(self) -> dict[str, Any]:
         return self._meta
 
-    def to_dict(self):
-        err = {"code": self._code.value, "msg": self._message, "meta": {}}
+    def to_dict(self) -> TwirpServerExceptionDict:
+        err: TwirpServerExceptionDict = {"code": self._code.value, "msg": self._message, "meta": {}}
         for k, v in self._meta.items():
             err["meta"][k] = str(v)
         return err
 
-    def to_json_bytes(self):
+    def to_json_bytes(self) -> bytes:
         return json.dumps(self.to_dict()).encode("utf-8")
 
-    @staticmethod
-    def from_json(err_dict):
-        return TwirpServerException(
+    @classmethod
+    def from_json(cls, err_dict: TwirpServerExceptionDict) -> Self:
+        return cls(
             code=err_dict.get("code", errors.Errors.Unknown),
             message=err_dict.get("msg", ""),
             meta=err_dict.get("meta", {}),
         )
 
 
-def InvalidArgument(*args, argument, error):
+def InvalidArgument(*, argument: str, error: str) -> TwirpServerException:
     return TwirpServerException(
         code=errors.Errors.InvalidArgument, message=f"{argument} {error}", meta={"argument": argument}
     )
 
 
-def RequiredArgument(*args, argument):
+def RequiredArgument(*, argument: str) -> TwirpServerException:
     return InvalidArgument(argument=argument, error="is required")
 
 
-def twirp_error_from_intermediary(status, reason, headers, body):
+def twirp_error_from_intermediary(
+    status: int, reason: str | None, headers: CaseInsensitiveDict[str] | CIMultiDictProxy[str], body: str
+) -> TwirpServerException:
     # see https://twitchtv.github.io/twirp/docs/errors.html#http-errors-from-intermediary-proxies
-    meta = {
+    meta: dict[str, str | None] = {
         "http_error_from_intermediary": "true",
         "status_code": str(status),
     }

{twirpy-0.1.0.dev4 → twirpy-0.3.0.dev2}/twirp/hook.py

@@ -1,47 +1,50 @@
+from . import context
+
+
 class TwirpHook:
     # Called as soon as a request is received, always called
-    def request_received(self, *args, ctx):
+    def request_received(self, *, ctx: context.Context) -> None:
         pass
 
     # Called once the request is routed, service name known, only called if request is routable
-    def request_routed(self, *args, ctx):
+    def request_routed(self, *, ctx: context.Context) -> None:
         pass
 
     # Called once the response is prepared, not called for error cases
-    def response_prepared(self, *args, ctx):
+    def response_prepared(self, *, ctx: context.Context) -> None:
         pass
 
     # Called if an error occurs
-    def error(self, *args, ctx, exc):
+    def error(self, *, ctx: context.Context, exc: Exception) -> None:
         pass
 
     # Called after error is sent, always called
-    def response_sent(self, *args, ctx):
+    def response_sent(self, *, ctx: context.Context) -> None:
         pass
 
 
 class ChainHooks(TwirpHook):
-    def __init__(self, *hooks):
+    def __init__(self, *hooks: TwirpHook) -> None:
         for hook in hooks:
             assert isinstance(hook, TwirpHook)
         self._hooks = hooks
 
-    def request_received(self, *args, ctx):
+    def request_received(self, *, ctx: context.Context) -> None:
         for hook in self._hooks:
             hook.request_received(ctx=ctx)
 
-    def request_routed(self, *args, ctx):
+    def request_routed(self, *, ctx: context.Context) -> None:
         for hook in self._hooks:
             hook.request_routed(ctx=ctx)
 
-    def response_prepared(self, *args, ctx):
+    def response_prepared(self, *, ctx: context.Context) -> None:
         for hook in self._hooks:
             hook.response_prepared(ctx=ctx)
 
-    def error(self, *args, ctx, exc):
+    def error(self, *, ctx: context.Context, exc: Exception) -> None:
         for hook in self._hooks:
             hook.error(ctx=ctx, exc=exc)
 
-    def response_sent(self, *args, ctx):
+    def response_sent(self, *, ctx: context.Context) -> None:
         for hook in self._hooks:
             hook.response_sent(ctx=ctx)

{twirpy-0.1.0.dev4 → twirpy-0.3.0.dev2}/twirp/logging.py

@@ -1,5 +1,6 @@
 import os
 import logging
+from typing import Any
 
 import structlog
 from structlog.stdlib import LoggerFactory, add_log_level
@@ -7,7 +8,7 @@ from structlog.stdlib import LoggerFactory, add_log_level
 _configured = False
 
 
-def configure(force=False):
+def configure(force: bool = False) -> None:
     """
     Configures logging & structlog modules
 
@@ -52,11 +53,11 @@ def configure(force=False):
     _configured = True
 
 
-def get_logger(**kwargs):
+def get_logger(**kwargs: Any) -> structlog.stdlib.BoundLogger:
     """
     Get the structlog logger
     """
     # Configure logging modules
     configure()
     # Return structlog
-    return structlog.get_logger(**kwargs)
+    return structlog.stdlib.get_logger(**kwargs)

{twirpy-0.1.0.dev4 → twirpy-0.3.0.dev2}/twirp/server.py

@@ -1,18 +1,21 @@
+from typing import Any
+
+from .endpoint import Endpoint
 from . import exceptions
 from . import errors
 
 
 class TwirpServer:
-    def __init__(self, *args, service):
-        self.service = service
-        self._endpoints = {}
-        self._prefix = ""
+    def __init__(self, *, service: Any) -> None:
+        self.service: Any = service
+        self._endpoints: dict[str, Endpoint] = {}
+        self._prefix: str = ""
 
     @property
-    def prefix(self):
+    def prefix(self) -> str:
         return self._prefix
 
-    def get_endpoint(self, path):
+    def get_endpoint(self, path: str) -> Endpoint:
         (_, url_pre, rpc_method) = path.rpartition(self._prefix + "/")
         if not url_pre or not rpc_method:
             raise exceptions.TwirpServerException(
@@ -21,7 +24,7 @@ class TwirpServer:
                 meta={"twirp_invalid_route": "POST " + path},
             )
 
-        endpoint = self._endpoints.get(rpc_method, None)
+        endpoint: Endpoint | None = self._endpoints.get(rpc_method, None)
         if not endpoint:
             raise exceptions.TwirpServerException(
                 code=errors.Errors.Unimplemented,

twirpy-0.1.0.dev4/twirp/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.0-dev.4"