telegrinder 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

telegrinder/client/abc.py

@@ -5,9 +5,10 @@ from abc import ABC, abstractmethod
 from telegrinder.client.form_data import MultipartFormProto, encode_form_data
 
 type Data = dict[str, typing.Any] | MultipartFormProto
+type Files = dict[str, tuple[str, typing.Any]]
 
 
-class ABCClient[MultipartForm: MultipartFormProto](ABC):
+class ABCClient(ABC):
     CONNECTION_TIMEOUT_ERRORS: tuple[type[BaseException], ...] = ()
     CLIENT_CONNECTION_ERRORS: tuple[type[BaseException], ...] = ()
 
@@ -15,6 +16,11 @@ class ABCClient[MultipartForm: MultipartFormProto](ABC):
     def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
         pass
 
+    @property
+    @abstractmethod
+    def timeout(self) -> float:
+        pass
+
     @abstractmethod
     async def request_text(
         self,
@@ -61,7 +67,7 @@ class ABCClient[MultipartForm: MultipartFormProto](ABC):
 
     @classmethod
     @abstractmethod
-    def multipart_form_factory(cls) -> MultipartForm:
+    def multipart_form_factory(cls) -> MultipartFormProto:
         pass
 
     @classmethod
@@ -69,8 +75,8 @@ class ABCClient[MultipartForm: MultipartFormProto](ABC):
         cls,
         *,
         data: dict[str, typing.Any],
-        files: dict[str, tuple[str, typing.Any]] | None = None,
-    ) -> MultipartForm:
+        files: Files | None = None,
+    ) -> MultipartFormProto:
         multipart_form = cls.multipart_form_factory()
         files = files or {}
 
@@ -92,9 +98,8 @@ class ABCClient[MultipartForm: MultipartFormProto](ABC):
         exc_type: type[BaseException],
         exc_val: typing.Any,
         exc_tb: typing.Any,
-    ) -> bool:
+    ) -> None:
         await self.close()
-        return not bool(exc_val)
 
 
 __all__ = ("ABCClient",)

telegrinder/client/aiohttp.py

@@ -1,70 +1,176 @@
+from __future__ import annotations
+
+import asyncio
 import ssl
 import typing
 
 import aiohttp
 import certifi
-from aiohttp import ClientSession, TCPConnector
+from aiohttp import BasicAuth, ClientSession, TCPConnector
+from aiohttp.hdrs import USER_AGENT
+from aiohttp.http import SERVER_SOFTWARE
 
-import telegrinder.msgspec_json as json
+from telegrinder.__meta__ import __version__
 from telegrinder.client.abc import ABCClient
+from telegrinder.msgspec_utils import json
 
 if typing.TYPE_CHECKING:
     from aiohttp import ClientResponse
 
 type Data = dict[str, typing.Any] | aiohttp.formdata.FormData
 type Response = ClientResponse
+type Timeout = int | float | aiohttp.ClientTimeout
+type Proxy = str | tuple[str, BasicAuth]
+type ProxyChain = typing.Iterable[Proxy]
+type ProxyType = Proxy | ProxyChain
+
+DEFAULT_TIMEOUT: typing.Final[float] = 30.0
+DEFAULT_LIMIT_SIMULTANEOUS_CONNECTIONS: typing.Final[int] = 100
+DEFAULT_TTL_DNS_CACHE: typing.Final[int] = 3600
+DEFAULT_HEADERS: typing.Final[dict[str, str]] = {USER_AGENT: f"{SERVER_SOFTWARE} telegrinder/{__version__}"}
+
+
+def _get_client_timeout(timeout: Timeout, /) -> aiohttp.ClientTimeout:
+    return timeout if isinstance(timeout, aiohttp.ClientTimeout) else aiohttp.ClientTimeout(total=float(timeout))
+
+
+def _prepare_proxy_connector(
+    proxy: ProxyType,
+    /,
+) -> tuple[type[TCPConnector], dict[str, typing.Any] | list[typing.Any]]:
+    try:
+        from aiohttp_socks import ChainProxyConnector, ProxyConnector, ProxyInfo  # type: ignore
+        from aiohttp_socks.utils import parse_proxy_url  # type: ignore
+    except ImportError:
+        raise ImportError(
+            "Module `aiohttp-socks` is not installed. You can install as follows: pip install aiohttp-socks "
+            'or pip install "telegrinder[socks]"',
+        ) from None
+
+    match proxy:
+        case str() | (str(), BasicAuth()):
+            proxy_chain = (proxy,)
+        case _:
+            proxy_chain = proxy
+
+    proxy_infos = list()  # type: ignore
+
+    for _proxy in proxy_chain:
+        url, basic = (_proxy, None) if isinstance(_proxy, str) else _proxy
+        proxy_type, host, port, username, password = parse_proxy_url(url)  # type: ignore
+
+        if basic is not None:
+            username, password = basic.login, basic.password  # type: ignore
+
+        proxy_infos.append(
+            ProxyInfo(  # type: ignore
+                proxy_type,
+                host,
+                port,
+                username,
+                password,
+                rdns=True,
+            ),
+        )
+
+    return (
+        (
+            ProxyConnector,  # type: ignore
+            proxy_infos[0]._asdict(),  # type: ignore
+        )
+        if len(proxy_infos) == 1
+        else (ChainProxyConnector, proxy_infos)
+    )  # type: ignore
 
 
-class AiohttpClient(ABCClient[aiohttp.formdata.FormData]):
+class AiohttpClient(ABCClient):
     """HTTP client based on `aiohttp` module."""
 
