telegrinder 0.1.dev169__py3-none-any.whl → 0.1.dev171__py3-none-any.whl

telegrinder/api/abc.py

@@ -1,6 +1,7 @@
 import pathlib
 import typing
 from abc import ABC, abstractmethod
+from functools import cached_property
 
 import msgspec
 from envparse import env
@@ -33,7 +34,7 @@ class Token(str):
             env.read_envfile(path_to_envfile)
         return cls(env.str(var_name))
 
-    @property
+    @cached_property
     def bot_id(self) -> int:
         return int(self.split(":")[0])
 
@@ -64,6 +65,11 @@ class ABCAPI(ABC):
     def request_url(self) -> str:
         pass
 
+    @property
+    @abstractmethod
+    def request_file_url(self) -> str:
+        pass
+
     @property
     @abstractmethod
     def id(self) -> int:

telegrinder/api/api.py

@@ -1,4 +1,5 @@
 import typing
+from functools import cached_property
 
 import msgspec
 from fntypes.result import Error, Ok, Result
@@ -16,7 +17,7 @@ def compose_data(
     data: dict[str, typing.Any],
     files: dict[str, tuple[str, bytes]],
 ) -> typing.Any:
-    converter = DataConverter(files=files.copy())
+    converter = DataConverter(_files=files.copy())
     return client.get_form(
         data={k: converter(v) for k, v in data.items()},
         files=converter.files,
@@ -24,9 +25,10 @@ def compose_data(
 
 
 class API(ABCAPI, APIMethods):
-    """Bot API with available API methods."""
+    """Bot API with available API methods and http client."""
 
     API_URL = "https://api.telegram.org/"
+    API_FILE_URL = "https://api.telegram.org/file/"
 
     def __init__(self, token: Token, *, http: ABCClient | None = None) -> None:
         self.token = token
@@ -40,7 +42,7 @@ class API(ABCAPI, APIMethods):
             self.http,
         )
 
-    @property
+    @cached_property
     def id(self) -> int:
         return self.token.bot_id
 
@@ -48,6 +50,13 @@ class API(ABCAPI, APIMethods):
     def request_url(self) -> str:
         return self.API_URL + f"bot{self.token}/"
 
+    @property
+    def request_file_url(self) -> str:
+        return self.API_FILE_URL + f"bot{self.token}/"
+
+    async def download_file(self, file_path: str) -> bytes:
+        return await self.http.request_content(f"{self.request_file_url}/{file_path}")
+
     async def request(
         self,
         method: str,

telegrinder/api/error.py

@@ -9,7 +9,8 @@ class APIError(BaseException):
         return f"<APIError: {self.__str__()}>"
 
 
-class InvalidTokenError(BaseException): ...
+class InvalidTokenError(BaseException):
+    pass
 
 
 __all__ = ("APIError", "InvalidTokenError")

telegrinder/bot/bot.py

@@ -43,7 +43,12 @@ class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
             return
         await self.api.delete_webhook()
 
-    async def run_polling(self, *, offset: int = 0, skip_updates: bool = False) -> None:
+    async def run_polling(
+        self,
+        *,
+        offset: int = 0,
+        skip_updates: bool = False,
+    ) -> None:
         if skip_updates:
             logger.debug("Dropping pending updates")
             await self.reset_webhook()

telegrinder/bot/cute_types/base.py

@@ -3,6 +3,7 @@ import inspect
 import typing
 from functools import wraps
 
+import typing_extensions
 from fntypes.result import Result
 
 from telegrinder.api import ABCAPI, API
@@ -10,7 +11,8 @@ from telegrinder.model import Model, get_params
 
 F = typing.TypeVar("F", bound=typing.Callable[..., typing.Any])
 Cute = typing.TypeVar("Cute", bound="BaseCute")
-Update = typing.TypeVar("Update", bound=Model)
+Update = typing_extensions.TypeVar("Update", bound=Model)
+CtxAPI = typing_extensions.TypeVar("CtxAPI", bound=ABCAPI, default=API)
 
 Executor: typing.TypeAlias = typing.Callable[
     [Cute, str, dict[str, typing.Any]],
@@ -19,31 +21,149 @@ Executor: typing.TypeAlias = typing.Callable[
 
 if typing.TYPE_CHECKING:
 
-    class BaseCute(Model, typing.Generic[Update]):
+    class BaseCute(Model, typing.Generic[Update, CtxAPI]):
         api: ABCAPI
 
         @classmethod
         def from_update(cls, update: Update, bound_api: ABCAPI) -> typing.Self: ...
 
         @property
-        def ctx_api(self) -> API: ...
+        def ctx_api(self) -> CtxAPI: ...
+
+        def to_dict(
+            self,
+            *,
+            exclude_fields: set[str] | None = None,
+        ) -> dict[str, typing.Any]:
+            """
+            :param exclude_fields: Cute model field names to exclude from the dictionary representation of this cute model.
+            :return: A dictionary representation of this cute model.
+            """
+
+            ...
+
+        def to_full_dict(
+            self,
+            *,
+            exclude_fields: set[str] | None = None,
+        ) -> dict[str, typing.Any]:
+            """
+            :param exclude_fields: Cute model field names to exclude from the dictionary representation of this cute model.
+            :return: A dictionary representation of this model including all models, structs, custom types.
+            """
+
+            ...
 
 else:
+    from fntypes.co import Nothing, Some, Variative
+    from msgspec._utils import get_class_annotations as _get_class_annotations
+
+    from telegrinder.msgspec_utils import Option, decoder
+
+    _DEFAULT_API_CLASS = API
+
+    def _get_ctx_api_class(cute_class):
+        if hasattr(cute_class, "__ctx_api_class__"):
+            return cute_class.__ctx_api_class__
+
+        ctx_api_class = _DEFAULT_API_CLASS
+        for base in cute_class.__dict__.get("__orig_bases__", ()):
+            if ctx_api_class is not _DEFAULT_API_CLASS:
+                break
+            if issubclass(typing.get_origin(base) or base, BaseCute):
+                for generic_type in typing.get_args(base):
+                    if issubclass(typing.get_origin(generic_type) or generic_type, ABCAPI):
+                        ctx_api_class = generic_type
+                        break
+
+        cute_class.__ctx_api_class__ = ctx_api_class
+        return ctx_api_class
+
+    def _get_cute_from_args(args):
+        for hint in args:
+            if not isinstance(hint, type):
+                hint = typing.get_origin(hint) or hint
+                if not isinstance(hint, type):
+                    continue
+
+            if hint is Variative or issubclass(hint, Option) or issubclass(hint, Some | Nothing):
+                return _get_cute_from_args(typing.get_args(hint))
+
+            if issubclass(hint, BaseCute):
+                return hint
+
+        return None
+
+    def _get_cute_annotations(annotations):
+        cute_annotations = {}
+
+        for key, hint in annotations.items():
+            if not isinstance(hint, type):
+                if (val := _get_cute_from_args(typing.get_args(hint))) is not None:
+                    cute_annotations[key] = val
+
+            elif issubclass(hint, BaseCute):
+                cute_annotations[key] = hint
+
+        return cute_annotations
+
+    def _get_value(value):
+        while isinstance(value, Variative | Some):
+            if isinstance(value, Variative):
+                value = value.v
+            if isinstance(value, Some):
+                value = value.value
+        return value
+
+    class BaseCute(typing.Generic[Update, CtxAPI]):
+        def __init_subclass__(cls, *args, **kwargs):
+            super().__init_subclass__(*args, **kwargs)
+
+            if not cls.__bases__ or not issubclass(cls.__bases__[0], BaseCute):
+                return
+
+            cls.__is_solved_annotations__ = False
+            cls.__cute_annotations__ = None
 
-    class BaseCute(typing.Generic[Update]):
         @classmethod
         def from_update(cls, update, bound_api):
-            return cls(**update.to_dict(), api=bound_api)
+            if not cls.__is_solved_annotations__:
+                cls.__is_solved_annotations__ = True
+                cls.__annotations__ = _get_class_annotations(cls)
+
+            if cls.__cute_annotations__ is None:
+                cls.__cute_annotations__ = _get_cute_annotations(cls.__annotations__)
+
+            return cls(
+                **{
+                    field: decoder.convert(
+                        cls.__cute_annotations__[field].from_update(_get_value(value), bound_api=bound_api),
+                        type=cls.__annotations__[field],
+                    )
+                    if field in cls.__cute_annotations__ and value
+                    else value
+                    for field, value in update.to_dict().items()
+                },
+                api=bound_api,
+            )
 
         @property
         def ctx_api(self):
-            assert isinstance(self.api, API)
+            ctx_api_class = _get_ctx_api_class(self.__class__)
+            assert isinstance(
+                self.api,
+                ctx_api_class,
+            ), f"Bound API of type {self.api.__class__.__name__!r} is incompatible with {ctx_api_class.__name__!r}."
             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 to_full_dict(self, *, exclude_fields=None):
+            exclude_fields = exclude_fields or set()
+            return super().to_full_dict(exclude_fields={"api"} | exclude_fields)
+
 
 def compose_method_params(
     params: dict[str, typing.Any],
@@ -57,12 +177,12 @@ def compose_method_params(
     :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`.
+    (`str`) - Attribute name to be get from `update` if param is undefined. \
+    (`tuple[str, str]`): tuple[0] - Parameter name to be set in `params`, \
+    tuple[1] - attribute name to be get 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.
+    parameter will be set, otherwise will not.
     :return: Composed params.
     """
 
@@ -79,8 +199,6 @@ def compose_method_params(
     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,
     *,
@@ -96,7 +214,15 @@ def shortcut(
         ) -> 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"}
+
+            if not hasattr(func, "_signature_params"):
+                setattr(
+                    func,
+                    "_signature_params",
+                    {k: p for k, p in inspect.signature(func).parameters.items() if k != "self"},
+                )
+
+            signature_params: dict[str, inspect.Parameter] = getattr(func, "_signature_params")
             params: dict[str, typing.Any] = {}
             index = 0
 
@@ -105,9 +231,11 @@ def shortcut(
                     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))
@@ -122,12 +250,11 @@ def shortcut(
     return wrapper
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True, frozen=True)
 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())
+    executor: Executor | None = dataclasses.field(default=None, kw_only=True)
+    custom_params: set[str] = dataclasses.field(default_factory=lambda: set(), kw_only=True)
 
 
 __all__ = ("BaseCute", "Shortcut", "compose_method_params", "shortcut")

telegrinder/bot/cute_types/callback_query.py

@@ -7,9 +7,10 @@ from fntypes.co import Nothing, Result, Some, Variative, unwrapping
 from telegrinder.api import ABCAPI, APIError
 from telegrinder.model import get_params
 from telegrinder.msgspec_utils import Option, decoder
-from telegrinder.types import (
+from telegrinder.types.objects import (
     CallbackQuery,
     Chat,
+    InaccessibleMessage,
     InlineKeyboardMarkup,
     InputFile,
     InputMedia,
@@ -27,6 +28,10 @@ from .message import MediaType, MessageCute, ReplyMarkup, execute_method_edit
 class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True, dict=True):
     api: ABCAPI
 
+    message: Option[Variative[MessageCute, InaccessibleMessage]] = Nothing()
+    """Optional. Message sent by the bot with the callback button that originated
+    the query."""
+
     @property
     def from_user(self) -> User:
         return self.from_

telegrinder/bot/cute_types/chat_member_updated.py

@@ -8,7 +8,6 @@ from telegrinder.model import get_params
 from telegrinder.types.objects import ChatMemberUpdated, ChatPermissions, User
 
 from .base import BaseCute, compose_method_params, shortcut
-from .utils import compose_chat_permissions
 
 
 async def chat_member_interaction(
@@ -17,7 +16,7 @@ async def chat_member_interaction(
     params: dict[str, typing.Any],
 ) -> Result[typing.Any, APIError]:
     if isinstance(params.get("permissions"), dict):
-        params["permissions"] = compose_chat_permissions(**params["permissions"])
+        params["permissions"] = ChatPermissions(**params["permissions"])
     params = compose_method_params(
         get_params(locals()),
         update,

telegrinder/bot/cute_types/message.py

@@ -2,15 +2,17 @@ from __future__ import annotations
 
 import typing
 
-from fntypes.co import Option, Result, Some, Variative
+import fntypes.option
+from fntypes.co import Result, Some, Variative
 
 from telegrinder.api import ABCAPI, APIError
 from telegrinder.model import get_params
-from telegrinder.msgspec_utils import Nothing
-from telegrinder.types import (
+from telegrinder.msgspec_utils import Nothing, Option
+from telegrinder.types.objects import (
     ChatAction,
     DiceEmoji,
     ForceReply,
+    InaccessibleMessage,
     InlineKeyboardMarkup,
     InputFile,
     InputMedia,
@@ -127,7 +129,7 @@ async def execute_method_edit(
 
     result = await getattr(update.ctx_api, method_name)(**params)
     return result.map(
-        lambda v: Variative["MessageCute", bool](
+        lambda v: Variative[MessageCute, bool](
             v.only()
             .map(
                 lambda x: MessageCute.from_update(x, bound_api=update.api),
@@ -139,9 +141,9 @@ async def execute_method_edit(
 
 def get_entity_value(
     entity_value: typing.Literal["user", "url", "custom_emoji_id", "language"],
-    entities: Option[list[MessageEntity]] = Nothing,
-    caption_entities: Option[list[MessageEntity]] = Nothing,
-) -> Option[typing.Any]:
+    entities: fntypes.option.Option[list[MessageEntity]] = Nothing,
+    caption_entities: fntypes.option.Option[list[MessageEntity]] = Nothing,
+) -> fntypes.option.Option[typing.Any]:
     ents = entities.unwrap_or(caption_entities.unwrap_or_none())
     if not ents:
         return Nothing
@@ -154,26 +156,36 @@ def get_entity_value(
 class MessageCute(BaseCute[Message], Message, kw_only=True):
     api: ABCAPI
 
+    reply_to_message: Option[MessageCute] = Nothing
+    """Optional. For replies in the same chat and message thread, the original
+    message. Note that the Message object in this field will not contain further
+    reply_to_message fields even if it itself is a reply."""
+
+    pinned_message: Option[Variative[MessageCute, InaccessibleMessage]] = Nothing
+    """Optional. Specified message was pinned. Note that the Message object in
+    this field will not contain further reply_to_message fields even if it
+    itself is a reply."""
+
     @property
-    def mentioned_user(self) -> Option[User]:
+    def mentioned_user(self) -> fntypes.option.Option[User]:
         """Mentioned user without username."""
 
         return get_entity_value("user", self.entities, self.caption_entities)
 
     @property
-    def url(self) -> Option[str]:
+    def url(self) -> fntypes.option.Option[str]:
         """Clickable text URL."""
 
         return get_entity_value("url", self.entities, self.caption_entities)
 
     @property
-    def programming_language(self) -> Option[str]:
+    def programming_language(self) -> fntypes.option.Option[str]:
         """The programming language of the entity text."""
 
         return get_entity_value("language", self.entities, self.caption_entities)
 
     @property
-    def custom_emoji_id(self) -> Option[str]:
+    def custom_emoji_id(self) -> fntypes.option.Option[str]:
         """Unique identifier of the custom emoji."""
 
         return get_entity_value("custom_emoji_id", self.entities, self.caption_entities)

telegrinder/bot/cute_types/update.py

@@ -7,6 +7,11 @@ from telegrinder.msgspec_utils import Option
 from telegrinder.types import Model, Update
 
 from .base import BaseCute
+from .callback_query import CallbackQueryCute
+from .chat_join_request import ChatJoinRequestCute
+from .chat_member_updated import ChatMemberUpdatedCute
+from .inline_query import InlineQueryCute
+from .message import MessageCute
 
 ModelT = typing.TypeVar("ModelT", bound=Model)
 
@@ -14,6 +19,49 @@ ModelT = typing.TypeVar("ModelT", bound=Model)
 class UpdateCute(BaseCute[Update], Update, kw_only=True):
     api: ABCAPI
 
+    message: Option[MessageCute] = Nothing()
+    """Optional. New incoming message of any kind - text, photo, sticker, etc."""
+
+    edited_message: Option[MessageCute] = Nothing()
+    """Optional. New version of a message that is known to the bot and was edited.
+    This update may at times be triggered by changes to message fields that are
+    either unavailable or not actively used by your bot."""
+
+    channel_post: Option[MessageCute] = Nothing()
+    """Optional. New incoming channel post of any kind - text, photo, sticker,
+    etc."""
+
+    edited_channel_post: Option[MessageCute] = Nothing()
+    """Optional. New version of a channel post that is known to the bot and was edited.
+    This update may at times be triggered by changes to message fields that are
+    either unavailable or not actively used by your bot."""
+
+    business_message: Option[MessageCute] = Nothing()
+    """Optional. New message from a connected business account."""
+
+    edited_business_message: Option[MessageCute] = Nothing()
+    """Optional. New version of a message from a connected business account."""
+
+    inline_query: Option[InlineQueryCute] = Nothing()
+    """Optional. New incoming inline query."""
+
+    callback_query: Option[CallbackQueryCute] = Nothing()
+    """Optional. New incoming callback query."""
+
+    my_chat_member: Option[ChatMemberUpdatedCute] = Nothing()
+    """Optional. The bot's chat member status was updated in a chat. For private
+    chats, this update is received only when the bot is blocked or unblocked
+    by the user."""
+
+    chat_member: Option[ChatMemberUpdatedCute] = Nothing()
+    """Optional. A chat member's status was updated in a chat. The bot must be an
+    administrator in the chat and must explicitly specify `chat_member` in
+    the list of allowed_updates to receive these updates."""
+
+    chat_join_request: Option[ChatJoinRequestCute] = Nothing()
+    """Optional. A request to join the chat has been sent. The bot must have the can_invite_users
+    administrator right in the chat to receive these updates."""
+
     @property
     def incoming_update(self) -> Model:
         return getattr(self, self.update_type.value).unwrap()