telegrinder 0.1.dev158__tar.gz → 0.1.dev159__tar.gz

{telegrinder-0.1.dev158 → telegrinder-0.1.dev159}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telegrinder
-Version: 0.1.dev158
+Version: 0.1.dev159
 Summary: Framework for effective and reliable async telegram bot building.
 Home-page: https://github.com/timoniq/telegrinder
 License: MIT
@@ -14,12 +14,13 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Typing :: Typed
 Requires-Dist: PyYAML (>=6.0,<7.0)
 Requires-Dist: aiohttp (>=3.8.1,<4.0.0)
-Requires-Dist: certifi (>=2022.6.15,<2023.0.0)
+Requires-Dist: certifi (>=2023.7.22,<2024.0.0)
 Requires-Dist: choicelib (>=0.1.5,<0.2.0)
 Requires-Dist: colorama (>=0.4.0,<0.5.0)
 Requires-Dist: envparse (>=0.2.0,<0.3.0)

{telegrinder-0.1.dev158 → telegrinder-0.1.dev159}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "telegrinder"
-version = "0.1.dev158"
+version = "0.1.dev159"
 description = "Framework for effective and reliable async telegram bot building."
 authors = ["timoniq <tesseradecades@mail.ru>"]
 maintainers = ["luwqz1"]
@@ -36,7 +36,7 @@ vbml = "^1.1.post1"
 choicelib = "^0.1.5"
 envparse = "^0.2.0"
 PyYAML = "^6.0"
-certifi = "^2022.6.15"
+certifi = "^2023.7.22"
 msgspec = "^0.18.4"
 requests = "^2.28.1"
 typing-extensions = "^4.8.0"

{telegrinder-0.1.dev158 → telegrinder-0.1.dev159}/telegrinder/api/abc.py

@@ -15,7 +15,7 @@ from .error import InvalidTokenError
 class Token(str):
     def __new__(cls, token: str) -> typing.Self:
         if token.count(":") != 1 or not token.split(":")[0].isdigit():
-            raise InvalidTokenError("Invalid token, it should look like this '123:token'.")
+            raise InvalidTokenError("Invalid token, it should look like this '123:ABC'.")
         return super().__new__(cls, token)
 
     @classmethod
@@ -42,15 +42,15 @@ class ABCAPI(ABC):
     async def request(
         self,
         method: str,
-        data: dict | None = None,
-    ) -> Result[list | dict | bool, APIError]:
+        data: dict[str, typing.Any] | None = None,
+    ) -> Result[list[typing.Any] | dict[str, typing.Any] | bool, APIError]:
         pass
 
     @abstractmethod
     async def request_raw(
         self,
         method: str,
-        data: dict | None = None,
+        data: dict[str, typing.Any] | None = None,
     ) -> Result[msgspec.Raw, APIError]:
         pass
 

{telegrinder-0.1.dev158 → telegrinder-0.1.dev159}/telegrinder/api/api.py

@@ -5,26 +5,38 @@ from fntypes.result import Error, Ok, Result
 
 from telegrinder.api.response import APIResponse
 from telegrinder.client import ABCClient, AiohttpClient
-from telegrinder.model import convert, decoder
+from telegrinder.model import DataConverter, decoder
 from telegrinder.types.methods import APIMethods
 
 from .abc import ABCAPI, APIError, Token
 
 
-def compose_data(client: ABCClient, data: dict[str, typing.Any]) -> typing.Any:
-    data = {k: convert(v) for k, v in data.items()}
-    if any(isinstance(v, tuple) for v in data.values()):
-        data = client.get_form(data)
-    return data
+def compose_data(
+    client: ABCClient,
+    data: dict[str, typing.Any],
+    files: dict[str, tuple[str, bytes]],
+) -> typing.Any:
+    converter = DataConverter(files=files)
+    return client.get_form(
+        data={k: converter.convert(v) for k, v in data.items()},
+        files=converter.files,
+    )
 
 
 class API(ABCAPI, APIMethods):
     API_URL: typing.ClassVar[str] = "https://api.telegram.org/"
 
-    def __init__(self, token: Token, *, http: ABCClient | None = None):
+    def __init__(self, token: Token, *, http: ABCClient | None = None) -> None:
         self.token = token
         self.http = http or AiohttpClient()
         super().__init__(self)
+    
+    def __repr__(self) -> str:
+        return "<{}: id={}, http={!r}>".format(
+            self.__class__.__name__,
+            self.id,
+            self.http,
+        )
 
     @property
     def id(self) -> int:
@@ -37,11 +49,12 @@ class API(ABCAPI, APIMethods):
     async def request(
         self,
         method: str,
-        data: dict | None = None,
-    ) -> Result[dict | list | bool, APIError]:
+        data: dict[str, typing.Any] | None = None,
+        files: dict[str, tuple[str, bytes]] | None = None,
+    ) -> Result[dict[str, typing.Any] | list[typing.Any] | bool, APIError]:
         response = await self.http.request_json(
             url=self.request_url + method,
-            data=compose_data(self.http, data or {})
+            data=compose_data(self.http, data or {}, files or {})
         )
         if response.get("ok"):
             assert "result" in response
@@ -55,10 +68,11 @@ class API(ABCAPI, APIMethods):
         self,
         method: str,
         data: dict[str, typing.Any] | None = None,
