asyncly 0.3.0__tar.gz

asyncly-0.3.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.1
+Name: asyncly
+Version: 0.3.0
+Summary: Simple HTTP client and server for your integrations based on aiohttp
+Home-page: https://github.com/andy-takker/asyncly
+License: MIT
+Keywords: aiohttp,http,client
+Author: Sergey Natalenko
+Author-email: sergey.natalenko@mail.ru
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Pytest
+Classifier: Framework :: aiohttp
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Provides-Extra: msgspec
+Provides-Extra: orjson
+Provides-Extra: pydantic
+Requires-Dist: aiohttp (>=3.9.5,<4.0.0)
+Requires-Dist: msgspec (>=0.18.6,<0.19.0) ; extra == "msgspec"
+Requires-Dist: orjson (>=3.10.6,<4.0.0) ; extra == "orjson"
+Requires-Dist: pydantic (>=2.8.2,<3.0.0) ; extra == "pydantic"
+Project-URL: Bug Tracker, https://github.com/andy-takker/v/issues
+Project-URL: Source, https://github.com/andy-takker/asyncly
+Description-Content-Type: text/x-rst
+
+Asyncly
+=======
+
+.. image:: https://img.shields.io/pypi/v/asyncly.svg
+   :target: https://pypi.python.org/pypi/asyncly/
+   :alt: Latest Version
+
+.. image:: https://img.shields.io/pypi/wheel/base-http-client.svg
+   :target: https://pypi.python.org/pypi/base-http-client/
+
+.. image:: https://img.shields.io/pypi/pyversions/base-http-client.svg
+   :target: https://pypi.python.org/pypi/base-http-client/
+
+.. image:: https://img.shields.io/pypi/l/base-http-client.svg
+   :target: https://pypi.python.org/pypi/base-http-client/
+
+Simple HTTP client and server for your integrations based on aiohttp_.
+
+Installation
+------------
+
+Installation is possible in standard ways, such as PyPI or
+installation from a git repository directly.
+
+Installing from PyPI_:
+
+.. code-block:: bash
+
+   pip install asyncly
+
+Installing from github.com:
+
+.. code-block:: bash
+
+   pip install git+https://github.com/andy-takker/asyncly
+
+The package contains several extras and you can install additional dependencies
+if you specify them in this way.
+
+For example, with msgspec_:
+
+.. code-block:: bash
+
+   pip install "asyncly[msgspec]"
+
+Complete table of extras below:
+
++-------------------------------------+----------------------------------+
+| example                             | description                      |
++========================================================================+
+| ``pip install "asyncly[msgspec]"``  | For using msgspec_ structs       |
++-------------------------------------+----------------------------------+
+| ``pip install "asyncly[orjson]"``   | For fast parsing json by orjson_ |
++-------------------------------------+----------------------------------+
+| ``pip install "asyncly[pydantic]"`` | For using pydantic_ models       |
++-------------------------------------+----------------------------------+
+
+Quick start guide
+-----------------
+
+BaseHttpClient
+~~~~~~~~~~~~~~
+
+Simple HTTP Client for `https://catfact.ninja`. See full example in `examples/catfact_client.py`_
+
+.. code-block:: python
+
+   from base_http_client.client import (
+       DEFAULT_TIMEOUT,
+       BaseHttpClient,
+       ResponseHandlersType,
+   )
+   from base_http_client.handlers.pydantic import parse_model
+   from base_http_client.timeout import TimeoutType
+
+
+   class CatfactClient(BaseHttpClient):
+       RANDOM_CATFACT_HANDLERS: ResponseHandlersType = MappingProxyType(
+            {
+                 HTTPStatus.OK: parse_model(CatfactSchema),
+            }
+       )
+
+      async def fetch_random_cat_fact(
+          self,
+          timeout: TimeoutType = DEFAULT_TIMEOUT,
+      ) -> CatfactSchema:
+          return await self._make_req(
+              method=hdrs.METH_GET,
+              url=self._url / "fact",
+              handlers=self.RANDOM_CATFACT_HANDLERS,
+              timeout=timeout,
+          )
+
+
+
+
+.. _PyPI: https://pypi.org/
+.. _aiohttp: https://pypi.org/project/aiohttp/
+.. _msgspec: https://github.com/jcrist/msgspec
+.. _orjson: https://github.com/ijl/orjson
+.. _pydantic: https://github.com/pydantic/pydantic
+
+.. _examples/catfact_client.py: https://github.com/andy-takker/asyncly/blob/master/examples/catfact_client.py