-    CONNECTION_TIMEOUT_ERRORS = (
-        aiohttp.client.ServerConnectionError,
-        TimeoutError,
-    )
+    CONNECTION_TIMEOUT_ERRORS = (aiohttp.client.ServerConnectionError,)
     CLIENT_CONNECTION_ERRORS = (
         aiohttp.client.ClientConnectionError,
         aiohttp.client.ClientConnectorError,
         aiohttp.ClientOSError,
     )
 
+    __slots__ = (
+        "session",
+        "limit",
+        "ttl_dns_cache",
+        "session_params",
+        "_proxy",
+        "_tcp_connector_kwargs",
+        "_tcp_connector_class",
+    )
+
     def __init__(
         self,
         session: ClientSession | None = None,
-        timeout: aiohttp.ClientTimeout | None = None,
+        proxy: ProxyType | None = None,
+        timeout: Timeout = DEFAULT_TIMEOUT,
+        limit: int = DEFAULT_LIMIT_SIMULTANEOUS_CONNECTIONS,
+        ttl_dns_cache: int = DEFAULT_TTL_DNS_CACHE,
         **session_params: typing.Any,
     ) -> None:
         self.session = session
+        self.limit = limit
+        self.ttl_dns_cache = ttl_dns_cache
         self.session_params = session_params
-        self.timeout = timeout or aiohttp.ClientTimeout(total=0)
+        self._timeout = _get_client_timeout(timeout)
+        self._proxy = proxy
+        self._tcp_connector_kwargs = dict[str, typing.Any](
+            ssl=ssl.create_default_context(cafile=certifi.where()),
+            limit=limit,
+            ttl_dns_cache=ttl_dns_cache,
+        )
+        self._tcp_connector_class: type[TCPConnector] = TCPConnector
+
+        self.session_params.setdefault("headers", DEFAULT_HEADERS)
+        self._setup_proxy()
 
     def __repr__(self) -> str:
         return "<{}: session={!r}, timeout={}, closed={}>".format(
-            self.__class__.__name__,
+            type(self).__name__,
             self.session,
-            self.timeout,
+            self._timeout,
             True if self.session is None else self.session.closed,
         )
 
+    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
+
+    @classmethod
+    def multipart_form_factory(cls) -> aiohttp.formdata.FormData:
+        return aiohttp.formdata.FormData(quote_fields=False)
+
+    @property
+    def timeout(self) -> float:
+        return float(self._timeout.total or 0.0)
+
     async def request_raw(
         self,
         url: str,
         method: str = "GET",
         data: Data | None = None,
+        *,
+        timeout: Timeout | None = None,
         **kwargs: typing.Any,
     ) -> Response:
         if not self.session:
             self.session = ClientSession(
-                connector=TCPConnector(ssl=ssl.create_default_context(cafile=certifi.where())),
+                connector=self._tcp_connector_class(**self._tcp_connector_kwargs),
                 json_serialize=json.dumps,
                 **self.session_params,
             )
 
         async with self.session.request(
-            url=url,
             method=method,
+            url=url,
             data=data,
-            timeout=self.timeout,
+            timeout=self._timeout if timeout is None else _get_client_timeout(timeout),
             **kwargs,
         ) as response:
             await response.read()
@@ -75,9 +181,11 @@ class AiohttpClient(ABCClient[aiohttp.formdata.FormData]):
         url: str,
         method: str = "GET",
         data: Data | None = None,