+        files: dict[str, tuple[str, bytes]] | None = None,
     ) -> Result[msgspec.Raw, APIError]:
         response_bytes = await self.http.request_bytes(
             url=self.request_url + method,
-            data=compose_data(self.http, data or {}),
+            data=compose_data(self.http, data or {}, files or {}),
         )
         return decoder.decode(response_bytes, type=APIResponse).to_result()
 

telegrinder-0.1.dev159/telegrinder/bot/cute_types/base.py

@@ -0,0 +1,138 @@
+import dataclasses
+import inspect
+import typing
+from functools import wraps
+
+from fntypes.result import Result
+
+from telegrinder.api import ABCAPI, API
+from telegrinder.model import Model, get_params
+
+F = typing.TypeVar("F", bound=typing.Callable[..., typing.Any])
+CuteT = typing.TypeVar("CuteT", bound="BaseCute")
+UpdateT = typing.TypeVar("UpdateT", bound=Model)
+
+Executor: typing.TypeAlias = typing.Callable[
+    [CuteT, str, dict[str, typing.Any]],
+    typing.Awaitable[Result[typing.Any, typing.Any]],
+]
+
+if typing.TYPE_CHECKING:
+
+    class BaseCute(Model, typing.Generic[UpdateT]):
+        api: ABCAPI
+
+        @classmethod
+        def from_update(cls, update: UpdateT, bound_api: ABCAPI) -> typing.Self:
+            ...
+
+        @property
+        def ctx_api(self) -> API:
+            ...
+
+else:
+
+    class BaseCute(typing.Generic[UpdateT]):
+        api: ABCAPI
+
+        @classmethod
+        def from_update(cls, update, bound_api):
+            return cls(**update.to_dict(), api=bound_api)
+
+        @property
+        def ctx_api(self):
+            assert isinstance(self.api, API)
+            return self.api
+
+        def to_dict(self, *, exclude_fields=None):
+            exclude_fields = exclude_fields or set()
+            return super().to_dict(exclude_fields={"api"} | exclude_fields)
+
+
+def compose_method_params(
+    params: dict[str, typing.Any],
+    update: CuteT,
+    *,
+    default_params: set[str | tuple[str, str]] | None = None,
+    validators: dict[str, typing.Callable[[CuteT], bool]] | None = None,
+) -> dict[str, typing.Any]:
+    """Compose method `params` from `update` by `default_params` and `validators`.
+    
+    :param params: Method params.
+    :param update: Update object.
+    :param default_params: Default params. \
+    type (`str`) - Attribute name to be taken from `update` if param undefined. \
+    type (`tuple[str, str]`) - tuple[0] Parameter name to be set in `params`, \
+    tuple[1] attribute name to be taken from `update`.
+    :param validators: Validators mapping (`str, Callable`), key - `Parameter name` \
+    for which the validator will be applied, value - `Validator`, if returned `True` \
+    parameter will be set, otherwise will not be set.
+    :return: Composed params.
+    """
+
+    default_params = default_params or set()
+    validators = validators or {}
+
+    for param in default_params:
+        param_name = param if isinstance(param, str) else param[0]
+        if param_name not in params:
+            if param_name in validators and not validators[param_name](update):
+                continue
+            params[param_name] = getattr(update, param if isinstance(param, str) else param[1])
+
+    return params
+
+
+# NOTE: implement parser on ast for methods decorated this decorator
+# to support updates to the schema Bot API.
+def shortcut(
+    method_name: str,
+    *,
+    executor: Executor[CuteT] | None = None,
+    custom_params: set[str] | None = None,
+):
+    def wrapper(func: F) -> F:
+        @wraps(func)
+        async def inner(self: CuteT, *args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+            if executor is None:
+                return await func(self, *args, **kwargs)
+            signature_params = {
+                k: p
+                for k, p in inspect.signature(func).parameters.items()
+                if k != "self"
+            }
+            params: dict[str, typing.Any] = {}
+            index = 0
+
+            for k, p in signature_params.items():
+                if p.kind in (p.POSITIONAL_OR_KEYWORD, p.POSITIONAL_ONLY) and len(args) > index:
+                    params[k] = args[index]
+                    index += 1
+                    continue
+                if p.kind in (p.VAR_KEYWORD, p.VAR_POSITIONAL):
+                    params[k] = kwargs.copy() if p.kind is p.VAR_KEYWORD else args[index:]
+                    continue
+                params[k] = kwargs.pop(k, p.default) if p.default is not p.empty else kwargs.pop(k)
+
+            return await executor(self, method_name, get_params(params))
+
+        func.__repr__ = lambda _: f"<Shortcut {method_name!r}@{func!r}>"   
+        inner.__shortcut__ = Shortcut(  # type: ignore
+            method_name=method_name,
+            executor=executor,
+            custom_params=custom_params or set(),
+        )
+        return inner  # type: ignore
+    
+    return wrapper
+
+
+@dataclasses.dataclass
+class Shortcut:
+    method_name: str
+    _: dataclasses.KW_ONLY
+    executor: Executor | None = dataclasses.field(default=None)
+    custom_params: set[str] = dataclasses.field(default_factory=lambda: set())
+
+
+__all__ = ("BaseCute", "Shortcut", "compose_method_params", "shortcut")