asyncly-0.3.0/README.rst

@@ -0,0 +1,104 @@
+Asyncly
+=======
+
+.. image:: https://img.shields.io/pypi/v/asyncly.svg
+   :target: https://pypi.python.org/pypi/asyncly/
+   :alt: Latest Version
+
+.. image:: https://img.shields.io/pypi/wheel/base-http-client.svg
+   :target: https://pypi.python.org/pypi/base-http-client/
+
+.. image:: https://img.shields.io/pypi/pyversions/base-http-client.svg
+   :target: https://pypi.python.org/pypi/base-http-client/
+
+.. image:: https://img.shields.io/pypi/l/base-http-client.svg
+   :target: https://pypi.python.org/pypi/base-http-client/
+
+Simple HTTP client and server for your integrations based on aiohttp_.
+
+Installation
+------------
+
+Installation is possible in standard ways, such as PyPI or
+installation from a git repository directly.
+
+Installing from PyPI_:
+
+.. code-block:: bash
+
+   pip install asyncly
+
+Installing from github.com:
+
+.. code-block:: bash
+
+   pip install git+https://github.com/andy-takker/asyncly
+
+The package contains several extras and you can install additional dependencies
+if you specify them in this way.
+
+For example, with msgspec_:
+
+.. code-block:: bash
+
+   pip install "asyncly[msgspec]"
+
+Complete table of extras below:
+
++-------------------------------------+----------------------------------+
+| example                             | description                      |
++========================================================================+
+| ``pip install "asyncly[msgspec]"``  | For using msgspec_ structs       |
++-------------------------------------+----------------------------------+
+| ``pip install "asyncly[orjson]"``   | For fast parsing json by orjson_ |
++-------------------------------------+----------------------------------+
+| ``pip install "asyncly[pydantic]"`` | For using pydantic_ models       |
++-------------------------------------+----------------------------------+
+
+Quick start guide
+-----------------
+
+BaseHttpClient
+~~~~~~~~~~~~~~
+
+Simple HTTP Client for `https://catfact.ninja`. See full example in `examples/catfact_client.py`_
+
+.. code-block:: python
+
+   from base_http_client.client import (
+       DEFAULT_TIMEOUT,
+       BaseHttpClient,
+       ResponseHandlersType,
+   )
+   from base_http_client.handlers.pydantic import parse_model
+   from base_http_client.timeout import TimeoutType
+
+
+   class CatfactClient(BaseHttpClient):
+       RANDOM_CATFACT_HANDLERS: ResponseHandlersType = MappingProxyType(
+            {
+                 HTTPStatus.OK: parse_model(CatfactSchema),
+            }
+       )
+
+      async def fetch_random_cat_fact(
+          self,
+          timeout: TimeoutType = DEFAULT_TIMEOUT,
+      ) -> CatfactSchema:
+          return await self._make_req(
+              method=hdrs.METH_GET,
+              url=self._url / "fact",
+              handlers=self.RANDOM_CATFACT_HANDLERS,
+              timeout=timeout,
+          )
+
+
+
+
+.. _PyPI: https://pypi.org/
+.. _aiohttp: https://pypi.org/project/aiohttp/
+.. _msgspec: https://github.com/jcrist/msgspec
+.. _orjson: https://github.com/ijl/orjson
+.. _pydantic: https://github.com/pydantic/pydantic
+
+.. _examples/catfact_client.py: https://github.com/andy-takker/asyncly/blob/master/examples/catfact_client.py

