telegrinder 0.1.dev158__py3-none-any.whl → 0.1.dev160__py3-none-any.whl

telegrinder/__init__.py

@@ -39,6 +39,7 @@ from .client import ABCClient, AiohttpClient
 from .model import Model
 from .modules import logger
 from .tools import (
+    ABCErrorHandler,
     ABCGlobalContext,
     ABCLoopWrapper,
     ABCTranslator,
@@ -47,6 +48,7 @@ from .tools import (
     Button,
     CtxVar,
     DelayedTask,
+    ErrorHandler,
     FormatString,
     GlobalContext,
     HTMLFormatter,
@@ -62,7 +64,6 @@ from .tools import (
     SimpleI18n,
     SimpleTranslator,
     ctx_var,
-    keyboard_remove,
     magic_bundle,
 )
 
@@ -76,6 +77,7 @@ __all__ = (
     "ABCAPI",
     "ABCClient",
     "ABCDispatch",
+    "ABCErrorHandler",
     "ABCGlobalContext",
     "ABCHandler",
     "ABCLoopWrapper",
@@ -107,6 +109,7 @@ __all__ = (
     "CtxVar",
     "DelayedTask",
     "Dispatch",
+    "ErrorHandler",
     "FormatString",
     "FuncHandler",
     "GlobalContext",
@@ -139,7 +142,6 @@ __all__ = (
     "ViewBox",
     "WaiterMachine",
     "ctx_var",
-    "keyboard_remove",
     "logger",
     "magic_bundle",
     "register_manager",

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,17 @@ 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,
+        files: dict[str, tuple[str, bytes]] | 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,
+        files: dict[str, tuple[str, bytes]] | None = None,
     ) -> Result[msgspec.Raw, APIError]:
         pass
 

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(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/bot/cute_types/base.py

@@ -1,10 +1,22 @@
+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
+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]):
@@ -18,13 +30,6 @@ if typing.TYPE_CHECKING:
         def ctx_api(self) -> API:
             ...
 
-        def to_dict(
-            self,
-            *,
-            exclude_fields: set[str] | None = None,
-        ) -> dict[str, typing.Any]:
-            ...
-
 else:
 
     class BaseCute(typing.Generic[UpdateT]):
@@ -44,4 +49,90 @@ else:
             return super().to_dict(exclude_fields={"api"} | exclude_fields)
 
 
-__all__ = ("BaseCute",)
+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")