asyncly 0.3.0__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,20 @@
+asyncly/__init__.py,sha256=mOpQzL75Op1HdNqT_o4oZ7NEpBCDARBh5hM-z5ExW1k,307
+asyncly/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+asyncly/client/base.py,sha256=MMnyoybfdANA4e-F69j5N5vFZdcvSjKJPVH0MSyFrjI,1334
+asyncly/client/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+asyncly/client/handlers/base.py,sha256=SeAF9Q09OG37s4IYmuAqSWABShuzLXq4raNn1if6xnU,1086
+asyncly/client/handlers/exceptions.py,sha256=mkjQwe_MSVDWT1QyvTB98uO3ZRJiF62i4TdJOMUOyzU,500
+asyncly/client/handlers/json.py,sha256=RatnbI-5s8vRCnA6TOChz53Ev4NBWp5pVRSOqehb0LQ,627
+asyncly/client/handlers/msgspec.py,sha256=k4x8_XTfNTxBIOR3LaZ8CcJcMW-2b5zf0SFupDuyD3k,413
+asyncly/client/handlers/pydantic.py,sha256=U7TPuueJm5j4tTQT0n5dIhPCBxkDNJScWkF8qemHCg0,392
+asyncly/client/timeout.py,sha256=hDPJ8iV5jXWJow5aK2A4iEQCIqagvVnhKa35gIVpKKM,658
+asyncly/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+asyncly/srvmocker/__init__.py,sha256=kUHXbFjbx9Mlu4qKPd3AAyCOLPkQMoME79NO76LBqC8,257
+asyncly/srvmocker/handlers.py,sha256=I4PnFsvM_IVOI_Ud5eLi0xttObQLlTGTq2uuhCrSuNw,722
+asyncly/srvmocker/models.py,sha256=ikVnVCTKGPS6zivesYFVJESVMwP9KiOkR4-qptiGbs4,853
+asyncly/srvmocker/responses.py,sha256=AKuA7t0Iam_rS-gx78C_kknPWou2QKF4A4i9P2esecA,2291
+asyncly/srvmocker/serialization.py,sha256=HteBp_w3XELlIvWEv2SnkntTY6IGEefoSeHajHqXmXs,310
+asyncly/srvmocker/service.py,sha256=XRVnWNnwkWag9ElbYeR7Ir7WXdNVi70PHDTIVfZ05nM,1000
+asyncly-0.3.0.dist-info/METADATA,sha256=6c85cr-1I10tCFoKpn8_yBYNLTbTEHtYkwWQKegScXY,4835
+asyncly-0.3.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+asyncly-0.3.0.dist-info/RECORD,,

asyncly-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.1
+Root-Is-Purelib: true
+Tag: py3-none-any