telegrinder 0.3.4.post1__py3-none-any.whl → 0.4.1__py3-none-any.whl

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",)

telegrinder/model.py

@@ -1,61 +1,35 @@
-import base64
-import dataclasses
-import enum
 import keyword
-import os
-import secrets
 import typing
-from datetime import datetime
-from types import NoneType
 
 import msgspec
 from fntypes.co import Nothing, Result, Some
 
-from telegrinder.msgspec_utils import decoder, encoder, get_origin
+from telegrinder.msgspec_utils import decoder, encoder, struct_as_dict
 
 if typing.TYPE_CHECKING:
     from telegrinder.api.error import APIError
 
-T = typing.TypeVar("T")
-P = typing.ParamSpec("P")
-
-UnionType: typing.TypeAlias = typing.Annotated[tuple[T, ...], ...]
-
 MODEL_CONFIG: typing.Final[dict[str, typing.Any]] = {
-    "omit_defaults": True,
     "dict": True,
     "rename": {kw + "_": kw for kw in keyword.kwlist},
 }
+UNSET = typing.cast(typing.Any, msgspec.UNSET)
+"""Docs: https://jcristharif.com/msgspec/api.html#unset
 
-
-@typing.overload
-def full_result(
-    result: Result[msgspec.Raw, "APIError"],
-    full_t: type[T],
-) -> Result[T, "APIError"]: ...
-
-
-@typing.overload
-def full_result(
-    result: Result[msgspec.Raw, "APIError"],
-    full_t: UnionType[T],
-) -> Result[T, "APIError"]: ...
+During decoding, if a field isn't explicitly set in the model,
+the default value of `UNSET` will be set instead. This lets downstream
+consumers determine whether a field was left unset, or explicitly set a value."""
 
 
-def full_result(
+def full_result[T](
     result: Result[msgspec.Raw, "APIError"],
-    full_t: typing.Any,
-) -> Result[typing.Any, "APIError"]:
+    full_t: type[T],
+) -> Result[T, "APIError"]:
     return result.map(lambda v: decoder.decode(v, type=full_t))
 
 
-def generate_random_id(length_bytes: int) -> str:
-    if length_bytes < 1 or length_bytes > 64:
-        raise ValueError("Length of bytes must be between 1 and 64.")
-
-    random_bytes = os.urandom(length_bytes)
-    random_id = base64.urlsafe_b64encode(random_bytes).rstrip(b"=").decode("utf-8")
-    return random_id
+def is_none(value: typing.Any, /) -> typing.TypeGuard[None | Nothing]:
+    return value is None or isinstance(value, Nothing)
 
 
 def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
@@ -66,7 +40,7 @@ def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
     ):
         if isinstance(v, Proxy):
             v = v.get()
-        if k == "self" or type(v) in (NoneType, Nothing):
+        if k == "self" or is_none(v):
             continue
         validated_params[k] = v.unwrap() if isinstance(v, Some) else v
     return validated_params
@@ -118,12 +92,12 @@ if typing.TYPE_CHECKING:
         converter=...,
     ) -> typing.Any: ...
 
-    class From(typing.Generic[T]):
+    class From[T]:
         def __new__(cls, _: T, /) -> typing.Any: ...
 else:
     from msgspec import field as _field
 
-    From = typing.Annotated[T, ...]
+    type From[T] = T
 
     def field(**kwargs):
         kwargs.pop("converter", None)
@@ -132,8 +106,19 @@ else:
 
 @typing.dataclass_transform(field_specifiers=(field,))
 class Model(msgspec.Struct, **MODEL_CONFIG):
+    if not typing.TYPE_CHECKING:
+
+        def __post_init__(self):
+            for field in self.__struct_fields__:
+                if is_none(getattr(self, field)):
+                    setattr(self, field, UNSET)
+
+        def __getattribute__(self, name, /):
+            val = super().__getattribute__(name)
+            return Nothing() if val is UNSET else val
+
     @classmethod