asyncly-0.3.0/asyncly/__init__.py

@@ -0,0 +1,12 @@
+from aiohttp.client import DEFAULT_TIMEOUT
+
+from asyncly.client.base import BaseHttpClient
+from asyncly.client.handlers.base import ResponseHandlersType
+from asyncly.client.timeout import TimeoutType
+
+__all__ = (
+    "BaseHttpClient",
+    "TimeoutType",
+    "ResponseHandlersType",
+    "DEFAULT_TIMEOUT",
+)

asyncly-0.3.0/asyncly/client/base.py

@@ -0,0 +1,50 @@
+from typing import Any, Literal
+
+from aiohttp import ClientSession
+from aiohttp.client import DEFAULT_TIMEOUT
+from yarl import URL
+
+from asyncly.client.handlers.base import (
+    ResponseHandlersType,
+    apply_handler,
+)
+from asyncly.client.timeout import TimeoutType, get_timeout
+
+
+class BaseHttpClient:
+    __slots__ = ("_url", "_session", "_client_name")
+
+    _url: URL
+    _session: ClientSession
+    _client_name: str
+
+    def __init__(
+        self, url: URL | str, session: ClientSession, client_name: str
+    ) -> None:
+        self._url = url if isinstance(url, URL) else URL(url)
+        self._session = session
+        self._client_name = client_name
+
+    @property
+    def url(self) -> URL:
+        return self._url
+
+    async def _make_req(
+        self,
+        method: Literal["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"],
+        url: URL,
+        handlers: ResponseHandlersType,
+        timeout: TimeoutType = DEFAULT_TIMEOUT,
+        **kwargs: Any,
+    ) -> Any:
+        async with self._session.request(
+            method=method,
+            url=url,
+            timeout=get_timeout(timeout),
+            **kwargs,
+        ) as response:
+            return await apply_handler(
+                handlers=handlers,
+                response=response,
+                client_name=self._client_name,
+            )

asyncly-0.3.0/asyncly/client/handlers/base.py

@@ -0,0 +1,39 @@
+from collections.abc import Callable, Mapping
+from http import HTTPStatus
+from typing import Any
+
+from aiohttp import ClientResponse
+
+from asyncly.client.handlers.exceptions import UnhandledStatusException
+
+ResponseHandlersType = Mapping[HTTPStatus | int | str, Callable]
+
+
+async def apply_handler(
+    handlers: ResponseHandlersType,
+    response: ClientResponse,
+    client_name: str,
+) -> Any:
+    handler = _find_handler(handlers=handlers, status=response.status)
+    if not handler:
+        raise UnhandledStatusException(
+            f"Unexpected resposne {response.status} from {response.url}",
+            status=response.status,
+            url=response.url,
+            client_name=client_name,
+        )
+    return await handler(response=response)
+
+
+def _find_handler(handlers: ResponseHandlersType, status: int) -> Callable | None:
+    if status in handlers:
+        return handlers[status]
+
+    status_group = f"{status // 100}xx"
+    if status_group in handlers:
+        return handlers[status_group]
+
+    if "*" in handlers:
+        return handlers["*"]
+
+    return None

asyncly-0.3.0/asyncly/client/handlers/exceptions.py

@@ -0,0 +1,24 @@
+from aiohttp import ClientError
+from yarl import URL
+
+
+class BaseHttpClientException(ClientError):
+    pass
+
+
+class UnhandledStatusException(BaseHttpClientException, KeyError):
+    status: int
+    url: URL
+    client_name: str | None
+
+    def __init__(
+        self,
+        message: str,
+        status: int,
+        url: URL,
+        client_name: str | None = None,
+    ):
+        super().__init__(message)
+        self.status = status
+        self.url = url
+        self.client_name = client_name

asyncly-0.3.0/asyncly/client/handlers/json.py

