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

telegrinder/__init__.py

@@ -33,7 +33,7 @@ bot.run_forever()
 
 import typing
 
-from .api import API, APIError, APIResponse, Token
+from .api import API, APIError, APIResponse, APIServerError, Token
 from .bot import (
     CALLBACK_QUERY_FOR_MESSAGE,
     CALLBACK_QUERY_FROM_CHAT,
@@ -82,6 +82,9 @@ from .bot import (
     MessageView,
     PhotoReplyHandler,
     Polling,
+    PreCheckoutQueryCute,
+    PreCheckoutQueryManager,
+    PreCheckoutQueryView,
     RawEventView,
     ShortState,
     StateViewHasher,
@@ -93,45 +96,37 @@ from .bot import (
     WaiterMachine,
     register_manager,
 )
-from .bot.rules import StateMeta
-from .client import ABCClient, AiohttpClient
+from .client import ABCClient, AiohttpClient, AiosonicClient
 from .model import Model
 from .modules import logger
-from .tools import (
-    ABCErrorHandler,
-    ABCGlobalContext,
-    ABCLoopWrapper,
-    ABCStateStorage,
+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,
-    CtxVar,
-    DelayedTask,
-    ErrorHandler,
-    FormatString,
-    GlobalContext,
-    HTMLFormatter,
-    I18nEnum,
     InlineButton,
     InlineKeyboard,
     Keyboard,
-    KeyboardSetBase,
-    KeyboardSetYAML,
-    Lifespan,
-    LoopWrapper,
-    MemoryStateStorage,
-    ParseMode,
     RowButtons,
-    SimpleI18n,
-    SimpleTranslator,
-    StateData,
-    ctx_var,
-    magic_bundle,
 )
+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
@@ -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,7 +241,9 @@ __all__ = (
     "VideoReplyHandler",
     "ViewBox",
     "WaiterMachine",
+    "cache_translation",
     "ctx_var",
+    "get_cached_translation",
     "logger",
     "magic_bundle",
     "register_manager",

telegrinder/api/__init__.py

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

telegrinder/api/api.py

@@ -1,39 +1,44 @@
-import typing
 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
-from telegrinder.model import DataConverter, decoder
+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)
 
-def compose_data(
-    client: ABCClient,
+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]],
-) -> typing.Any:
-    converter = DataConverter(_files=files.copy())
-    return client.get_form(
-        data={k: converter(v) for k, v in data.items()},
-        files=converter.files,
-    )
+) -> MultipartForm:
+    if not data and not files:
+        return client.multipart_form_factory()
+    return client.get_form(data=data, files=files)
 
 
-class API(APIMethods):
+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/"
 
-    def __init__(self, token: Token, *, http: ABCClient | None = None) -> None:
+    token: Token
+    http: HTTPClient
+
+    def __init__(self, token: Token, *, http: HTTPClient | None = None) -> None:
         self.token = token
-        self.http = http or AiohttpClient()
-        super().__init__(self)
+        self.http = http or AiohttpClient()  # type: ignore
+        super().__init__(api=self)
 
     def __repr__(self) -> str:
         return "<{}: token={!r}, http={!r}>".format(
@@ -62,19 +67,20 @@ class API(APIMethods):
         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]:
+    ) -> 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"):
-            assert "result" in response
+        if response.get("ok", False) is True:
             return Ok(response["result"])
         return Error(
             APIError(
                 code=response.get("error_code", 400),
-                error=response.get("description"),
-            )
+                error=response.get("description", "Something went wrong"),
+            ),
         )
 
     async def request_raw(
@@ -83,8 +89,10 @@ class API(APIMethods):
         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()

telegrinder/api/error.py

@@ -1,16 +1,20 @@
-class APIError(BaseException):
-    def __init__(self, code: int, error: str | None = None) -> None:
+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 or 'Something went wrong'}"
+        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", "InvalidTokenError")
+__all__ = ("APIError", "APIServerError", "InvalidTokenError")

telegrinder/api/response.py

@@ -8,8 +8,8 @@ from telegrinder.model import Model
 class APIResponse(Model):
     ok: bool = False
     result: msgspec.Raw = msgspec.Raw(b"")
-    error_code: int = 0
-    description: str = ""
+    error_code: int = 400
+    description: str = "Something went wrong"
 
     def to_result(self) -> Result[msgspec.Raw, APIError]:
         if self.ok:

telegrinder/api/token.py

@@ -8,9 +8,9 @@ from .error import InvalidTokenError
 
 
 class Token(str):
-    def __new__(cls, token: str) -> typing.Self:
+    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'.")
+            raise InvalidTokenError("Invalid token, it should look like this: 12345:ABCdef")
         return super().__new__(cls, token)
 
     def __repr__(self) -> str:

telegrinder/bot/__init__.py

