telegrinder 0.3.4__py3-none-any.whl → 0.3.4.post1__py3-none-any.whl

telegrinder/__init__.py

@@ -1,145 +1,145 @@
-"""Telegrinder
-
-Modern visionary telegram bot framework.
-
-* Type hinted
-* Customizable and extensible
-* Ready to use scenarios and rules
-* Fast models built on [msgspec](https://github.com/jcrist/msgspec)
-* Both low-level and high-level API
-* Support [optional dependecies](https://github.com/timoniq/telegrinder/blob/dev/docs/guide/optional_dependencies.md)
-
-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 API, APIError, APIResponse, Token
-from .bot import (
-    CALLBACK_QUERY_FOR_MESSAGE,
-    CALLBACK_QUERY_FROM_CHAT,
-    CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE,
-    MESSAGE_FROM_USER,
-    MESSAGE_FROM_USER_IN_CHAT,
-    MESSAGE_IN_CHAT,
-    ABCDispatch,
-    ABCHandler,
-    ABCMiddleware,
-    ABCPolling,
-    ABCReturnManager,
-    ABCRule,
-    ABCScenario,
-    ABCStateView,
-    ABCView,
-    AudioReplyHandler,
-    BaseCute,
-    BaseReturnManager,
-    BaseStateView,
-    BaseView,
-    CallbackQueryCute,
-    CallbackQueryReturnManager,
-    CallbackQueryRule,
-    CallbackQueryView,
-    ChatJoinRequestCute,
-    ChatJoinRequestRule,
-    ChatJoinRequestView,
-    ChatMemberUpdatedCute,
-    ChatMemberView,
-    Checkbox,
-    Choice,
-    Context,
-    Dispatch,
-    DocumentReplyHandler,
-    FuncHandler,
-    Hasher,
-    InlineQueryCute,
-    InlineQueryReturnManager,
-    InlineQueryRule,
-    MediaGroupReplyHandler,
-    MessageCute,
-    MessageReplyHandler,
-    MessageReturnManager,
-    MessageRule,
-    MessageView,
-    PhotoReplyHandler,
-    Polling,
-    RawEventView,
-    ShortState,
-    StateViewHasher,
-    StickerReplyHandler,
-    Telegrinder,
-    UpdateCute,
-    VideoReplyHandler,
-    ViewBox,
-    WaiterMachine,
-    register_manager,
-)
-from .bot.rules import StateMeta
-from .client import ABCClient, AiohttpClient
-from .model import Model
-from .modules import logger
-from .tools import (
-    ABCErrorHandler,
-    ABCGlobalContext,
-    ABCLoopWrapper,
-    ABCStateStorage,
-    ABCTranslator,
-    ABCTranslatorMiddleware,
-    AnyMarkup,
-    Button,
-    CtxVar,
-    DelayedTask,
-    ErrorHandler,
-    FormatString,
-    GlobalContext,
-    HTMLFormatter,
-    I18nEnum,
-    InlineButton,
-    InlineKeyboard,
-    Keyboard,
-    KeyboardSetBase,
-    KeyboardSetYAML,
-    Lifespan,
-    LoopWrapper,
-    MemoryStateStorage,
-    ParseMode,
-    RowButtons,
-    SimpleI18n,
-    SimpleTranslator,
-    StateData,
-    ctx_var,
-    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
-
-
-__all__ = (
+"""Telegrinder
+
+Modern visionary telegram bot framework.
+
+* Type hinted
+* Customizable and extensible
+* Ready to use scenarios and rules
+* Fast models built on [msgspec](https://github.com/jcrist/msgspec)
+* Both low-level and high-level API
+* Support [optional dependecies](https://github.com/timoniq/telegrinder/blob/dev/docs/guide/optional_dependencies.md)
+
+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 API, APIError, APIResponse, Token
+from .bot import (
+    CALLBACK_QUERY_FOR_MESSAGE,
+    CALLBACK_QUERY_FROM_CHAT,
+    CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE,
+    MESSAGE_FROM_USER,
+    MESSAGE_FROM_USER_IN_CHAT,
+    MESSAGE_IN_CHAT,
+    ABCDispatch,
+    ABCHandler,
+    ABCMiddleware,
+    ABCPolling,
+    ABCReturnManager,
+    ABCRule,
+    ABCScenario,
+    ABCStateView,
+    ABCView,
+    AudioReplyHandler,
+    BaseCute,
+    BaseReturnManager,
+    BaseStateView,
+    BaseView,
+    CallbackQueryCute,
+    CallbackQueryReturnManager,
+    CallbackQueryRule,
+    CallbackQueryView,
+    ChatJoinRequestCute,
+    ChatJoinRequestRule,
+    ChatJoinRequestView,
+    ChatMemberUpdatedCute,
+    ChatMemberView,
+    Checkbox,
+    Choice,
+    Context,
+    Dispatch,
+    DocumentReplyHandler,
+    FuncHandler,
+    Hasher,
+    InlineQueryCute,
+    InlineQueryReturnManager,
+    InlineQueryRule,
+    MediaGroupReplyHandler,
+    MessageCute,
+    MessageReplyHandler,
+    MessageReturnManager,
+    MessageRule,
+    MessageView,
+    PhotoReplyHandler,
+    Polling,
+    RawEventView,
+    ShortState,
+    StateViewHasher,
+    StickerReplyHandler,
+    Telegrinder,
+    UpdateCute,
+    VideoReplyHandler,
+    ViewBox,
+    WaiterMachine,
+    register_manager,
+)
+from .bot.rules import StateMeta
+from .client import ABCClient, AiohttpClient
+from .model import Model
+from .modules import logger
+from .tools import (
+    ABCErrorHandler,
+    ABCGlobalContext,
+    ABCLoopWrapper,
+    ABCStateStorage,
+    ABCTranslator,
+    ABCTranslatorMiddleware,
+    AnyMarkup,
+    Button,
+    CtxVar,
+    DelayedTask,
+    ErrorHandler,
+    FormatString,
+    GlobalContext,
+    HTMLFormatter,
+    I18nEnum,
+    InlineButton,
+    InlineKeyboard,
+    Keyboard,
+    KeyboardSetBase,
+    KeyboardSetYAML,
+    Lifespan,
+    LoopWrapper,
+    MemoryStateStorage,
+    ParseMode,
+    RowButtons,
+    SimpleI18n,
+    SimpleTranslator,
+    StateData,
+    ctx_var,
+    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
+
+
+__all__ = (
     "ABCClient",
     "ABCDispatch",
     "ABCErrorHandler",
@@ -247,5 +247,5 @@ __all__ = (
     "ctx_var",
     "logger",
     "magic_bundle",
-    "register_manager",
-)
+    "register_manager",
+)

telegrinder/api/__init__.py

@@ -1,12 +1,12 @@
-from .api import API
-from .error import APIError, InvalidTokenError
-from .response import APIResponse
-from .token import Token
-
-__all__ = (
+from .api import API
+from .error import APIError, InvalidTokenError
+from .response import APIResponse
+from .token import Token
+
+__all__ = (
     "API",
     "APIError",
     "APIResponse",
     "InvalidTokenError",
-    "Token",
-)
+    "Token",
+)

telegrinder/api/api.py

@@ -1,93 +1,93 @@
-import typing
-from functools import cached_property
-
-import msgspec
-from fntypes.result import Error, Ok, Result
-
-from telegrinder.api.error import APIError
-from telegrinder.api.response import APIResponse
-from telegrinder.api.token import Token
-from telegrinder.client import ABCClient, AiohttpClient
-from telegrinder.model import DataConverter, decoder
-from telegrinder.types.methods import APIMethods
-
-
-def compose_data(
-    client: ABCClient,
-    data: dict[str, typing.Any],
-    files: dict[str, tuple[str, bytes]],
-) -> typing.Any:
-    converter = DataConverter(_files=files.copy())
-    return client.get_form(
-        data={k: converter(v) for k, v in data.items()},
-        files=converter.files,
-    )
-
-
-class API(APIMethods):
-    """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
-        self.http = http or AiohttpClient()
-        super().__init__(self)
-
-    def __repr__(self) -> str:
-        return "<{}: token={!r}, http={!r}>".format(
-            self.__class__.__name__,
-            self.token,
-            self.http,
-        )
-
-    @cached_property
-    def id(self) -> int:
-        return self.token.bot_id
-
-    @property
-    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,
-        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 {}, 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"),
-            )
-        )
-
-    async def request_raw(
-        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 {}, files or {}),
-        )
-        return decoder.decode(response_bytes, type=APIResponse).to_result()
-
-
-__all__ = ("API",)
+import typing
+from functools import cached_property
+
+import msgspec
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.error import APIError
+from telegrinder.api.response import APIResponse
+from telegrinder.api.token import Token
+from telegrinder.client import ABCClient, AiohttpClient
+from telegrinder.model import DataConverter, decoder
+from telegrinder.types.methods import APIMethods
+
+
+def compose_data(
+    client: ABCClient,
+    data: dict[str, typing.Any],
+    files: dict[str, tuple[str, bytes]],
+) -> typing.Any:
+    converter = DataConverter(_files=files.copy())
+    return client.get_form(
+        data={k: converter(v) for k, v in data.items()},
+        files=converter.files,
+    )
+
+
+class API(APIMethods):
+    """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
+        self.http = http or AiohttpClient()
+        super().__init__(self)
+
+    def __repr__(self) -> str:
+        return "<{}: token={!r}, http={!r}>".format(
+            self.__class__.__name__,
+            self.token,
+            self.http,
+        )
+
+    @cached_property
+    def id(self) -> int:
+        return self.token.bot_id
+
+    @property
+    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,
+        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 {}, 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"),
+            )
+        )
+
+    async def request_raw(
+        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 {}, files or {}),
+        )
+        return decoder.decode(response_bytes, type=APIResponse).to_result()
+
+
+__all__ = ("API",)