@@ -0,0 +1,24 @@
+from asyncio import iscoroutinefunction
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from aiohttp import ClientResponse
+
+try:
+    import orjson as json
+except ImportError:
+    import json  # type: ignore
+
+
+def parse_json(
+    parser: Callable,
+    loads: Callable = json.loads,
+) -> Callable[[ClientResponse], Awaitable[Any]]:
+    async def _parse(response: ClientResponse) -> Any:
+        response_data = await response.json(loads=loads)
+        if iscoroutinefunction(parser):
+            return await parser(response_data)
+        else:
+            return parser(response_data)
+
+    return _parse

asyncly-0.3.0/asyncly/client/handlers/msgspec.py

@@ -0,0 +1,15 @@
+from collections.abc import Awaitable, Callable
+from typing import TypeVar
+
+from aiohttp import ClientResponse
+from msgspec import Struct
+from msgspec.json import decode
+
+T = TypeVar("T", bound=Struct)
+
+
+def parse_struct(struct: type[T]) -> Callable[[ClientResponse], Awaitable[T]]:
+    async def _parse(response: ClientResponse) -> T:
+        return decode(await response.read(), type=struct)
+
+    return _parse

asyncly-0.3.0/asyncly/client/handlers/pydantic.py

@@ -0,0 +1,14 @@
+from collections.abc import Awaitable, Callable
+from typing import TypeVar
+
+from aiohttp import ClientResponse
+from pydantic import BaseModel
+
+T = TypeVar("T", bound=BaseModel)
+
+
+def parse_model(model: type[T]) -> Callable[[ClientResponse], Awaitable[T]]:
+    async def _parse(response: ClientResponse) -> T:
+        return model.model_validate_json(await response.read())
+
+    return _parse

asyncly-0.3.0/asyncly/client/timeout.py

@@ -0,0 +1,27 @@
+from datetime import timedelta
+from functools import singledispatch
+
+from aiohttp import ClientTimeout
+
+TimeoutType = ClientTimeout | timedelta | int | float
+
+
+@singledispatch
+def get_timeout(t: TimeoutType) -> ClientTimeout:
+    raise TypeError(f"Unknown type {type(t)}")
+
+
+@get_timeout.register(ClientTimeout)
+def _client_timeout(t: ClientTimeout) -> ClientTimeout:
+    return t
+
+
+@get_timeout.register(timedelta)
+def _timedelta(t: timedelta) -> ClientTimeout:
+    return ClientTimeout(total=t.total_seconds())
+
+
+@get_timeout.register(int)
+@get_timeout.register(float)
+def _number(t: int | float) -> ClientTimeout:
+    return ClientTimeout(total=float(t))

asyncly-0.3.0/asyncly/srvmocker/__init__.py

@@ -0,0 +1,10 @@
+from asyncly.srvmocker.models import MockRoute, MockService
+from asyncly.srvmocker.responses import JsonResponse
+from asyncly.srvmocker.service import start_service
+
+__all__ = (
+    "MockRoute",
+    "MockService",
+    "JsonResponse",
+    "start_service",
+)

asyncly-0.3.0/asyncly/srvmocker/handlers.py

@@ -0,0 +1,21 @@
+from collections.abc import Awaitable, Callable
+
+from aiohttp.web_request import Request
+from aiohttp.web_response import Response
+
+from asyncly.srvmocker.models import MockService, RequestHistory
+
+
+def get_default_handler(handler_name: str) -> Callable[[Request], Awaitable[Response]]:
+    async def _handler(request: Request) -> Response:
+        history = RequestHistory(
+            request=request,
+            body=await request.read(),
+        )
+        context: MockService = request.app["service"]
+        context.history.append(history)
+        context.history_map[handler_name].append(history)
+        handler = context.handlers[handler_name]
+        return await handler.response(request)
+
+    return _handler

asyncly-0.3.0/asyncly/srvmocker/models.py