@@ -6,6 +6,7 @@ from telegrinder.bot.cute_types import (
     ChatMemberUpdatedCute,
     InlineQueryCute,
     MessageCute,
+    PreCheckoutQueryCute,
     UpdateCute,
 )
 from telegrinder.bot.dispatch import (
@@ -41,6 +42,8 @@ from telegrinder.bot.dispatch import (
     MessageReturnManager,
     MessageView,
     PhotoReplyHandler,
+    PreCheckoutQueryManager,
+    PreCheckoutQueryView,
     RawEventView,
     ShortState,
     StateViewHasher,
@@ -110,6 +113,9 @@ __all__ = (
     "MessageView",
     "PhotoReplyHandler",
     "Polling",
+    "PreCheckoutQueryCute",
+    "PreCheckoutQueryManager",
+    "PreCheckoutQueryView",
     "RawEventView",
     "ShortState",
     "StateViewHasher",

telegrinder/bot/bot.py

@@ -1,32 +1,32 @@
 import typing_extensions as typing
 
-from telegrinder.api.api import API
+from telegrinder.api.api import API, HTTPClient
+from telegrinder.bot.dispatch import dispatch as dp
 from telegrinder.bot.dispatch.abc import ABCDispatch
-from telegrinder.bot.dispatch.dispatch import Dispatch
+from telegrinder.bot.polling import polling as pg
 from telegrinder.bot.polling.abc import ABCPolling
-from telegrinder.bot.polling.polling import Polling
 from telegrinder.modules import logger
 from telegrinder.tools.loop_wrapper import ABCLoopWrapper
-from telegrinder.tools.loop_wrapper.loop_wrapper import LoopWrapper
+from telegrinder.tools.loop_wrapper import loop_wrapper as lw
 
-DispatchT = typing.TypeVar("DispatchT", bound=ABCDispatch, default=Dispatch)
-PollingT = typing.TypeVar("PollingT", bound=ABCPolling, default=Polling)
-LoopWrapperT = typing.TypeVar("LoopWrapperT", bound=ABCLoopWrapper, default=LoopWrapper)
+Dispatch = typing.TypeVar("Dispatch", bound=ABCDispatch, default=dp.Dispatch[HTTPClient])
+Polling = typing.TypeVar("Polling", bound=ABCPolling, default=pg.Polling[HTTPClient])
+LoopWrapper = typing.TypeVar("LoopWrapper", bound=ABCLoopWrapper, default=lw.LoopWrapper)
 
 
-class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
+class Telegrinder(typing.Generic[HTTPClient, Dispatch, Polling, LoopWrapper]):
     def __init__(
         self,
-        api: API,
+        api: API[HTTPClient],
         *,
-        polling: PollingT | None = None,
-        dispatch: DispatchT | None = None,
-        loop_wrapper: LoopWrapperT | None = None,
+        dispatch: Dispatch | None = None,
+        polling: Polling | None = None,
+        loop_wrapper: LoopWrapper | None = None,
     ) -> None:
         self.api = api
-        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())
+        self.dispatch = typing.cast(Dispatch, dispatch or dp.Dispatch())
+        self.polling = typing.cast(Polling, polling or pg.Polling(api))
+        self.loop_wrapper = typing.cast(LoopWrapper, loop_wrapper or lw.LoopWrapper())
 
     def __repr__(self) -> str:
         return "<{}: api={!r}, dispatch={!r}, polling={!r}, loop_wrapper={!r}>".format(
@@ -38,7 +38,7 @@ class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
         )
 
     @property
-    def on(self) -> DispatchT:
+    def on(self) -> Dispatch:
         return self.dispatch
 
     async def reset_webhook(self) -> None:
@@ -51,23 +51,30 @@ class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
         *,
         offset: int = 0,
         skip_updates: bool = False,
-    ) -> None:
-        if skip_updates:
-            logger.debug("Dropping pending updates")
-            await self.reset_webhook()
-            await self.api.delete_webhook(drop_pending_updates=True)
-        self.polling.offset = offset
+    ) -> typing.NoReturn:
+        async def polling() -> typing.NoReturn:
+            if skip_updates:
+                logger.debug("Dropping pending updates")
+                await self.reset_webhook()
+                await self.api.delete_webhook(drop_pending_updates=True)
+            self.polling.offset = offset
+
+            async for updates in self.polling.listen():
+                for update in updates:
+                    logger.debug(
+                        "Received update (update_id={}, update_type={!r})",
+                        update.update_id,
+                        update.update_type.name,
+                    )
+                    self.loop_wrapper.add_task(self.dispatch.feed(update, self.api))
 
-        async for updates in self.polling.listen():
-            for update in updates:
-                logger.debug(
-                    "Received update (update_id={}, update_type={!r})",
-                    update.update_id,
-                    update.update_type.name,
-                )
-                self.loop_wrapper.add_task(self.dispatch.feed(update, self.api))
+        if self.loop_wrapper.is_running:
+            await polling()
+        else:
+            self.loop_wrapper.add_task(polling())
+            self.loop_wrapper.run_event_loop()
 
-    def run_forever(self, *, offset: int = 0, skip_updates: bool = False) -> None:
+    def run_forever(self, *, offset: int = 0, skip_updates: bool = False) -> typing.NoReturn:
         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.run_event_loop()

telegrinder/bot/cute_types/__init__.py

@@ -4,6 +4,7 @@ from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
 from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
 from telegrinder.bot.cute_types.inline_query import InlineQueryCute
 from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.cute_types.pre_checkout_query import PreCheckoutQueryCute
 from telegrinder.bot.cute_types.update import UpdateCute
 
 __all__ = (
@@ -13,5 +14,6 @@ __all__ = (
     "ChatMemberUpdatedCute",
     "InlineQueryCute",
     "MessageCute",
+    "PreCheckoutQueryCute",
     "UpdateCute",
 )