telegrinder/api/error.py

@@ -1,16 +1,16 @@
-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'}"
-
-    def __repr__(self) -> str:
-        return f"<APIError: {self.__str__()}>"
-
-
-class InvalidTokenError(BaseException):
-    pass
-
-
-__all__ = ("APIError", "InvalidTokenError")
+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'}"
+
+    def __repr__(self) -> str:
+        return f"<APIError: {self.__str__()}>"
+
+
+class InvalidTokenError(BaseException):
+    pass
+
+
+__all__ = ("APIError", "InvalidTokenError")

telegrinder/api/response.py

@@ -1,20 +1,20 @@
-import msgspec
-from fntypes.result import Error, Ok, Result
-
-from telegrinder.api.error import APIError
-from telegrinder.model import Model
-
-
-class APIResponse(Model):
-    ok: bool = False
-    result: msgspec.Raw = msgspec.Raw(b"")
-    error_code: int = 0
-    description: str = ""
-
-    def to_result(self) -> Result[msgspec.Raw, APIError]:
-        if self.ok:
-            return Ok(self.result)
-        return Error(APIError(self.error_code, self.description))
-
-
-__all__ = ("APIResponse",)
+import msgspec
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.error import APIError
+from telegrinder.model import Model
+
+
+class APIResponse(Model):
+    ok: bool = False
+    result: msgspec.Raw = msgspec.Raw(b"")
+    error_code: int = 0
+    description: str = ""
+
+    def to_result(self) -> Result[msgspec.Raw, APIError]:
+        if self.ok:
+            return Ok(self.result)
+        return Error(APIError(self.error_code, self.description))
+
+
+__all__ = ("APIResponse",)