@@ -0,0 +1,37 @@
+from abc import ABC, abstractmethod
+from collections.abc import MutableMapping, MutableSequence
+from dataclasses import dataclass
+
+from aiohttp.web_request import Request
+from aiohttp.web_response import Response
+from yarl import URL
+
+
+@dataclass(frozen=True)
+class MockRoute:
+    method: str
+    path: str
+    handler_name: str
+
+
+@dataclass
+class RequestHistory:
+    request: Request
+    body: bytes
+
+
+class BaseMockResponse(ABC):
+    @abstractmethod
+    async def response(self, request: Request) -> Response:
+        pass
+
+
+@dataclass(frozen=True)
+class MockService:
+    history: MutableSequence[RequestHistory]
+    history_map: MutableMapping[str, MutableSequence[RequestHistory]]
+    url: URL
+    handlers: MutableMapping[str, BaseMockResponse]
+
+    def register(self, name: str, resp: BaseMockResponse) -> None:
+        self.handlers[name] = resp

asyncly-0.3.0/asyncly/srvmocker/responses.py

@@ -0,0 +1,80 @@
+from asyncio import sleep
+from collections.abc import Iterable, Iterator, Mapping, MutableMapping
+from dataclasses import dataclass
+from http import HTTPStatus
+from typing import Any
+
+from aiohttp import hdrs
+from aiohttp.web_request import Request
+from aiohttp.web_response import Response
+
+from asyncly.srvmocker.models import BaseMockResponse
+from asyncly.srvmocker.serialization import JsonSerializer, Serializer
+
+TimeoutType = int | float
+
+
+@dataclass
+class ContentResponse(BaseMockResponse):
+    body: Any = None
+    status: int = HTTPStatus.OK
+    headers: Mapping[str, str] | None = None
+    serializer: Serializer | None = None
+
+    async def response(self, request: Request) -> Response:
+        headers: MutableMapping[str, str] = dict()
+        if self.headers:
+            headers.update(self.headers)
+        if self.serializer:
+            headers[hdrs.CONTENT_TYPE] = self.serializer.content_type
+        return Response(
+            status=self.status,
+            body=self.serialize(),
+            headers=headers,
+        )
+
+    def serialize(self) -> Any:
+        if not self.serializer:
+            return self.body
+        return self.serializer.dumps(self.body)
+
+
+@dataclass
+class LatencyResponse(BaseMockResponse):
+    wrapped: BaseMockResponse
+    latency: TimeoutType
+
+    async def response(self, request: Request) -> Response:
+        await sleep(self.latency)
+        return await self.wrapped.response(request)
+
+
+class MockSeqResponse(BaseMockResponse):
+    responses: Iterator[BaseMockResponse]
+
+    def __init__(self, responses: Iterable[BaseMockResponse]) -> None:
+        self.responses = iter(responses)
+
+    async def response(self, request: Request) -> Response:
+        resp = next(self.responses)
+        return await resp.response(request)
+
+
+class JsonResponse(BaseMockResponse):
+    __content: ContentResponse
+
+    def __init__(
+        self,
+        body: Any,
+        status: int = HTTPStatus.OK,
+        headers: Mapping[str, str] | None = None,
+    ) -> None:
+        self.__content = ContentResponse(
+            body=body,
+            status=status,
+            headers=headers,
+            serializer=JsonSerializer,
+        )
+
+    async def response(self, request: Request) -> Response:
+        return await self.__content.response(request)

asyncly-0.3.0/asyncly/srvmocker/serialization.py

@@ -0,0 +1,16 @@
+import json
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Final
+
+
+@dataclass(frozen=True)
+class Serializer:
+    dumps: Callable[[Any], str]
+    content_type: str
+
+
+JsonSerializer: Final = Serializer(
+    dumps=json.dumps,
+    content_type="application/json",
+)

asyncly-0.3.0/asyncly/srvmocker/service.py