+        *,
+        timeout: Timeout | None = None,
         **kwargs: typing.Any,
     ) -> dict[str, typing.Any]:
-        response = await self.request_raw(url, method, data, **kwargs)
+        response = await self.request_raw(url, method, data, timeout=timeout, **kwargs)
         return await response.json(
             encoding="UTF-8",
             loads=json.loads,
@@ -89,9 +197,11 @@ class AiohttpClient(ABCClient[aiohttp.formdata.FormData]):
         url: str,
         method: str = "GET",
         data: Data | None = None,
+        *,
+        timeout: Timeout | None = None,
         **kwargs: typing.Any,
     ) -> str:
-        response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
+        response = await self.request_raw(url, method, data, timeout=timeout, **kwargs)
         return await response.text(encoding="UTF-8")
 
     async def request_bytes(
@@ -99,9 +209,11 @@ class AiohttpClient(ABCClient[aiohttp.formdata.FormData]):
         url: str,
         method: str = "GET",
         data: Data | None = None,
+        *,
+        timeout: Timeout | None = None,
         **kwargs: typing.Any,
     ) -> bytes:
-        response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
+        response = await self.request_raw(url, method, data, timeout=timeout, **kwargs)
         if response._body is None:
             await response.read()
         return response._body or bytes()
@@ -111,24 +223,26 @@ class AiohttpClient(ABCClient[aiohttp.formdata.FormData]):
         url: str,
         method: str = "GET",
         data: Data | None = None,
+        *,
+        timeout: Timeout | None = None,
         **kwargs: typing.Any,
     ) -> bytes:
-        response = await self.request_raw(url, method, data, **kwargs)
+        response = await self.request_raw(url, method, data, timeout=timeout, **kwargs)
         return response._body or bytes()
 
-    async def close(self) -> None:
+    async def close(self, *, gracefully: bool = True) -> 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)
+        if gracefully:
+            # Wait 250 ms for graceful shutdown SSL connections
+            await asyncio.sleep(0.250)
 
-    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
+    def _setup_proxy(self) -> None:
+        if self._proxy is not None:
+            tcp_connector_class, data = _prepare_proxy_connector(self._proxy)
+            self._tcp_connector_class = tcp_connector_class
+            self._tcp_connector_kwargs.update(data if isinstance(data, dict) else dict(proxy_infos=data))
 
 
 __all__ = ("AiohttpClient",)

telegrinder/client/form_data.py

