telegrinder 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/client/aiohttp.py

@@ -1,130 +1,134 @@
-import ssl
-import typing
-
-import aiohttp
-import certifi
-from aiohttp import ClientSession, TCPConnector
-
-import telegrinder.msgspec_json as json
-from telegrinder.client.abc import ABCClient
-
-if typing.TYPE_CHECKING:
-    from aiohttp import ClientResponse
-
-
-class AiohttpClient(ABCClient):
-    def __init__(
-        self,
-        session: ClientSession | None = None,
-        timeout: aiohttp.ClientTimeout | None = None,
-        **session_params: typing.Any,
-    ) -> None:
-        self.session = session
-        self.session_params = session_params
-        self.timeout = timeout or aiohttp.ClientTimeout(total=0)
-
-    def __repr__(self) -> str:
-        return "<{}: session={!r}, timeout={}, closed={}>".format(
-            self.__class__.__name__,
-            self.session,
-            self.timeout,
-            True if self.session is None else self.session.closed,
-        )
-
-    async def request_raw(
-        self,
-        url: str,
-        method: str = "GET",
-        data: dict[str, typing.Any] | None = None,
-        **kwargs: typing.Any,
-    ) -> "ClientResponse":
-        if not self.session:
-            self.session = ClientSession(
-                connector=TCPConnector(ssl=ssl.create_default_context(cafile=certifi.where())),
-                json_serialize=json.dumps,
-                **self.session_params,
-            )
-        async with self.session.request(
-            url=url,
-            method=method,
-            data=data,
-            timeout=self.timeout,
-            **kwargs,
-        ) as response:
-            await response.read()
-            return response
-
-    async def request_json(
-        self,
-        url: str,
-        method: str = "GET",
-        data: dict[str, typing.Any] | None = None,
-        **kwargs: typing.Any,
-    ) -> dict[str, typing.Any]:
-        response = await self.request_raw(url, method, data, **kwargs)
-        return await response.json(
-            encoding="UTF-8",
-            loads=json.loads,
-            content_type=None,
-        )
-
-    async def request_text(
-        self,
-        url: str,
-        method: str = "GET",
-        data: dict[str, typing.Any] | aiohttp.FormData | None = None,
-        **kwargs: typing.Any,
-    ) -> str:
-        response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
-        return await response.text(encoding="UTF-8")
-
-    async def request_bytes(
-        self,
-        url: str,
-        method: str = "GET",
-        data: dict[str, typing.Any] | aiohttp.FormData | None = None,
-        **kwargs: typing.Any,
-    ) -> bytes:
-        response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
-        if response._body is None:
-            await response.read()
-        return response._body
-
-    async def request_content(
-        self,
-        url: str,
-        method: str = "GET",
-        data: dict[str, typing.Any] | None = None,
-        **kwargs: typing.Any,
-    ) -> bytes:
-        response = await self.request_raw(url, method, data, **kwargs)
-        return response._body
-
-    async def close(self) -> None:
-        if self.session and not self.session.closed:
-            await self.session.close()
-
-    @classmethod
-    def get_form(
-        cls,
-        data: dict[str, typing.Any],
-        files: dict[str, tuple[str, bytes]] | None = None,
-    ) -> aiohttp.formdata.FormData:
-        files = files or {}
-        form = aiohttp.formdata.FormData(quote_fields=False)
-        for k, v in data.items():
-            form.add_field(k, str(v))
-
-        for n, f in files.items():
-            form.add_field(n, f[1], filename=f[0])
-
-        return form
-
-    def __del__(self) -> None:
-        if self.session and not self.session.closed:
-            if self.session._connector is not None and self.session._connector_owner:
-                self.session._connector.close()
-            self.session._connector = None
-
-
-__all__ = ("AiohttpClient",)
+import ssl
+import typing
+
+import aiohttp
+import certifi
+from aiohttp import ClientSession, TCPConnector
+
+import telegrinder.msgspec_json as json
+from telegrinder.client.abc import ABCClient
+
+if typing.TYPE_CHECKING:
+    from aiohttp import ClientResponse
+
+type Data = dict[str, typing.Any] | aiohttp.formdata.FormData
+type Response = ClientResponse
+
+
+class AiohttpClient(ABCClient[aiohttp.formdata.FormData]):
+    """HTTP client based on `aiohttp` module."""
+
+    CONNECTION_TIMEOUT_ERRORS = (
+        aiohttp.client.ServerConnectionError,
+        TimeoutError,
+    )
+    CLIENT_CONNECTION_ERRORS = (
+        aiohttp.client.ClientConnectionError,
+        aiohttp.client.ClientConnectorError,
+        aiohttp.ClientOSError,
+    )
+
+    def __init__(
+        self,
+        session: ClientSession | None = None,
+        timeout: aiohttp.ClientTimeout | None = None,
+        **session_params: typing.Any,
+    ) -> None:
+        self.session = session
+        self.session_params = session_params
+        self.timeout = timeout or aiohttp.ClientTimeout(total=0)
+
+    def __repr__(self) -> str:
+        return "<{}: session={!r}, timeout={}, closed={}>".format(
+            self.__class__.__name__,
+            self.session,
+            self.timeout,
+            True if self.session is None else self.session.closed,
+        )
+
+    async def request_raw(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Any,
+    ) -> Response:
+        if not self.session:
+            self.session = ClientSession(
+                connector=TCPConnector(ssl=ssl.create_default_context(cafile=certifi.where())),
+                json_serialize=json.dumps,
+                **self.session_params,
+            )
+
+        async with self.session.request(
+            url=url,
+            method=method,
+            data=data,
+            timeout=self.timeout,
+            **kwargs,
+        ) as response:
+            await response.read()
+            return response
+
+    async def request_json(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Any,
+    ) -> dict[str, typing.Any]:
+        response = await self.request_raw(url, method, data, **kwargs)
+        return await response.json(
+            encoding="UTF-8",
+            loads=json.loads,
+            content_type=None,
+        )
+
+    async def request_text(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Any,
+    ) -> str:
+        response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
+        return await response.text(encoding="UTF-8")
+
+    async def request_bytes(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Any,
+    ) -> bytes:
+        response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
+        if response._body is None:
+            await response.read()
+        return response._body or bytes()
+
+    async def request_content(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Any,
+    ) -> bytes:
+        response = await self.request_raw(url, method, data, **kwargs)
+        return response._body or bytes()
+
+    async def close(self) -> None:
+        if self.session and not self.session.closed:
+            await self.session.close()
+
+    @classmethod
+    def multipart_form_factory(cls) -> aiohttp.formdata.FormData:
+        return aiohttp.formdata.FormData(quote_fields=False)
+
+    def __del__(self) -> None:
+        if self.session and not self.session.closed:
+            if self.session._connector is not None and self.session._connector_owner:
+                self.session._connector._close()
+            self.session._connector = None
+
+
+__all__ = ("AiohttpClient",)