-    def from_data(cls: typing.Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+    def from_data[**P, T](cls: typing.Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
         return decoder.convert(msgspec.structs.asdict(cls(*args, **kwargs)), type=cls)  # type: ignore
 
     @classmethod
@@ -141,8 +126,8 @@ class Model(msgspec.Struct, **MODEL_CONFIG):
         return decoder.convert(obj, type=cls)
 
     @classmethod
-    def from_bytes(cls, obj: bytes, /) -> typing.Self:
-        return decoder.decode(obj, type=cls)
+    def from_raw(cls, raw: str | bytes, /) -> typing.Self:
+        return decoder.decode(raw, type=cls)
 
     def _to_dict(
         self,
@@ -152,7 +137,7 @@ class Model(msgspec.Struct, **MODEL_CONFIG):
     ) -> dict[str, typing.Any]:
         if dct_name not in self.__dict__:
             self.__dict__[dct_name] = (
-                msgspec.structs.asdict(self)
+                struct_as_dict(self)
                 if not full
                 else encoder.to_builtins(self.to_dict(exclude_fields=exclude_fields), order="deterministic")
             )
@@ -162,16 +147,17 @@ class Model(msgspec.Struct, **MODEL_CONFIG):
 
         return {key: value for key, value in self.__dict__[dct_name].items() if key not in exclude_fields}
 
+    def to_raw(self) -> str:
+        return encoder.encode(self)
+
     def to_dict(
         self,
         *,
         exclude_fields: set[str] | None = None,
     ) -> dict[str, typing.Any]:
-        """
-        :param exclude_fields: Model field names to exclude from the dictionary representation of this model.
+        """:param exclude_fields: Model field names to exclude from the dictionary representation of this model.
         :return: A dictionary representation of this model.
         """
-
         return self._to_dict("model_as_dict", exclude_fields or set(), full=False)
 
     def to_full_dict(
@@ -179,104 +165,14 @@ class Model(msgspec.Struct, **MODEL_CONFIG):
         *,
         exclude_fields: set[str] | None = None,
     ) -> dict[str, typing.Any]:
-        """
-        :param exclude_fields: Model field names to exclude from the dictionary representation of this model.
+        """:param exclude_fields: Model field names to exclude from the dictionary representation of this model.
         :return: A dictionary representation of this model including all models, structs, custom types.
         """
-
         return self._to_dict("model_as_full_dict", exclude_fields or set(), full=True)
 
 
-@dataclasses.dataclass(kw_only=True, frozen=True, slots=True, repr=False)
-class DataConverter:
-    _converters: dict[type[typing.Any], typing.Callable[..., typing.Any]] = dataclasses.field(
-        init=False,
-        default_factory=lambda: {},
-    )
-    _files: dict[str, tuple[str, bytes]] = dataclasses.field(default_factory=lambda: {})
-
-    def __repr__(self) -> str:
-        return "<{}: {}>".format(
-            self.__class__.__name__,
-            ", ".join(f"{k}={v.__name__!r}" for k, v in self._converters.items()),
-        )
-
-    def __post_init__(self) -> None:
-        self._converters.update(
-            {
-                get_origin(value.__annotations__["data"]): value
-                for key, value in vars(self.__class__).items()
-                if key.startswith("convert_") and callable(value)
-            }
-        )
-
-    def __call__(self, data: typing.Any, *, serialize: bool = True) -> typing.Any:
-        converter = self.get_converter(get_origin(type(data)))
-        if converter is not None:
-            if isinstance(converter, staticmethod):
-                return converter(data, serialize)
-            return converter(self, data, serialize)
-        return data
-
-    @property
-    def converters(self) -> dict[type[typing.Any], typing.Callable[..., typing.Any]]:
-        return self._converters.copy()
-
-    @property
-    def files(self) -> dict[str, tuple[str, bytes]]:
-        return self._files.copy()
-
-    @staticmethod
-    def convert_enum(data: enum.Enum, _: bool = False) -> typing.Any:
-        return data.value
-
-    @staticmethod
-    def convert_datetime(data: datetime, _: bool = False) -> int:
-        return int(data.timestamp())
-
-    def get_converter(self, t: type[typing.Any]):
-        for type_, converter in self._converters.items():
-            if issubclass(t, type_):
-                return converter
-        return None
-
-    def convert_model(
-        self,
-        data: Model,
-        serialize: bool = True,
-    ) -> str | dict[str, typing.Any]:
-        converted_dct = self(data.to_dict(), serialize=False)
-        return encoder.encode(converted_dct) if serialize is True else converted_dct
-
-    def convert_dct(
-        self,
-        data: dict[str, typing.Any],
-        serialize: bool = True,
-    ) -> dict[str, typing.Any]:
-        return {
-            k: self(v, serialize=serialize) for k, v in data.items() if type(v) not in (NoneType, Nothing)
-        }
-
-    def convert_lst(
-        self,
-        data: list[typing.Any],
-        serialize: bool = True,
-    ) -> str | list[typing.Any]:
-        converted_lst = [self(x, serialize=False) for x in data]
-        return encoder.encode(converted_lst) if serialize is True else converted_lst
-
-    def convert_tpl(self, data: tuple[typing.Any, ...], _: bool = False) -> str | tuple[typing.Any, ...]:
-        match data:
-            case (str(filename), bytes(content)):
-                attach_name = secrets.token_urlsafe(16)
-                self._files[attach_name] = (filename, content)
-                return "attach://{}".format(attach_name)
-
-        return data
-
-
-class Proxy:
-    def __init__(self, cfg: "_ProxiedDict", key: str) -> None:
+class Proxy[T]:
+    def __init__(self, cfg: "_ProxiedDict[T]", key: str) -> None:
         self.key = key
         self.cfg = cfg
 
@@ -284,7 +180,7 @@ class Proxy:
         return self.cfg._defaults.get(self.key)
 
 
-class _ProxiedDict(typing.Generic[T]):
+class _ProxiedDict[T]:
     def __init__(self, tp: type[T]) -> None:
         self.type = tp
         self._defaults = {}
@@ -301,20 +197,17 @@ class _ProxiedDict(typing.Generic[T]):
 
 if typing.TYPE_CHECKING:
 
-    def ProxiedDict(typed_dct: type[T]) -> T | _ProxiedDict[T]:  # noqa: N802
+    def ProxiedDict[T](typed_dct: type[T]) -> T | _ProxiedDict[T]:  # noqa: N802
         ...
-
 else:
     ProxiedDict = _ProxiedDict
 
 
 __all__ = (
-    "DataConverter",
     "MODEL_CONFIG",
     "Model",
     "ProxiedDict",
     "Proxy",
     "full_result",
-    "generate_random_id",
     "get_params",
 )

telegrinder/modules.py

@@ -3,6 +3,8 @@ import typing
 
 from choicelib import choice_in_order
 
+import telegrinder.msgspec_json as json
+
 
 @typing.runtime_checkable
 class LoggerModule(typing.Protocol):
@@ -234,4 +236,4 @@ def _set_logger_level(level, /):
 setattr(logger, "set_level", staticmethod(_set_logger_level))  # type: ignore
 
 
-__all__ = ("LoggerModule", "logger")
+__all__ = ("LoggerModule", "json", "logger")