[1/5] Typing cleanup (#13)

* Typing cleanup
* Ignore errors resulting from lack of dataclass_transform

Author: dandavison

pyproject.toml

@@ -18,10 +18,11 @@ dependencies = [
 
 [dependency-groups]
 dev = [
+    "basedpyright>=1.30.1",
     "mypy>=1.15.0",
     "poethepoet>=0.35.0",
     "pydoctor>=25.4.0",
-    "pyright>=1.1.402",
+    "pyright>=1.1",
     "pytest>=8.3.5",
     "pytest-asyncio>=0.26.0",
     "pytest-cov>=6.1.1",
@@ -38,6 +39,7 @@ packages = ["src/nexusrpc"]
 
 [tool.poe.tasks]
 lint = [
+  {cmd = "uv run basedpyright src"},
   {cmd = "uv run pyright src"},
   {cmd = "uv run mypy --check-untyped-defs src"},
   {cmd = "uv run ruff check --select I"},
@@ -52,6 +54,21 @@ docs = [
 ]
 
 [tool.pyright]
+# https://docs.basedpyright.com/v1.30.0/configuration/config-files/#diagnostic-settings-defaults
+reportAny = "none"
+reportDeprecated = "none"
+reportExplicitAny = "none"
+reportIgnoreCommentWithoutRule = "none"
+reportImplicitOverride = "none"
+reportImplicitStringConcatenation = "none"
+reportImportCycles = "none"
+reportUnannotatedClassAttribute = "none"
+reportUnknownArgumentType = "none"
+reportUnknownMemberType = "none"
+reportUnknownVariableType = "none"
+reportUnnecessaryTypeIgnoreComment = "none"
+enableTypeIgnoreComments = true
+failOnWarnings = false  # basedpyright setting
 include = ["src", "tests"]
 
 [tool.mypy]

src/nexusrpc/_serializer.py

@@ -1,14 +1,11 @@
 from __future__ import annotations
 
+from collections.abc import AsyncIterable, Awaitable, Mapping
 from dataclasses import dataclass
 from typing import (
     Any,
-    AsyncIterable,
-    Awaitable,
-    Mapping,
     Optional,
     Protocol,
-    Type,
     Union,
 )
 
@@ -42,7 +39,7 @@ def serialize(self, value: Any) -> Union[Content, Awaitable[Content]]:
         ...
 
     def deserialize(
-        self, content: Content, as_type: Optional[Type[Any]] = None
+        self, content: Content, as_type: Optional[type[Any]] = None
     ) -> Union[Any, Awaitable[Any]]:
         """Deserialize decodes a Content into a value.
 
@@ -56,7 +53,7 @@ def deserialize(
 
 class LazyValueT(Protocol):
     def consume(
-        self, as_type: Optional[Type[Any]] = None
+        self, as_type: Optional[type[Any]] = None
     ) -> Union[Any, Awaitable[Any]]: ...
 
 
@@ -96,22 +93,21 @@ def __init__(
             headers: Headers that include information on how to process the stream's content.
                      Headers constructed by the framework always have lower case keys.
                      User provided keys are treated case-insensitively.
-            stream:  Iterable that contains request or response data. None means empty data.
+            stream:  AsyncIterable of bytes that contains request or response data.
+                     None means empty data.
         """
         self.serializer = serializer
         self.headers = headers
         self.stream = stream
 
-    async def consume(self, as_type: Optional[Type[Any]] = None) -> Any:
+    async def consume(self, as_type: Optional[type[Any]] = None) -> Any:
         """
         Consume the underlying reader stream, deserializing via the embedded serializer.
         """
         if self.stream is None:
             return await self.serializer.deserialize(
                 Content(headers=self.headers, data=b""), as_type=as_type
             )
-        elif not isinstance(self.stream, AsyncIterable):
-            raise ValueError("When using consume, stream must be an AsyncIterable")
 
         return await self.serializer.deserialize(
             Content(

src/nexusrpc/_service.py

@@ -8,14 +8,13 @@
 
 import dataclasses
 import typing
+from collections.abc import Mapping
 from dataclasses import dataclass
 from typing import (
     Any,
     Callable,
     Generic,
-    Mapping,
     Optional,
-    Type,
     Union,
     overload,
 )
@@ -47,8 +46,8 @@ class MyNexusService:
     name: str
     # TODO(preview): they should not be able to set method_name in constructor
     method_name: Optional[str] = dataclasses.field(default=None)
-    input_type: Optional[Type[InputT]] = dataclasses.field(default=None)
-    output_type: Optional[Type[OutputT]] = dataclasses.field(default=None)
+    input_type: Optional[type[InputT]] = dataclasses.field(default=None)
+    output_type: Optional[type[OutputT]] = dataclasses.field(default=None)
 
     def __post_init__(self):
         if not self.name:
@@ -70,22 +69,22 @@ def _validation_errors(self) -> list[str]:
 
 
 @overload
-def service(cls: Type[ServiceT]) -> Type[ServiceT]: ...
+def service(cls: type[ServiceT]) -> type[ServiceT]: ...
 
 
 @overload
 def service(
     *, name: Optional[str] = None
-) -> Callable[[Type[ServiceT]], Type[ServiceT]]: ...
+) -> Callable[[type[ServiceT]], type[ServiceT]]: ...
 
 
 def service(
-    cls: Optional[Type[ServiceT]] = None,
+    cls: Optional[type[ServiceT]] = None,
     *,
     name: Optional[str] = None,
 ) -> Union[
-    Type[ServiceT],
-    Callable[[Type[ServiceT]], Type[ServiceT]],
+    type[ServiceT],
+    Callable[[type[ServiceT]], type[ServiceT]],
 ]:
     """
     Decorator marking a class as a Nexus service definition.
@@ -115,7 +114,7 @@ class AnotherService:
     # This will require forming a union of operations disovered via __annotations__
     # and __dict__
 
-    def decorator(cls: Type[ServiceT]) -> Type[ServiceT]:
+    def decorator(cls: type[ServiceT]) -> type[ServiceT]:
         if name is not None and not name:
             raise ValueError("Service name must not be empty.")
         defn = ServiceDefinition.from_class(cls, name or cls.__name__)
@@ -161,7 +160,7 @@ def __post_init__(self):
             )
 
     @staticmethod
-    def from_class(user_class: Type[ServiceT], name: str) -> ServiceDefinition:
+    def from_class(user_class: type[ServiceT], name: str) -> ServiceDefinition:
         """Create a ServiceDefinition from a user service definition class.
 
         The set of service definition operations returned is the union of operations
@@ -216,12 +215,12 @@ def _validation_errors(self) -> list[str]:
             if op.method_name in seen_method_names:
                 errors.append(f"Operation method name '{op.method_name}' is not unique")
             seen_method_names.add(op.method_name)
-            errors.extend(op._validation_errors())
+            errors.extend(op._validation_errors())  # pyright: ignore[reportPrivateUsage]
         return errors
 
     @staticmethod
     def _collect_operations(
-        user_class: Type[ServiceT],
+        user_class: type[ServiceT],
     ) -> dict[str, Operation[Any, Any]]:
         """Collect operations from a user service definition class.
 

src/nexusrpc/_util.py

@@ -3,7 +3,8 @@
 import functools
 import inspect
 import typing
-from typing import TYPE_CHECKING, Any, Awaitable, Callable, Optional, Type
+from collections.abc import Awaitable
+from typing import TYPE_CHECKING, Any, Callable, Optional
 
 from typing_extensions import TypeGuard
 
@@ -34,17 +35,15 @@ def get_service_definition(
 
 
 def set_service_definition(
-    cls: Type[ServiceT], service_definition: nexusrpc.ServiceDefinition
+    cls: type[ServiceT], service_definition: nexusrpc.ServiceDefinition
 ) -> None:
-    """Set the :py:class:`nexusrpc.ServiceDefinition` for this object."""
-    if not isinstance(cls, type):
-        raise TypeError(f"Expected {cls} to be a class, but is {type(cls)}.")
+    """Set the :py:class:`nexusrpc.ServiceDefinition` for this class."""
     setattr(cls, "__nexus_service__", service_definition)
 
 
 def get_operation_definition(
     obj: Any,
-) -> Optional[nexusrpc.Operation]:
+) -> Optional[nexusrpc.Operation[Any, Any]]:
     """Return the :py:class:`nexusrpc.Operation` for the object, or None
 
     ``obj`` should be a decorated operation start method.
@@ -54,7 +53,7 @@ def get_operation_definition(
 
 def set_operation_definition(
     obj: Any,
-    operation_definition: nexusrpc.Operation,
+    operation_definition: nexusrpc.Operation[Any, Any],
 ) -> None:
     """Set the :py:class:`nexusrpc.Operation` for this object.
 
@@ -137,7 +136,7 @@ def get_callable_name(fn: Callable[..., Any]) -> str:
     return method_name
 
 
-def is_subtype(type1: Type[Any], type2: Type[Any]) -> bool:
+def is_subtype(type1: type[Any], type2: type[Any]) -> bool:
     # Note that issubclass() argument 2 cannot be a parameterized generic
     # TODO(nexus-preview): review desired type compatibility logic
     if type1 == type2:
@@ -149,7 +148,9 @@ def is_subtype(type1: Type[Any], type2: Type[Any]) -> bool:
 # https://docs.python.org/3/howto/annotations.html#accessing-the-annotations-dict-of-an-object-in-python-3-9-and-older
 
 try:
-    from inspect import get_annotations  # type: ignore
+    from inspect import (  # type: ignore
+        get_annotations as get_annotations,  # type: ignore[reportAttributeAccessIssue]
+    )
 except ImportError:
     import functools
     import sys
@@ -251,10 +252,10 @@ def get_annotations(obj, *, globals=None, locals=None, eval_str=False):  # type:
         if unwrap is not None:
             while True:
                 if hasattr(unwrap, "__wrapped__"):
-                    unwrap = unwrap.__wrapped__  # type: ignore
+                    unwrap = unwrap.__wrapped__  # type: ignore[reportFunctionMemberAccess,union-attr]
                     continue
                 if isinstance(unwrap, functools.partial):
-                    unwrap = unwrap.func  # type: ignore
+                    unwrap = unwrap.func  # type: ignore[reportGeneralTypeIssues,assignment]
                     continue
                 break
             if hasattr(unwrap, "__globals__"):

src/nexusrpc/handler/_common.py

@@ -1,14 +1,10 @@
 from __future__ import annotations
 
 from abc import ABC
+from collections.abc import Mapping, Sequence
 from dataclasses import dataclass, field
 from datetime import timedelta
-from typing import (
-    Generic,
-    Mapping,
-    Optional,
-    Sequence,
-)
+from typing import Any, Generic, Optional
 
 from nexusrpc._common import Link, OutputT
 
@@ -19,7 +15,7 @@ class OperationContext(ABC):
 
     Includes information from the request."""
 
-    def __new__(cls, *args, **kwargs):
+    def __new__(cls, *args: Any, **kwargs: Any):
         if cls is OperationContext:
             raise TypeError(
                 "OperationContext is an abstract class and cannot be instantiated directly"

src/nexusrpc/handler/_core.py

@@ -93,16 +93,9 @@ def my_op(...)
 import asyncio
 import concurrent.futures
 from abc import ABC, abstractmethod
+from collections.abc import Awaitable, Mapping, Sequence
 from dataclasses import dataclass
-from typing import (
-    Any,
-    Awaitable,
-    Callable,
-    Mapping,
-    Optional,
-    Sequence,
-    Union,
-)
+from typing import Any, Callable, Optional, Union
 
 from typing_extensions import Self, TypeGuard
 
@@ -179,7 +172,7 @@ def cancel_operation(
         ...
 
 
-class BaseServiceCollectionHandler(AbstractHandler):
+class BaseServiceCollectionHandler(AbstractHandler, ABC):
     """
     A Nexus handler, managing a collection of Nexus service handlers.
 
@@ -294,7 +287,7 @@ async def start_operation(
             input: The input to the operation, as a LazyValue.
         """
         service_handler = self._get_service_handler(ctx.service)
-        op_handler = service_handler._get_operation_handler(ctx.operation)
+        op_handler = service_handler._get_operation_handler(ctx.operation)  # pyright: ignore[reportPrivateUsage]
         op = service_handler.service.operations[ctx.operation]
         deserialized_input = await input.consume(as_type=op.input_type)
         # TODO(preview): apply middleware stack
@@ -314,7 +307,7 @@ async def cancel_operation(self, ctx: CancelOperationContext, token: str) -> Non
             token: The operation token.
         """
         service_handler = self._get_service_handler(ctx.service)
-        op_handler = service_handler._get_operation_handler(ctx.operation)
+        op_handler = service_handler._get_operation_handler(ctx.operation)  # pyright: ignore[reportPrivateUsage]
         if is_async_callable(op_handler.cancel):
             return await op_handler.cancel(ctx, token)
         else:
@@ -325,7 +318,7 @@ async def fetch_operation_info(
         self, ctx: FetchOperationInfoContext, token: str
     ) -> OperationInfo:
         service_handler = self._get_service_handler(ctx.service)
-        op_handler = service_handler._get_operation_handler(ctx.operation)
+        op_handler = service_handler._get_operation_handler(ctx.operation)  # pyright: ignore[reportPrivateUsage]
         if is_async_callable(op_handler.fetch_info):
             return await op_handler.fetch_info(ctx, token)
         else:
@@ -341,7 +334,7 @@ async def fetch_operation_result(
                 "wait parameter or request-timeout header."
             )
         service_handler = self._get_service_handler(ctx.service)
-        op_handler = service_handler._get_operation_handler(ctx.operation)
+        op_handler = service_handler._get_operation_handler(ctx.operation)  # pyright: ignore[reportPrivateUsage]
         if is_async_callable(op_handler.fetch_result):
             return await op_handler.fetch_result(ctx, token)
         else:
@@ -351,10 +344,10 @@ async def fetch_operation_result(
     def _validate_all_operation_handlers_are_async(self) -> None:
         for service_handler in self.service_handlers.values():
             for op_handler in service_handler.operation_handlers.values():
-                self._assert_async_callable(op_handler.start)
-                self._assert_async_callable(op_handler.cancel)
-                self._assert_async_callable(op_handler.fetch_info)
-                self._assert_async_callable(op_handler.fetch_result)
+                _ = self._assert_async_callable(op_handler.start)
+                _ = self._assert_async_callable(op_handler.cancel)
+                _ = self._assert_async_callable(op_handler.fetch_info)
+                _ = self._assert_async_callable(op_handler.fetch_result)
 
     def _assert_async_callable(
         self, method: Callable[..., Any]