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

telegrinder/__init__.py

@@ -1,145 +1,140 @@
-"""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, APIServerError, 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,
+    PreCheckoutQueryCute,
+    PreCheckoutQueryManager,
+    PreCheckoutQueryView,
+    RawEventView,
+    ShortState,
+    StateViewHasher,
+    StickerReplyHandler,
+    Telegrinder,
+    UpdateCute,
+    VideoReplyHandler,
+    ViewBox,
+    WaiterMachine,
+    register_manager,
+)
+from .client import ABCClient, AiohttpClient, AiosonicClient
+from .model import Model
+from .modules import logger
+from .tools.error_handler import ABCErrorHandler, ErrorHandler
+from .tools.formatting import HTMLFormatter
+from .tools.global_context import ABCGlobalContext, CtxVar, GlobalContext, ctx_var
+from .tools.i18n import (
+    ABCTranslator,
+    ABCTranslatorMiddleware,
+    I18nEnum,
+    SimpleI18n,
+    SimpleTranslator,
+)
+from .tools.input_file_directory import InputFileDirectory
+from .tools.keyboard import (
+    AnyMarkup,
+    Button,
+    InlineButton,
+    InlineKeyboard,
+    Keyboard,
+    RowButtons,
+)
+from .tools.lifespan import Lifespan
+from .tools.loop_wrapper import ABCLoopWrapper, DelayedTask, LoopWrapper
+from .tools.magic import cache_translation, get_cached_translation, magic_bundle
+from .tools.parse_mode import ParseMode
+from .tools.state_storage import ABCStateStorage, MemoryStateStorage, StateData
+
+Update: typing.TypeAlias = UpdateCute
+Message: typing.TypeAlias = MessageCute
+PreCheckoutQuery: typing.TypeAlias = PreCheckoutQueryCute
+ChatJoinRequest: typing.TypeAlias = ChatJoinRequestCute
+ChatMemberUpdated: typing.TypeAlias = ChatMemberUpdatedCute
+CallbackQuery: typing.TypeAlias = CallbackQueryCute
+InlineQuery: typing.TypeAlias = InlineQueryCute
+Bot: typing.TypeAlias = Telegrinder
+
+
+__all__ = (
     "ABCClient",
     "ABCDispatch",
     "ABCErrorHandler",
@@ -160,7 +155,9 @@ __all__ = (
     "API",
     "APIError",
     "APIResponse",
+    "APIServerError",
     "AiohttpClient",
+    "AiosonicClient",
     "AnyMarkup",
     "AudioReplyHandler",
     "BaseCute",
@@ -192,7 +189,6 @@ __all__ = (
     "Dispatch",
     "DocumentReplyHandler",
     "ErrorHandler",
-    "FormatString",
     "FuncHandler",
     "GlobalContext",
     "HTMLFormatter",
@@ -204,9 +200,8 @@ __all__ = (
     "InlineQueryCute",
     "InlineQueryReturnManager",
     "InlineQueryRule",
+    "InputFileDirectory",
     "Keyboard",
-    "KeyboardSetBase",
-    "KeyboardSetYAML",
     "Lifespan",
     "LoopWrapper",
     "MESSAGE_FROM_USER",
@@ -226,6 +221,10 @@ __all__ = (
     "ParseMode",
     "PhotoReplyHandler",
     "Polling",
+    "PreCheckoutQuery",
+    "PreCheckoutQueryCute",
+    "PreCheckoutQueryManager",
+    "PreCheckoutQueryView",
     "RawEventView",
     "RowButtons",
     "ShortState",
@@ -233,8 +232,6 @@ __all__ = (
     "SimpleTranslator",
     "StateData",
     "StateData",
-    "StateMeta",
-    "StateMeta",
     "StateViewHasher",
     "StickerReplyHandler",
     "Telegrinder",
@@ -244,8 +241,10 @@ __all__ = (
     "VideoReplyHandler",
     "ViewBox",
     "WaiterMachine",
+    "cache_translation",
     "ctx_var",
+    "get_cached_translation",
     "logger",
     "magic_bundle",
-    "register_manager",
-)
+    "register_manager",
+)

telegrinder/api/__init__.py

@@ -1,12 +1,13 @@
-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, APIServerError, InvalidTokenError
+from .response import APIResponse
+from .token import Token
+
+__all__ = (
     "API",
     "APIError",
     "APIResponse",
+    "APIServerError",
     "InvalidTokenError",
-    "Token",
-)
+    "Token",
+)

telegrinder/api/api.py

@@ -1,93 +1,101 @@
-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",)
+from functools import cached_property
+
+import msgspec
+import typing_extensions as typing
+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, MultipartFormProto
+from telegrinder.model import decoder
+from telegrinder.types.methods import APIMethods
+
+HTTPClient = typing.TypeVar("HTTPClient", bound=ABCClient, default=AiohttpClient)
+
+type Json = str | int | float | bool | list[Json] | dict[str, Json] | None
+
+
+def compose_data[MultipartForm: MultipartFormProto](
+    client: ABCClient[MultipartForm],
+    data: dict[str, typing.Any],
+    files: dict[str, tuple[str, bytes]],
+) -> MultipartForm:
+    if not data and not files:
+        return client.multipart_form_factory()
+    return client.get_form(data=data, files=files)
+
+
+class API(APIMethods[HTTPClient], typing.Generic[HTTPClient]):
+    """Bot API with available API methods and http client."""
+
+    API_URL = "https://api.telegram.org/"
+    API_FILE_URL = "https://api.telegram.org/file/"
+
+    token: Token
+    http: HTTPClient
+
+    def __init__(self, token: Token, *, http: HTTPClient | None = None) -> None:
+        self.token = token
+        self.http = http or AiohttpClient()  # type: ignore
+        super().__init__(api=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[Json, APIError]:
+        """Request a `JSON` response with the `POST` HTTP method and passing data, files as `multipart/form-data`."""
+        response = await self.http.request_json(
+            url=self.request_url + method,
+            method="POST",
+            data=compose_data(self.http, data or {}, files or {}),
+        )
+        if response.get("ok", False) is True:
+            return Ok(response["result"])
+        return Error(
+            APIError(
+                code=response.get("error_code", 400),
+                error=response.get("description", "Something went wrong"),
+            ),
+        )
+
+    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]:
+        """Request a `raw` response with the `POST` HTTP method and passing data, files as `multipart/form-data`."""
+        response_bytes = await self.http.request_bytes(
+            url=self.request_url + method,
+            method="POST",
+            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,20 @@
-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(Exception):
+    def __init__(self, code: int, error: str) -> None:
+        self.code, self.error = code, error
+
+    def __str__(self) -> str:
+        return f"[{self.code}] {self.error}"
+
+    def __repr__(self) -> str:
+        return f"<APIError: {self.__str__()}>"
+
+
+class APIServerError(Exception):
+    pass
+
+
+class InvalidTokenError(BaseException):
+    pass
+
+
+__all__ = ("APIError", "APIServerError", "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 = 400
+    description: str = "Something went wrong"
+
+    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",)