@@ -10,7 +10,7 @@ def encode_form_data(
 ) -> dict[str, str]:
     context = dict(files=files)
     return {
-        k: encoder.encode(v, context=context).removeprefix('"').removesuffix('"')  # Remove quoted strings
+        k: encoder.encode(v, context=context).strip('"')  # Remove quoted string
         if not isinstance(v, str)
         else v
         for k, v in data.items()

telegrinder/model.py

@@ -1,53 +1,31 @@
 import keyword
-import typing
+import types
+from reprlib import recursive_repr
 
 import msgspec
-from fntypes.co import Nothing, Result, Some
+import typing_extensions as typing
+from fntypes.co import Nothing
 
-from telegrinder.msgspec_utils import decoder, encoder, struct_as_dict
-
-if typing.TYPE_CHECKING:
-    from telegrinder.api.error import APIError
+from telegrinder.msgspec_utils import Option, decoder, encoder, struct_asdict
 
+UNSET: typing.Final[typing.Any] = typing.cast("typing.Any", msgspec.UNSET)
+"""See [DOCS](https://jcristharif.com/msgspec/api.html#unset) about `msgspec.UNSET`."""
 MODEL_CONFIG: typing.Final[dict[str, typing.Any]] = {
     "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
-
-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[T](
-    result: Result[msgspec.Raw, "APIError"],
-    full_t: type[T],
-) -> Result[T, "APIError"]:
-    return result.map(lambda v: decoder.decode(v, type=full_t))
-
-
-def is_none(value: typing.Any, /) -> typing.TypeGuard[None | Nothing]:
-    return value is None or isinstance(value, Nothing)
+INSPECTED_MODEL_FIELDS_KEY: typing.Final[str] = "__inspected_struct_fields__"
 
 
-def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
-    validated_params = {}
-    for k, v in (
-        *params.pop("other", {}).items(),
-        *params.items(),
-    ):
-        if isinstance(v, Proxy):
-            v = v.get()
-        if k == "self" or is_none(v):
-            continue
-        validated_params[k] = v.unwrap() if isinstance(v, Some) else v
-    return validated_params
+def is_none(obj: typing.Any, /) -> typing.TypeIs[Nothing | None]:
+    return isinstance(obj, Nothing | types.NoneType)
 
 
 if typing.TYPE_CHECKING:
 
+    @typing.overload
+    def field() -> typing.Any: ...
+
     @typing.overload
     def field(*, name: str | None = ...) -> typing.Any: ...
 
@@ -100,6 +78,9 @@ else:
     type From[T] = T
 
     def field(**kwargs):
+        if (default := kwargs.get("default")) is Ellipsis:
+            kwargs["default"] = UNSET
+
         kwargs.pop("converter", None)
         return _field(**kwargs)
 
@@ -108,14 +89,50 @@ else:
 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
+            class_ = type(self)
+            val = object.__getattribute__(self, name)
+
+            if name not in class_.__struct_fields__:
+                return val
+
+            if (
+                (field_info := class_.get_fields().get(name)) is not None
+                and isinstance(field_info.type, msgspec.inspect.CustomType)
+                and issubclass(field_info.type.cls, Option)
+            ):
+                return Nothing() if val is UNSET else val
+
+            if val is UNSET:
+                raise AttributeError(f"{class_.__name__!r} object has no attribute {name!r}")
+
+            return val
+
+    def __post_init__(self) -> None:
+        for field, value in struct_asdict(self, exclude_unset=False).items():
+            if is_none(value):
+                setattr(self, field, UNSET)
+
+    @recursive_repr()
+    def __repr__(self) -> str:
+        return "{}({})".format(
+            type(self).__name__,
+            ", ".join(
+                f"{f}={val!r}"
+                for f, val in struct_asdict(self, exclude_unset=False, unset_as_nothing=True).items()
+            ),
+        )
+
+    @classmethod
+    def get_fields(cls) -> types.MappingProxyType[str, msgspec.inspect.Field]:
+        if (model_fields := getattr(cls, INSPECTED_MODEL_FIELDS_KEY, None)) is not None:
+            return model_fields
+
+        model_fields = types.MappingProxyType[str, msgspec.inspect.Field](
+            {f.name: f for f in msgspec.inspect.type_info(cls).fields},  # type: ignore
+        )
+        setattr(cls, INSPECTED_MODEL_FIELDS_KEY, model_fields)
+        return model_fields
 
     @classmethod
     def from_data[**P, T](cls: typing.Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
@@ -137,7 +154,7 @@ class Model(msgspec.Struct, **MODEL_CONFIG):
     ) -> dict[str, typing.Any]:
         if dct_name not in self.__dict__:
             self.__dict__[dct_name] = (
-                struct_as_dict(self)
+                struct_asdict(self)
                 if not full
                 else encoder.to_builtins(self.to_dict(exclude_fields=exclude_fields), order="deterministic")
             )
@@ -155,9 +172,6 @@ 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.
-        :return: A dictionary representation of this model.
-        """
         return self._to_dict("model_as_dict", exclude_fields or set(), full=False)
 
     def to_full_dict(
@@ -165,49 +179,7 @@ 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.
-        :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)
 
 
-class Proxy[T]:
-    def __init__(self, cfg: "_ProxiedDict[T]", key: str) -> None:
-        self.key = key
-        self.cfg = cfg
-
-    def get(self) -> typing.Any | None:
-        return self.cfg._defaults.get(self.key)
-
-
-class _ProxiedDict[T]:
-    def __init__(self, tp: type[T]) -> None:
-        self.type = tp
-        self._defaults = {}
-
-    def __setattribute__(self, name: str, value: typing.Any, /) -> None:
-        self._defaults[name] = value
-
-    def __getitem__(self, key: str, /) -> None:
-        return Proxy(self, key)  # type: ignore
-
-    def __setitem__(self, key: str, value: typing.Any, /) -> None:
-        self._defaults[key] = value
-
-
-if typing.TYPE_CHECKING:
-
-    def ProxiedDict[T](typed_dct: type[T]) -> T | _ProxiedDict[T]:  # noqa: N802
-        ...
-else:
-    ProxiedDict = _ProxiedDict
-
-
-__all__ = (
-    "MODEL_CONFIG",
-    "Model",
-    "ProxiedDict",
-    "Proxy",
-    "full_result",
-    "get_params",
-)
+__all__ = ("MODEL_CONFIG", "UNSET", "Model", "field", "is_none")