telegrinder/client/form_data.py

@@ -0,0 +1,31 @@
+import typing
+
+from telegrinder.msgspec_utils import encoder
+
+
+def encode_form_data(
+    data: dict[str, typing.Any],
+    files: dict[str, tuple[str, typing.Any]],
+    /,
+) -> dict[str, str]:
+    context = dict(files=files)
+    return {
+        k: encoder.encode(v, context=context).removeprefix('"').removesuffix('"')  # Remove quoted strings
+        if not isinstance(v, str)
+        else v
+        for k, v in data.items()
+    }
+
+
+class MultipartFormProto(typing.Protocol):
+    def add_field(
+        self,
+        name: str,
+        value: typing.Any,
+        /,
+        *,
+        filename: str | None = None,
+    ) -> None: ...
+
+
+__all__ = ("MultipartFormProto", "encode_form_data")

telegrinder/client/sonic.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import io
+import ssl
+import typing
+
+import certifi
+
+import telegrinder.msgspec_json as json
+from telegrinder.client.abc import ABCClient
+
+if typing.TYPE_CHECKING:
+    from aiosonic import Connection, HTTPClient, HttpResponse, MultipartForm, Proxy, TCPConnector, Timeouts
+
+type Data = dict[str, typing.Any] | MultipartForm
+type Response = HttpResponse
+
+AIOSONIC_OBJECTS = (
+    "Connection",
+    "HTTPClient",
+    "HttpResponse",
+    "Proxy",
+    "TCPConnector",
+    "Timeouts",
+)
+
+
+def init_aiosonic_module(client_class: type[ABCClient[typing.Any]], /) -> None:
+    try:
+        import aiosonic
+        import aiosonic.exceptions
+    except ImportError:
+        raise ImportError(
+            "Module 'aiosonic' is not installed. You can install as follows: pip install aiosonic"
+        ) from None
+
+    globalns = globals()
+    for name in AIOSONIC_OBJECTS:
+        globalns.setdefault(name, getattr(aiosonic, name))
+
+    if "MultipartForm" not in globalns:
+        globalns["MultipartForm"] = type("MultiPartForm", (_MultipartForm, aiosonic.MultipartForm), {})
+
+    if not client_class.CONNECTION_TIMEOUT_ERRORS:
+        client_class.CONNECTION_TIMEOUT_ERRORS = (
+            aiosonic.exceptions.ConnectTimeout,
+            aiosonic.exceptions.RequestTimeout,
+            TimeoutError,
+        )
+
+    if not client_class.CLIENT_CONNECTION_ERRORS:
+        client_class.CLIENT_CONNECTION_ERRORS = (
+            aiosonic.exceptions.ConnectionDisconnected,
+            aiosonic.exceptions.ConnectionPoolAcquireTimeout,
+        )
+
+
+class _MultipartForm(MultipartForm if typing.TYPE_CHECKING else object):
+    async def _generate_chunks(self) -> typing.AsyncGenerator[bytes, None]:
+        for field in self.fields:
+            yield (f"--{self.boundary}\r\n").encode()
+
+            if isinstance(field[1], io.IOBase):
+                yield (
+                    "Content-Type: application/octet-stream\r\n"
+                    "Content-Disposition: form-data; " + f'name="{field[0]}"; filename="{field[2]}"\r\n\r\n'
+                ).encode()
+
+                async for data in self._read_file(field[1]):
+                    yield data + b"\r\n"
+
+                field[1].close()
+            else:
+                yield (
+                    "Content-Type: text/plain; charset=utf-8\r\n"
+                    f'Content-Disposition: form-data; name="{field[0]}"\r\n\r\n'
+                ).encode()
+                yield field[1].encode() + b"\r\n"
+
+        yield (f"--{self.boundary}--").encode()
+
+    async def get_body_size(self) -> tuple[bytes, int]:
+        if not self.fields:
+            return b"", 0
+        return await super().get_body_size()
+
+    def get_headers(self, size: int | None = None) -> dict[str, str]:
+        if not self.fields:
+            return {"Content-Type": "application/x-www-form-urlencoded"}
+        return super().get_headers(size)
+
+
+class AiosonicClient(ABCClient["MultipartForm"]):
+    """HTTP client based on `aiosonic` module."""
+
+    def __init_subclass__(cls, *args: typing.Any, **kwargs: typing.Any) -> None:
+        init_aiosonic_module(cls)
+        return super().__init_subclass__(*args, **kwargs)
+
+    def __init__(
+        self,
+        *,
+        verify_ssl: bool = True,
+        tpc_pool_size: int = 25,
+        tpc_timeouts: Timeouts | None = None,
+        proxy: Proxy | None = None,
+        conn_max_requests: int = 100,
+        use_dns_cache: bool = True,
+        handle_cookies: bool = False,
+        ttl_dns_cache: int = 10000,
+        **kwargs: typing.Any,
+    ) -> None:
+        init_aiosonic_module(self.__class__)
+        self.ssl = ssl.create_default_context(cafile=certifi.where())
+        self.proxy = proxy
+        self.verify_ssl = verify_ssl
+        self.handle_cookies = handle_cookies
+        self.tpc_timeouts = tpc_timeouts or Timeouts()
+        self.tcp_connector = TCPConnector(
+            pool_size=tpc_pool_size,
+            timeouts=self.tpc_timeouts,
+            connection_cls=Connection,
+            conn_max_requests=conn_max_requests,
+            use_dns_cache=use_dns_cache,
+            ttl_dns_cache=ttl_dns_cache,
+            **kwargs,
+        )
+        self.client: HTTPClient | None = None
+
+    def __repr__(self) -> str:
+        return "<{}: proxy={!r}, tpc_timeouts={!r}, tcp_connector={!r}, client={!r}>".format(
+            self.__class__.__name__,
+            self.proxy,
+            self.tpc_timeouts,
+            self.tcp_connector,
+            self.client,
+        )
+
+    @classmethod
+    def multipart_form_factory(cls) -> MultipartForm:
+        return MultipartForm()
+
+    async def request_raw(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Any,
+    ) -> Response:
+        if self.client is None:
+            self.client = HTTPClient(
+                connector=self.tcp_connector,
+                handle_cookies=self.handle_cookies,
+                verify_ssl=self.verify_ssl,
+                proxy=self.proxy,
+            )
+
+        return await self.client.request(
+            url=url,
+            method=method,
+            data=data,
+            json_serializer=json.dumps,
+            ssl=self.ssl,
+            **kwargs,
+        )
+
+    async def request_text(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Any,
+    ) -> str:
+        response = await self.request_raw(url, method, data, **kwargs)
+        return await response.text()
+
+    async def request_json(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Any,
+    ) -> dict[str, typing.Any]:
+        return json.loads(await self.request_content(url, method, data, **kwargs))
+
+    async def request_bytes(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Any,
+    ) -> bytes:
+        response = await self.request_raw(url, method, data, **kwargs)
+        return response.body
+
+    async def request_content(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Any,
+    ) -> bytes:
+        response = await self.request_raw(url, method, data, **kwargs)
+        return await response.content()
+
+    async def close(self) -> None:
+        if self.client is not None:
+            await self.client.connector.cleanup()
+            self.client = None
+
+
+__all__ = ("AiosonicClient",)