telegrinder/api/token.py

@@ -1,36 +1,36 @@
-import pathlib
-import typing
-from functools import cached_property
-
-from envparse import env
-
-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:ABC'.")
-        return super().__new__(cls, token)
-
-    def __repr__(self) -> str:
-        return f"<Token: {self.bot_id}:{''.join(self.split(':')[-1])[:6]}...>"
-
-    @classmethod
-    def from_env(
-        cls,
-        var_name: str = "BOT_TOKEN",
-        *,
-        is_read: bool = False,
-        path_to_envfile: str | pathlib.Path | None = None,
-    ) -> typing.Self:
-        if not is_read:
-            env.read_envfile(path_to_envfile)
-        return cls(env.str(var_name))
-
-    @cached_property
-    def bot_id(self) -> int:
-        return int(self.split(":")[0])
-
-
-__all__ = ("Token",)
+import pathlib
+import typing
+from functools import cached_property
+
+from envparse import env
+
+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:ABC'.")
+        return super().__new__(cls, token)
+
+    def __repr__(self) -> str:
+        return f"<Token: {self.bot_id}:{''.join(self.split(':')[-1])[:6]}...>"
+
+    @classmethod
+    def from_env(
+        cls,
+        var_name: str = "BOT_TOKEN",
+        *,
+        is_read: bool = False,
+        path_to_envfile: str | pathlib.Path | None = None,
+    ) -> typing.Self:
+        if not is_read:
+            env.read_envfile(path_to_envfile)
+        return cls(env.str(var_name))
+
+    @cached_property
+    def bot_id(self) -> int:
+        return int(self.split(":")[0])
+
+
+__all__ = ("Token",)