@@ -0,0 +1,35 @@
+from collections import defaultdict
+from collections.abc import AsyncGenerator, Iterable
+from contextlib import asynccontextmanager
+
+from aiohttp.test_utils import TestServer
+from aiohttp.web_app import Application
+
+from asyncly.srvmocker.handlers import get_default_handler
+from asyncly.srvmocker.models import MockRoute, MockService
+
+
+@asynccontextmanager
+async def start_service(
+    routes: Iterable[MockRoute],
+) -> AsyncGenerator[MockService, None]:
+    app = Application()
+    server = TestServer(app)
+    for route in routes:
+        app.router.add_route(
+            method=route.method,
+            path=route.path,
+            handler=get_default_handler(route.handler_name),
+        )
+    await server.start_server()
+    mock_service = MockService(
+        history=list(),
+        history_map=defaultdict(list),
+        url=server.make_url(""),
+        handlers=dict(),
+    )
+    app["service"] = mock_service
+    try:
+        yield mock_service
+    finally:
+        await server.close()

asyncly-0.3.0/pyproject.toml

@@ -0,0 +1,136 @@
+[tool.poetry]
+name = "asyncly"
+version = "0.3.0"
+description = "Simple HTTP client and server for your integrations based on aiohttp"
+authors = ["Sergey Natalenko <sergey.natalenko@mail.ru>"]
+license = "MIT"
+homepage = "https://github.com/andy-takker/asyncly"
+readme = "README.rst"
+keywords = ["aiohttp", "http", "client"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: AsyncIO",
+    "Framework :: Pytest",
+    "Framework :: aiohttp",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Internet",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development",
+]
+packages = [
+    { include = "asyncly" },
+]
+
+[tool.poetry.urls]
+"Source" = "https://github.com/andy-takker/asyncly"
+"Bug Tracker" = "https://github.com/andy-takker/v/issues"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+aiohttp = "^3.9.5"
+msgspec = {version = "^0.18.6", optional = true}
+orjson = {version = "^3.10.6", optional = true}
+pydantic = {version = "^2.8.2", optional = true}
+
+[tool.poetry.extras]
+msgspec = ["msgspec"]
+pydantic = ["pydantic"]
+orjson = ["orjson"]
+
+[tool.poetry.group.dev.dependencies]
+pre-commit = ">=3.7.1,<5.0.0"
+mypy = "^1.10.1"
+ruff = ">=0.5.2,<0.8.0"
+restructuredtext-lint = "^1.4.0"
+pygments = "^2.18.0"
+pytest = "^8.3.3"
+pytest-asyncio = "^0.24.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+python_files = "test_*"
+python_functions = "test_*"
+python_classes = "TestSuite*"
+addopts = "-p no:cacheprovider"
+
+[tool.coverage.run]
+branch = true
+source = ["asyncly"]
+command_line = "-m pytest"
+
+[tool.coverage.report]
+show_missing = true
+
+[tool.coverage.xml]
+output = "coverage.xml"
+
+[tool.ruff]
+line-length = 88
+exclude = [
+    ".git",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".venv",
+]
+indent-width = 4
+target-version = "py310"
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.ruff.lint]
+select = [
+    "BLE",
+    "C90",
+    "E",
+    "F",
+    "G",
+    "I",
+    "ICN",
+    "ISC",
+    "PLE",
+    "Q",
+    "RUF006",
+    "RUF100",
+    "T10",
+    "T20",
+    "TID",
+    "UP",
+    "W",
+]
+ignore = ["ISC001"]
+fixable = ["ALL"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["asyncly", "tests"]
+
+[tool.mypy]
+plugins = ["pydantic.mypy"]
+check_untyped_defs = true
+disallow_incomplete_defs = true
+disallow_untyped_defs = true
+ignore_missing_imports = false
+no_implicit_optional = true
+
+[[tool.mypy.overrides]]
+module = [
+    "msgspec.*",
+    "orjson.*",
+]
+ignore_missing_imports = true