telegrinder 0.1.dev165__py3-none-any.whl → 0.1.dev166__py3-none-any.whl

telegrinder/__init__.py

@@ -52,6 +52,10 @@ from .bot import (
     CallbackQueryCute,
     CallbackQueryReturnManager,
     CallbackQueryView,
+    ChatJoinRequestCute,
+    ChatJoinRequestView,
+    ChatMemberUpdatedCute,
+    ChatMemberView,
     Checkbox,
     Dispatch,
     FuncHandler,
@@ -63,8 +67,12 @@ from .bot import (
     MessageRule,
     MessageView,
     Polling,
+    RawEventView,
+    ShortState,
+    ShortStateStorage,
     SingleChoice,
     Telegrinder,
+    UpdateCute,
     ViewBox,
     WaiterMachine,
     register_manager,
@@ -102,7 +110,10 @@ from .tools import (
     magic_bundle,
 )
 
+Update: typing.TypeAlias = UpdateCute
 Message: typing.TypeAlias = MessageCute
+ChatJoinRequest: typing.TypeAlias = ChatJoinRequestCute
+ChatMemberUpdated: typing.TypeAlias = ChatMemberUpdatedCute
 CallbackQuery: typing.TypeAlias = CallbackQueryCute
 InlineQuery: typing.TypeAlias = InlineQueryCute
 Bot: typing.TypeAlias = Telegrinder
@@ -140,6 +151,12 @@ __all__ = (
     "CallbackQueryCute",
     "CallbackQueryReturnManager",
     "CallbackQueryView",
+    "ChatJoinRequest",
+    "ChatJoinRequestCute",
+    "ChatJoinRequestView",
+    "ChatMemberUpdated",
+    "ChatMemberUpdatedCute",
+    "ChatMemberView",
     "Checkbox",
     "CtxVar",
     "DelayedTask",
@@ -169,12 +186,17 @@ __all__ = (
     "Model",
     "ParseMode",
     "Polling",
+    "RawEventView",
     "RowButtons",
+    "ShortState",
+    "ShortStateStorage",
     "SimpleI18n",
     "SimpleTranslator",
     "SingleChoice",
     "Telegrinder",
     "Token",
+    "Update",
+    "UpdateCute",
     "ViewBox",
     "WaiterMachine",
     "ctx_var",

telegrinder/api/abc.py

@@ -17,7 +17,7 @@ class Token(str):
         if token.count(":") != 1 or not token.split(":")[0].isdigit():
             raise InvalidTokenError("Invalid token, it should look like this '123:ABC'.")
         return super().__new__(cls, token)
-    
+
     def __repr__(self) -> str:
         return f"<Token: {self.bot_id}:{''.join(self.split(':')[-1])[:6]}...>"
 

telegrinder/api/api.py

@@ -32,7 +32,7 @@ class API(ABCAPI, APIMethods):
         self.token = token
         self.http = http or AiohttpClient()
         super().__init__(self)
-    
+
     def __repr__(self) -> str:
         return "<{}: token={!r}, http={!r}>".format(
             self.__class__.__name__,
@@ -56,15 +56,17 @@ class API(ABCAPI, APIMethods):
     ) -> 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 {}, files or {})
+            data=compose_data(self.http, data or {}, files or {}),
         )
         if response.get("ok"):
             assert "result" in response
             return Ok(response["result"])
-        return Error(APIError(
-            code=response.get("error_code", 400),
-            error=response.get("description"),
-        ))
+        return Error(
+            APIError(
+                code=response.get("error_code", 400),
+                error=response.get("description"),
+            )
+        )
 
     async def request_raw(
         self,

telegrinder/api/error.py

@@ -1,7 +1,7 @@
 class APIError(BaseException):
     def __init__(self, code: int, error: str | None = None) -> None:
         self.code, self.error = code, error
-    
+
     def __str__(self) -> str:
         return f"[{self.code}] {self.error or 'Something went wrong'}"
 
@@ -9,8 +9,7 @@ class APIError(BaseException):
         return f"<APIError: {self.__str__()}>"
 
 
-class InvalidTokenError(BaseException):
-    ...
+class InvalidTokenError(BaseException): ...
 
 
 __all__ = ("APIError", "InvalidTokenError")

telegrinder/bot/__init__.py

@@ -2,6 +2,8 @@ from .bot import Telegrinder
 from .cute_types import (
     BaseCute,
     CallbackQueryCute,
+    ChatJoinRequestCute,
+    ChatMemberUpdatedCute,
     InlineQueryCute,
     MessageCute,
     UpdateCute,
@@ -18,6 +20,8 @@ from .dispatch import (
     BaseView,
     CallbackQueryReturnManager,
     CallbackQueryView,
+    ChatJoinRequestView,
+    ChatMemberView,
     CompositionDispatch,
     Context,
     Dispatch,
@@ -27,6 +31,9 @@ from .dispatch import (
     MessageReplyHandler,
     MessageReturnManager,
     MessageView,
+    RawEventView,
+    ShortState,
+    ShortStateStorage,
     ViewBox,
     WaiterMachine,
     register_manager,
@@ -53,6 +60,10 @@ __all__ = (
     "CallbackQueryReturnManager",
     "CallbackQueryRule",
     "CallbackQueryView",
+    "ChatJoinRequestCute",
+    "ChatJoinRequestView",
+    "ChatMemberUpdatedCute",
+    "ChatMemberView",
     "Checkbox",
     "CompositionDispatch",
     "Context",
@@ -67,6 +78,9 @@ __all__ = (
     "MessageRule",
     "MessageView",
     "Polling",
+    "RawEventView",
+    "ShortState",
+    "ShortStateStorage",
     "SingleChoice",
     "Telegrinder",
     "UpdateCute",

telegrinder/bot/bot.py

@@ -11,7 +11,7 @@ PollingT = typing.TypeVar("PollingT", bound=ABCPolling, default=Polling)
 LoopWrapperT = typing.TypeVar("LoopWrapperT", bound=ABCLoopWrapper, default=LoopWrapper)
 
 
-class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):    
+class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
     def __init__(
         self,
         api: API,
@@ -24,7 +24,7 @@ class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
         self.dispatch = typing.cast(DispatchT, dispatch or Dispatch())
         self.polling = typing.cast(PollingT, polling or Polling(api))
         self.loop_wrapper = typing.cast(LoopWrapperT, loop_wrapper or LoopWrapper())
-    
+
     def __repr__(self) -> str:
         return "<{}: api={!r}, dispatch={!r}, polling={!r}, loop_wrapper={!r}>".format(
             self.__class__.__name__,
@@ -57,7 +57,9 @@ class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
 
     def run_forever(self, *, offset: int = 0, skip_updates: bool = False) -> None:
         logger.debug("Running blocking polling (id={})", self.api.id)
-        self.loop_wrapper.add_task(self.run_polling(offset=offset, skip_updates=skip_updates))
+        self.loop_wrapper.add_task(
+            self.run_polling(offset=offset, skip_updates=skip_updates)
+        )
         self.loop_wrapper.run_event_loop()
 
 

telegrinder/bot/cute_types/__init__.py

@@ -1,5 +1,7 @@
 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
 from .update import UpdateCute
@@ -7,6 +9,8 @@ from .update import UpdateCute
 __all__ = (
     "BaseCute",
     "CallbackQueryCute",
+    "ChatJoinRequestCute",
+    "ChatMemberUpdatedCute",
     "InlineQueryCute",
     "MessageCute",
     "UpdateCute",

telegrinder/bot/cute_types/base.py

@@ -23,12 +23,10 @@ if typing.TYPE_CHECKING:
         api: ABCAPI
 
         @classmethod
-        def from_update(cls, update: UpdateT, bound_api: ABCAPI) -> typing.Self:
-            ...
+        def from_update(cls, update: UpdateT, bound_api: ABCAPI) -> typing.Self: ...
 
         @property
-        def ctx_api(self) -> API:
-            ...
+        def ctx_api(self) -> API: ...
 
 else:
 
@@ -76,7 +74,9 @@ def compose_method_params(
         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])
+            params[param_name] = getattr(
+                update, param if isinstance(param, str) else param[1]
+            )
 
     return params
 
@@ -91,36 +91,45 @@ def shortcut(
 ):
     def wrapper(func: F) -> F:
         @wraps(func)
-        async def inner(self: CuteT, *args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+        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"
+                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:
+                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)
+                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))
-        
+
         inner.__shortcut__ = Shortcut(  # type: ignore
             method_name=method_name,
             executor=executor,
             custom_params=custom_params or set(),
         )
         return inner  # type: ignore
-    
+
     return wrapper
 
 

telegrinder/bot/cute_types/chat_join_request.py

@@ -0,0 +1,63 @@
+import typing
+
+from fntypes.result import Result
+
+from telegrinder.api.abc import ABCAPI, APIError
+from telegrinder.types.objects import ChatJoinRequest, User
+
+from .base import BaseCute, shortcut
+from .chat_member_updated import ChatMemberShortcuts, chat_member_interaction
+
+
+class ChatJoinRequestCute(BaseCute[ChatJoinRequest], ChatJoinRequest, ChatMemberShortcuts, kw_only=True):
+    api: ABCAPI
+
+    @property
+    def from_user(self) -> User:
+        return self.from_
+
+    @property
+    def user_id(self) -> int:
+        return self.from_user.id
+
+    @shortcut("approve_chat_join_request", executor=chat_member_interaction)
+    async def approve(
+        self,
+        chat_id: int | str | None = None,
+        user_id: int | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.approve_chat_join_request()`, see the [documentation](https://core.telegram.org/bots/api#approvechatjoinrequest)
+
+        Use this method to approve a chat join request. The bot must be an administrator 
+        in the chat for this to work and must have the can_invite_users administrator 
+        right. Returns True on success.
+
+        :param chat_id: Unique identifier for the target chat or username of the target channel \
+        (in the format @channelusername).
+
+        :param user_id: Unique identifier of the target user.
+        """
+
+        ...
+
+    @shortcut("decline_chat_join_request", executor=chat_member_interaction)
+    async def decline(
+        self,
+        chat_id: int | str | None = None,
+        user_id: int | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.decline_chat_join_request()`, see the [documentation](https://core.telegram.org/bots/api#declinechatjoinrequest)
+
+        Use this method to decline a chat join request. The bot must be an administrator 
+        in the chat for this to work and must have the can_invite_users administrator 
+        right. Returns True on success.
+
+        :param chat_id: Unique identifier for the target chat or username of the target channel \
+        (in the format @channelusername).
+
+        :param user_id: Unique identifier of the target user.
+        """
+
+        ...

telegrinder/bot/cute_types/chat_member_updated.py

@@ -0,0 +1,244 @@
+import typing
+from datetime import datetime
+
+from fntypes.result import Result
+
+from telegrinder.api import ABCAPI, APIError
+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(
+    update: BaseCute[typing.Any],
+    method_name: str,
+    params: dict[str, typing.Any],
+) -> Result[typing.Any, APIError]:
+    if isinstance(params.get("permissions"), dict):
+        params["permissions"] = compose_chat_permissions(**params["permissions"])
+    params = compose_method_params(
+        get_params(locals()),
+        update,
+        default_params={"chat_id", "user_id"},
+    )
+    return await getattr(update.ctx_api, method_name)(**params)
+
+
+class ChatMemberShortcuts:
+    """Shortcut methods for `ChatMemberUpdatedCute`, `ChatJoinRequestCute` objects."""
+
+    @shortcut("ban_chat_member", executor=chat_member_interaction)
+    async def ban_chat_member(
+        self,
+        chat_id: int | str | None = None,
+        user_id: int | None = None,
+        until_date: datetime | int | None = None,
+        revoke_messages: bool | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.ban_chat_member()`, see the [documentation](https://core.telegram.org/bots/api#banchatmember)
+
+        Use this method to ban a user in a group, a supergroup or a channel. In the case 
+        of supergroups and channels, the user will not be able to return to the chat 
+        on their own using invite links, etc., unless unbanned first. The bot must 
+        be an administrator in the chat for this to work and must have the appropriate 
+        administrator rights. Returns True on success.
+
+        :param chat_id: Unique identifier for the target group or username of the target supergroup \
+        or channel (in the format @channelusername).
+
+        :param user_id: Unique identifier of the target user.
+
+        :param until_date: Date when the user will be unbanned; Unix time. If user is banned for more \
+        than 366 days or less than 30 seconds from the current time they are considered \
+        to be banned forever. Applied for supergroups and channels only.
+
+        :param revoke_messages: Pass True to delete all messages from the chat for the user that is being removed. \
+        If False, the user will be able to see messages in the group that were sent \
+        before the user was removed. Always True for supergroups and channels. \
+        """
+
+        ...
+
+    @shortcut("unban_chat_member", executor=chat_member_interaction)
+    async def unban_chat_member(
+        self,
+        chat_id: int | str | None = None,
+        user_id: int | None = None,
+        only_if_banned: bool | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.unban_chat_member()`, see the [documentation](https://core.telegram.org/bots/api#unbanchatmember)
+
+        Use this method to unban a previously banned user in a supergroup or channel. 
+        The user will not return to the group or channel automatically, but will 
+        be able to join via link, etc. The bot must be an administrator for this to 
+        work. By default, this method guarantees that after the call the user is 
+        not a member of the chat, but will be able to join it. So if the user is a member 
+        of the chat they will also be removed from the chat. If you don't want this, 
+        use the parameter only_if_banned. Returns True on success.
+
+        :param chat_id: Unique identifier for the target group or username of the target supergroup \
+        or channel (in the format @channelusername).
+
+        :param user_id: Unique identifier of the target user.
+
+        :param only_if_banned: Do nothing if the user is not banned.
+        """
+
+        ...
+
+    @shortcut(
+        "restrict_chat_member",
+        executor=chat_member_interaction,
+        custom_params={"permissions"},
+    )
+    async def restrict_chat_member(
+        self,
+        permissions: ChatPermissions | dict[str, typing.Any],
+        chat_id: int | str | None = None,
+        user_id: int | None = None,
+        use_independent_chat_permissions: bool | None = None,
+        until_date: datetime | int | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.restrict_chat_member()`, see the [documentation](https://core.telegram.org/bots/api#restrictchatmember)
+
+        Use this method to restrict a user in a supergroup. The bot must be an administrator 
+        in the supergroup for this to work and must have the appropriate administrator 
+        rights. Pass True for all permissions to lift restrictions from a user. 
+        Returns True on success.
+
+        :param chat_id: Unique identifier for the target chat or username of the target supergroup \
+        (in the format @supergroupusername).
+
+        :param user_id: Unique identifier of the target user.
+
+        :param permissions: A JSON-serialized object for new user permissions.
+
+        :param use_independent_chat_permissions: Pass True if chat permissions are set independently. Otherwise, the can_send_other_messages \
+        and can_add_web_page_previews permissions will imply the can_send_messages, \
+        can_send_audios, can_send_documents, can_send_photos, can_send_videos, \
+        can_send_video_notes, and can_send_voice_notes permissions; the can_send_polls \
+        permission will imply the can_send_messages permission.
+
+        :param until_date: Date when restrictions will be lifted for the user; Unix time. If user is \
+        restricted for more than 366 days or less than 30 seconds from the current \
+        time, they are considered to be restricted forever.
+        """
+
+        ...
+
+    @shortcut("promote_chat_member", executor=chat_member_interaction)
+    async def promote_chat_member(
+        self,
+        chat_id: int | str | None = None,
+        user_id: int | None = None,
+        is_anonymous: bool | None = None,
+        can_manage_chat: bool | None = None,
+        can_delete_messages: bool | None = None,
+        can_manage_video_chats: bool | None = None,
+        can_restrict_members: bool | None = None,
+        can_promote_members: bool | None = None,
+        can_change_info: bool | None = None,
+        can_invite_users: bool | None = None,
+        can_post_stories: bool | None = None,
+        can_edit_stories: bool | None = None,
+        can_delete_stories: bool | None = None,
+        can_post_messages: bool | None = None,
+        can_edit_messages: bool | None = None,
+        can_pin_messages: bool | None = None,
+        can_manage_topics: bool | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.promote_chat_member()`, see the [documentation](https://core.telegram.org/bots/api#promotechatmember)
+
+        Use this method to promote or demote a user in a supergroup or a channel. The 
+        bot must be an administrator in the chat for this to work and must have the 
+        appropriate administrator rights. Pass False for all boolean parameters 
+        to demote a user. Returns True on success.
+
+        :param chat_id: Unique identifier for the target chat or username of the target channel \
+        (in the format @channelusername).
+
+        :param user_id: Unique identifier of the target user.
+
+        :param is_anonymous: Pass True if the administrator's presence in the chat is hidden.
+
+        :param can_manage_chat: Pass True if the administrator can access the chat event log, get boost list, \
+        see hidden supergroup and channel members, report spam messages and ignore \
+        slow mode. Implied by any other administrator privilege.
+
+        :param can_delete_messages: Pass True if the administrator can delete messages of other users.
+
+        :param can_manage_video_chats: Pass True if the administrator can manage video chats.
+
+        :param can_restrict_members: Pass True if the administrator can restrict, ban or unban chat members, \
+        or access supergroup statistics.
+
+        :param can_promote_members: Pass True if the administrator can add new administrators with a subset \
+        of their own privileges or demote administrators that they have promoted, \
+        directly or indirectly (promoted by administrators that were appointed \
+        by him).
+
+        :param can_change_info: Pass True if the administrator can change chat title, photo and other settings. \
+
+        :param can_invite_users: Pass True if the administrator can invite new users to the chat.
+
+        :param can_post_stories: Pass True if the administrator can post stories to the chat.
+
+        :param can_edit_stories: Pass True if the administrator can edit stories posted by other users.
+
+        :param can_delete_stories: Pass True if the administrator can delete stories posted by other users. \
+
+        :param can_post_messages: Pass True if the administrator can post messages in the channel, or access \
+        channel statistics; for channels only.
+
+        :param can_edit_messages: Pass True if the administrator can edit messages of other users and can pin \
+        messages; for channels only.
+
+        :param can_pin_messages: Pass True if the administrator can pin messages; for supergroups only. \
+
+        :param can_manage_topics: Pass True if the user is allowed to create, rename, close, and reopen forum \
+        topics; for supergroups only.
+        """
+
+        ...
+
+    @shortcut("set_chat_administrator_custom_title", executor=chat_member_interaction)
+    async def set_chat_administrator_custom_title(
+        self,
+        custom_title: str,
+        chat_id: int | str | None = None,
+        user_id: int | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.set_chat_administrator_custom_title()`, see the [documentation](https://core.telegram.org/bots/api#setchatadministratorcustomtitle)
+
+        Use this method to set a custom title for an administrator in a supergroup 
+        promoted by the bot. Returns True on success.
+
+        :param chat_id: Unique identifier for the target chat or username of the target supergroup \
+        (in the format @supergroupusername).
+
+        :param user_id: Unique identifier of the target user.
+
+        :param custom_title: New custom title for the administrator; 0-16 characters, emoji are not \
+        allowed.
+        """
+
+        ...
+
+
+class ChatMemberUpdatedCute(BaseCute[ChatMemberUpdated], ChatMemberUpdated, ChatMemberShortcuts, kw_only=True):
+    api: ABCAPI
+
+    @property
+    def from_user(self) -> User:
+        return self.from_
+
+    @property
+    def user_id(self) -> int:
+        return self.from_user.id