telegrinder 0.1.dev164__tar.gz → 0.1.dev166__tar.gz

{telegrinder-0.1.dev164 → telegrinder-0.1.dev166}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telegrinder
-Version: 0.1.dev164
+Version: 0.1.dev166
 Summary: Framework for effective and reliable async telegram bot building.
 Home-page: https://github.com/timoniq/telegrinder
 License: MIT

{telegrinder-0.1.dev164 → telegrinder-0.1.dev166}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "telegrinder"
-version = "0.1.dev164"
+version = "0.1.dev166"
 description = "Framework for effective and reliable async telegram bot building."
 authors = ["timoniq <tesseradecades@mail.ru>"]
 maintainers = ["luwqz1 <howluwqz1@gmail.com>"]
@@ -60,8 +60,8 @@ build-backend = "poetry.core.masonry.api"
 [tool.ruff]
 line-length = 100
 target-version = "py311"
-select = ["I", "N", "ANN", "COM", "YTT", "TCH", "SIM"]
-ignore = [
+lint.select = ["I", "N", "ANN", "COM", "YTT", "TCH", "SIM"]
+lint.ignore = [
   "ANN001", "ANN002", "ANN003", "ANN101", "ANN102", "ANN201", "ANN202",
   "ANN204", "ANN206", "ANN401", "COM812", "N818", "TCH001", "TCH004"
 ]
@@ -73,8 +73,8 @@ target-version = ["py311"]
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 
-[tool.ruff.per-file-ignores]
+[tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["F401", "F403"]
 
-[tool.ruff.flake8-quotes]
+[tool.ruff.lint.flake8-quotes]
 docstring-quotes = "double"

{telegrinder-0.1.dev164 → telegrinder-0.1.dev166}/telegrinder/__init__.py

@@ -1,3 +1,37 @@
+"""Telegrinder
+
+Framework for effective and reliable telegram bot building.
+
+* Type hinted
+* Customizable and extensible
+* Ready to use scenarios and rules
+* Fast models built on msgspec
+* Both low-level and high-level API
+
+Basic example:
+
+```python
+from telegrinder import API, Message, Telegrinder, Token
+from telegrinder.modules import logger
+from telegrinder.rules import Text
+
+api = API(token=Token("123:token"))
+bot = Telegrinder(api)
+logger.set_level("INFO")
+
+
+@bot.on.message(Text("/start"))
+async def start(message: Message):
+    me = (await api.get_me()).unwrap()
+    await message.answer(
+        f"Hello, {message.from_user.full_name}! I'm {me.full_name}."
+    )
+
+
+bot.run_forever()
+```
+"""
+
 import typing
 
 from .api import ABCAPI, API, APIError, APIResponse, Token
@@ -18,6 +52,10 @@ from .bot import (
     CallbackQueryCute,
     CallbackQueryReturnManager,
     CallbackQueryView,
+    ChatJoinRequestCute,
+    ChatJoinRequestView,
+    ChatMemberUpdatedCute,
+    ChatMemberView,
     Checkbox,
     Dispatch,
     FuncHandler,
@@ -29,8 +67,12 @@ from .bot import (
     MessageRule,
     MessageView,
     Polling,
+    RawEventView,
+    ShortState,
+    ShortStateStorage,
     SingleChoice,
     Telegrinder,
+    UpdateCute,
     ViewBox,
     WaiterMachine,
     register_manager,
@@ -58,6 +100,7 @@ from .tools import (
     Keyboard,
     KeyboardSetBase,
     KeyboardSetYAML,
+    Lifespan,
     LoopWrapper,
     ParseMode,
     RowButtons,
@@ -67,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
@@ -105,6 +151,12 @@ __all__ = (
     "CallbackQueryCute",
     "CallbackQueryReturnManager",
     "CallbackQueryView",
+    "ChatJoinRequest",
+    "ChatJoinRequestCute",
+    "ChatJoinRequestView",
+    "ChatMemberUpdated",
+    "ChatMemberUpdatedCute",
+    "ChatMemberView",
     "Checkbox",
     "CtxVar",
     "DelayedTask",
@@ -123,6 +175,7 @@ __all__ = (
     "Keyboard",
     "KeyboardSetBase",
     "KeyboardSetYAML",
+    "Lifespan",
     "LoopWrapper",
     "Message",
     "MessageCute",
@@ -133,12 +186,17 @@ __all__ = (
     "Model",
     "ParseMode",
     "Polling",
+    "RawEventView",
     "RowButtons",
+    "ShortState",
+    "ShortStateStorage",
     "SimpleI18n",
     "SimpleTranslator",
     "SingleChoice",
     "Telegrinder",
     "Token",
+    "Update",
+    "UpdateCute",
     "ViewBox",
     "WaiterMachine",
     "ctx_var",

{telegrinder-0.1.dev164 → telegrinder-0.1.dev166}/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-0.1.dev164 → telegrinder-0.1.dev166}/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-0.1.dev164 → telegrinder-0.1.dev166}/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-0.1.dev164 → telegrinder-0.1.dev166}/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-0.1.dev164 → telegrinder-0.1.dev166}/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,
@@ -25,6 +25,15 @@ class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
         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__,
+            self.api,
+            self.dispatch,
+            self.polling,
+            self.loop_wrapper,
+        )
+
     @property
     def on(self) -> DispatchT:
         return self.dispatch
@@ -48,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-0.1.dev164 → telegrinder-0.1.dev166}/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-0.1.dev164 → telegrinder-0.1.dev166}/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-0.1.dev166/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.
+        """
+
+        ...