telegrinder 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

telegrinder/__init__.py

@@ -1,13 +1,10 @@
-"""Telegrinder
-
-Modern visionary telegram bot framework.
+"""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:
 
@@ -16,13 +13,13 @@ from telegrinder import API, Message, Telegrinder, Token
 from telegrinder.modules import logger
 from telegrinder.rules import Text
 
+logger.set_level("INFO")
 api = API(token=Token("123:token"))
 bot = Telegrinder(api)
-logger.set_level("INFO")
 
 
 @bot.on.message(Text("/start"))
-async def start(message: Message):
+async def start(message: Message) -> None:
     me = (await api.get_me()).unwrap()
     await message.answer(f"Hello, {message.from_user.full_name}! I'm {me.full_name}.")
 
@@ -48,19 +45,15 @@ from .bot import (
     ABCReturnManager,
     ABCRule,
     ABCScenario,
-    ABCStateView,
     ABCView,
     AudioReplyHandler,
     BaseCute,
     BaseReturnManager,
-    BaseStateView,
     BaseView,
     CallbackQueryCute,
     CallbackQueryReturnManager,
-    CallbackQueryRule,
     CallbackQueryView,
     ChatJoinRequestCute,
-    ChatJoinRequestRule,
     ChatJoinRequestView,
     ChatMemberUpdatedCute,
     ChatMemberView,
@@ -73,12 +66,10 @@ from .bot import (
     Hasher,
     InlineQueryCute,
     InlineQueryReturnManager,
-    InlineQueryRule,
     MediaGroupReplyHandler,
     MessageCute,
     MessageReplyHandler,
     MessageReturnManager,
-    MessageRule,
     MessageView,
     PhotoReplyHandler,
     Polling,
@@ -87,40 +78,40 @@ from .bot import (
     PreCheckoutQueryView,
     RawEventView,
     ShortState,
-    StateViewHasher,
     StickerReplyHandler,
     Telegrinder,
     UpdateCute,
     VideoReplyHandler,
     ViewBox,
     WaiterMachine,
+    action,
     register_manager,
 )
-from .client import ABCClient, AiohttpClient, AiosonicClient
-from .model import Model
+from .client import ABCClient, AiohttpClient
+from .model import Model, field
 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.global_context import ABCGlobalContext, GlobalContext, TelegrinderContext
 from .tools.input_file_directory import InputFileDirectory
 from .tools.keyboard import (
-    AnyMarkup,
+    ABCKeyboard,
+    ABCStaticKeyboard,
+    BaseButton,
+    BaseKeyboard,
+    BaseStaticButton,
+    BaseStaticKeyboard,
     Button,
     InlineButton,
     InlineKeyboard,
     Keyboard,
     RowButtons,
+    StaticButton,
+    StaticInlineButton,
+    StaticInlineKeyboard,
+    StaticKeyboard,
 )
 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.loop_wrapper import DelayedTask, LoopWrapper
 from .tools.parse_mode import ParseMode
 from .tools.state_storage import ABCStateStorage, MemoryStateStorage, StateData
 
@@ -135,12 +126,18 @@ Bot: typing.TypeAlias = Telegrinder
 
 
 __all__ = (
+    "API",
+    "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",
     "ABCClient",
     "ABCDispatch",
-    "ABCErrorHandler",
     "ABCGlobalContext",
     "ABCHandler",
-    "ABCLoopWrapper",
+    "ABCKeyboard",
     "ABCMiddleware",
     "ABCPolling",
     "ABCReturnManager",
@@ -148,35 +145,28 @@ __all__ = (
     "ABCScenario",
     "ABCStateStorage",
     "ABCStateStorage",
-    "ABCStateView",
-    "ABCTranslator",
-    "ABCTranslatorMiddleware",
+    "ABCStaticKeyboard",
     "ABCView",
-    "API",
     "APIError",
     "APIResponse",
     "APIServerError",
     "AiohttpClient",
-    "AiosonicClient",
-    "AnyMarkup",
     "AudioReplyHandler",
+    "BaseButton",
     "BaseCute",
+    "BaseKeyboard",
     "BaseReturnManager",
-    "BaseStateView",
+    "BaseStaticButton",
+    "BaseStaticKeyboard",
     "BaseView",
     "Bot",
     "Button",
-    "CALLBACK_QUERY_FOR_MESSAGE",
-    "CALLBACK_QUERY_FROM_CHAT",
-    "CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE",
     "CallbackQuery",
     "CallbackQueryCute",
     "CallbackQueryReturnManager",
-    "CallbackQueryRule",
     "CallbackQueryView",
     "ChatJoinRequest",
     "ChatJoinRequestCute",
-    "ChatJoinRequestRule",
     "ChatJoinRequestView",
     "ChatMemberUpdated",
     "ChatMemberUpdatedCute",
@@ -184,29 +174,22 @@ __all__ = (
     "Checkbox",
     "Choice",
     "Context",
-    "CtxVar",
     "DelayedTask",
     "Dispatch",
     "DocumentReplyHandler",
-    "ErrorHandler",
     "FuncHandler",
     "GlobalContext",
     "HTMLFormatter",
     "Hasher",
-    "I18nEnum",
     "InlineButton",
     "InlineKeyboard",
     "InlineQuery",
     "InlineQueryCute",
     "InlineQueryReturnManager",
-    "InlineQueryRule",
     "InputFileDirectory",
     "Keyboard",
     "Lifespan",
     "LoopWrapper",
-    "MESSAGE_FROM_USER",
-    "MESSAGE_FROM_USER_IN_CHAT",
-    "MESSAGE_IN_CHAT",
     "MediaGroupReplyHandler",
     "MemoryStateStorage",
     "MemoryStateStorage",
@@ -215,7 +198,6 @@ __all__ = (
     "MessageReplyHandler",
     "MessageReplyHandler",
     "MessageReturnManager",
-    "MessageRule",
     "MessageView",
     "Model",
     "ParseMode",
@@ -228,23 +210,23 @@ __all__ = (
     "RawEventView",
     "RowButtons",
     "ShortState",
-    "SimpleI18n",
-    "SimpleTranslator",
     "StateData",
     "StateData",
-    "StateViewHasher",
+    "StaticButton",
+    "StaticInlineButton",
+    "StaticInlineKeyboard",
+    "StaticKeyboard",
     "StickerReplyHandler",
     "Telegrinder",
+    "TelegrinderContext",
     "Token",
     "Update",
     "UpdateCute",
     "VideoReplyHandler",
     "ViewBox",
     "WaiterMachine",
-    "cache_translation",
-    "ctx_var",
-    "get_cached_translation",
+    "action",
+    "field",
     "logger",
-    "magic_bundle",
     "register_manager",
 )

telegrinder/__meta__.py

@@ -0,0 +1 @@
+__version__ = "0.5.0"

telegrinder/api/__init__.py

@@ -1,7 +1,7 @@
-from .api import API
-from .error import APIError, APIServerError, InvalidTokenError
-from .response import APIResponse
-from .token import Token
+from telegrinder.api.api import API, compose_data, retryer
+from telegrinder.api.error import APIError, APIServerError, InvalidTokenError
+from telegrinder.api.response import APIResponse
+from telegrinder.api.token import Token
 
 __all__ = (
     "API",
@@ -10,4 +10,6 @@ __all__ = (
     "APIServerError",
     "InvalidTokenError",
     "Token",
+    "compose_data",
+    "retryer",
 )

telegrinder/api/api.py

@@ -1,50 +1,102 @@
-from functools import cached_property
+from __future__ import annotations
+
+import asyncio
+import pathlib
+from functools import cached_property, wraps
+from http import HTTPStatus
 
 import msgspec
 import typing_extensions as typing
+from fntypes.misc import is_ok
 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.client.aiohttp import DEFAULT_TIMEOUT
 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
+type Data = dict[str, typing.Any]
+type Files = dict[str, tuple[str, bytes]]
+type APIRequestMethod[T: API, **P, R] = typing.Callable[
+    typing.Concatenate[T, P],
+    typing.Coroutine[typing.Any, typing.Any, Result[R, APIError]],
+]
+
+DEFAULT_MAX_RETRIES: typing.Final[int] = 5
 
 
-def compose_data[MultipartForm: MultipartFormProto](
-    client: ABCClient[MultipartForm],
-    data: dict[str, typing.Any],
-    files: dict[str, tuple[str, bytes]],
-) -> MultipartForm:
+def compose_data(
+    client: ABCClient,
+    data: Data,
+    files: Files,
+) -> MultipartFormProto:
     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]):
+def retryer[T: API, **P, R](func: APIRequestMethod[T, P, R], /) -> APIRequestMethod[T, P, R]:
+    @wraps(func)
+    async def wrapper(
+        self: T,
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> Result[typing.Any, APIError]:
+        retries_counter = 0
+
+        while True:
+            result = await func(self, *args, **kwargs)
+
+            if is_ok(result) or not self.retryer_enabled or retries_counter >= self.max_retries:
+                return result
+
+            if result.error.status_code == HTTPStatus.TOO_MANY_REQUESTS:
+                await asyncio.sleep(result.error.retry_after.unwrap_or(5.0))
+
+            elif result.error.status_code == HTTPStatus.INTERNAL_SERVER_ERROR and "restart" in result.error.error:
+                await asyncio.sleep(10.0)
+
+            elif result.error.migrate_to_chat_id:
+                kwargs["chat_id"] = result.error.migrate_to_chat_id.value
+
+            retries_counter += 1
+
+    return wrapper  # type: ignore
+
+
+class API(APIMethods):
     """Bot API with available API methods and http client."""
 
+    http: ABCClient
+
     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:
+    def __init__(
+        self,
+        token: Token,
+        *,
+        http: ABCClient | None = None,
+        enable_retryer: bool = True,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+    ) -> None:
         self.token = token
-        self.http = http or AiohttpClient()  # type: ignore
+        self.http = http or AiohttpClient()
+        self._retryer_enabled = enable_retryer
+        self._max_retries = max_retries
         super().__init__(api=self)
 
     def __repr__(self) -> str:
-        return "<{}: token={!r}, http={!r}>".format(
-            self.__class__.__name__,
-            self.token,
+        return "<{}: id={}, http={!r}, retryer_enabled={}, max_retries={}>".format(
+            type(self).__name__,
+            self.id,
             self.http,
+            self._retryer_enabled,
+            self._max_retries,
         )
 
     @cached_property
@@ -59,20 +111,38 @@ class API(APIMethods[HTTPClient], typing.Generic[HTTPClient]):
     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}")
+    @property
+    def retryer_enabled(self) -> bool:
+        return self._retryer_enabled
+
+    @property
+    def max_retries(self) -> int:
+        return self._max_retries
+
+    async def download_file(
+        self,
+        file_path: str | pathlib.Path,
+        timeout: int | float = DEFAULT_TIMEOUT,
+    ) -> bytes:
+        return await self.http.request_content(
+            url=f"{self.request_file_url}/{file_path}",
+            timeout=timeout,
+        )
 
+    @retryer
     async def request(
         self,
         method: str,
-        data: dict[str, typing.Any] | None = None,
-        files: dict[str, tuple[str, bytes]] | None = None,
+        data: Data | None = None,
+        files: Files | None = None,
+        **kwargs: typing.Any,
     ) -> Result[Json, APIError]:
-        """Request a `JSON` response with the `POST` HTTP method and passing data, files as `multipart/form-data`."""
+        """Request a `JSON` response using http method `POST` 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 {}),
+            **kwargs,
         )
         if response.get("ok", False) is True:
             return Ok(response["result"])
@@ -80,22 +150,26 @@ class API(APIMethods[HTTPClient], typing.Generic[HTTPClient]):
             APIError(
                 code=response.get("error_code", 400),
                 error=response.get("description", "Something went wrong"),
+                data=response.get("parameters", {}),
             ),
         )
 
+    @retryer
     async def request_raw(
         self,
         method: str,
-        data: dict[str, typing.Any] | None = None,
-        files: dict[str, tuple[str, bytes]] | None = None,
+        data: Data | None = None,
+        files: Files | None = None,
+        **kwargs: typing.Any,
     ) -> Result[msgspec.Raw, APIError]:
-        """Request a `raw` response with the `POST` HTTP method and passing data, files as `multipart/form-data`."""
+        """Request a `raw` response using http method `POST` 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 {}),
+            **kwargs,
         )
         return decoder.decode(response_bytes, type=APIResponse).to_result()
 
 
-__all__ = ("API",)
+__all__ = ("API", "compose_data", "retryer")

telegrinder/api/error.py

@@ -1,16 +1,50 @@
-class APIError(Exception):
-    def __init__(self, code: int, error: str) -> None:
-        self.code, self.error = code, error
+import typing
+from functools import cached_property
+from http import HTTPStatus
+
+from fntypes.misc import from_optional
+from fntypes.option import Option
 
-    def __str__(self) -> str:
-        return f"[{self.code}] {self.error}"
 
+class ReprErrorMixin:
     def __repr__(self) -> str:
-        return f"<APIError: {self.__str__()}>"
+        return f"{type(self).__name__}: {self}"
 
 
-class APIServerError(Exception):
-    pass
+class APIError(ReprErrorMixin, Exception):
+    def __init__(
+        self,
+        code: int,
+        error: str,
+        data: dict[str, typing.Any],
+    ) -> None:
+        self.code, self.error, self.parameters = code, error, data
+        super().__init__(code, error, data)
+
+    @cached_property
+    def status_code(self) -> HTTPStatus:
+        return HTTPStatus(self.code)
+
+    @property
+    def retry_after(self) -> Option[int]:
+        return from_optional(self.parameters.get("retry_after"))
+
+    @property
+    def migrate_to_chat_id(self) -> Option[int]:
+        return from_optional(self.parameters.get("migrate_to_chat_id"))
+
+    def __str__(self) -> str:
+        return f"[{self.code}] ({self.status_code.name}) {self.error}"
+
+
+class APIServerError(ReprErrorMixin, Exception):
+    def __init__(self, message: str, retry_after: int) -> None:
+        self.message = message
+        self.retry_after = retry_after
+        super().__init__(message, retry_after)
+
+    def __str__(self) -> str:
+        return self.message
 
 
 class InvalidTokenError(BaseException):

telegrinder/api/response.py

@@ -1,3 +1,5 @@
+import typing
+
 import msgspec
 from fntypes.result import Error, Ok, Result
 
@@ -10,11 +12,12 @@ class APIResponse(Model):
     result: msgspec.Raw = msgspec.Raw(b"")
     error_code: int = 400
     description: str = "Something went wrong"
+    parameters: dict[str, typing.Any] = msgspec.field(default_factory=dict[str, typing.Any])
 
     def to_result(self) -> Result[msgspec.Raw, APIError]:
         if self.ok:
             return Ok(self.result)
-        return Error(APIError(self.error_code, self.description))
+        return Error(APIError(code=self.error_code, error=self.description, data=self.parameters))
 
 
 __all__ = ("APIResponse",)

telegrinder/api/token.py

@@ -4,7 +4,7 @@ from functools import cached_property
 
 from envparse import env
 
-from .error import InvalidTokenError
+from telegrinder.api.error import InvalidTokenError
 
 
 class Token(str):
@@ -14,7 +14,7 @@ class Token(str):
         return super().__new__(cls, token)
 
     def __repr__(self) -> str:
-        return f"<Token: {self.bot_id}:{''.join(self.split(':')[-1])[:6]}...>"
+        return f"<Token: {self.bot_id}:{self.split(':')[1][:6]}...>"
 
     @classmethod
     def from_env(

telegrinder/bot/__init__.py

@@ -20,11 +20,9 @@ from telegrinder.bot.dispatch import (
     ABCHandler,
     ABCMiddleware,
     ABCReturnManager,
-    ABCStateView,
     ABCView,
     AudioReplyHandler,
     BaseReturnManager,
-    BaseStateView,
     BaseView,
     CallbackQueryReturnManager,
     CallbackQueryView,
@@ -46,25 +44,24 @@ from telegrinder.bot.dispatch import (
     PreCheckoutQueryView,
     RawEventView,
     ShortState,
-    StateViewHasher,
     StickerReplyHandler,
     VideoReplyHandler,
     ViewBox,
     WaiterMachine,
-    clear_wm_storage_worker,
+    action,
     register_manager,
 )
 from telegrinder.bot.polling import ABCPolling, Polling
-from telegrinder.bot.rules import (
-    ABCRule,
-    CallbackQueryRule,
-    ChatJoinRequestRule,
-    InlineQueryRule,
-    MessageRule,
-)
+from telegrinder.bot.rules import ABCRule
 from telegrinder.bot.scenario import ABCScenario, Checkbox, Choice
 
 __all__ = (
+    "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",
@@ -72,22 +69,15 @@ __all__ = (
     "ABCReturnManager",
     "ABCRule",
     "ABCScenario",
-    "ABCStateView",
     "ABCView",
     "AudioReplyHandler",
     "BaseCute",
     "BaseReturnManager",
-    "BaseStateView",
     "BaseView",
-    "CALLBACK_QUERY_FOR_MESSAGE",
-    "CALLBACK_QUERY_FROM_CHAT",
-    "CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE",
     "CallbackQueryCute",
     "CallbackQueryReturnManager",
-    "CallbackQueryRule",
     "CallbackQueryView",
     "ChatJoinRequestCute",
-    "ChatJoinRequestRule",
     "ChatJoinRequestView",
     "ChatMemberUpdatedCute",
     "ChatMemberView",
@@ -100,16 +90,11 @@ __all__ = (
     "Hasher",
     "InlineQueryCute",
     "InlineQueryReturnManager",
-    "InlineQueryRule",
-    "MESSAGE_FROM_USER",
-    "MESSAGE_FROM_USER_IN_CHAT",
-    "MESSAGE_IN_CHAT",
     "Manager",
     "MediaGroupReplyHandler",
     "MessageCute",
     "MessageReplyHandler",
     "MessageReturnManager",
-    "MessageRule",
     "MessageView",
     "PhotoReplyHandler",
     "Polling",
@@ -118,13 +103,12 @@ __all__ = (
     "PreCheckoutQueryView",
     "RawEventView",
     "ShortState",
-    "StateViewHasher",
     "StickerReplyHandler",
     "Telegrinder",
     "UpdateCute",
     "VideoReplyHandler",
     "ViewBox",
     "WaiterMachine",
-    "clear_wm_storage_worker",
+    "action",
     "register_manager",
 )