telegrinder 0.1.dev20__py3-none-any.whl → 0.1.dev158__py3-none-any.whl

telegrinder/__init__.py

@@ -1,39 +1,146 @@
-from .client import ABCClient, AiohttpClient
-from .api import ABCAPI, Token, API, APIError, APIResponse
+import typing
+
+from .api import ABCAPI, API, APIError, APIResponse, Token
 from .bot import (
-    ABCPolling,
-    Polling,
     ABCDispatch,
+    ABCHandler,
+    ABCMiddleware,
+    ABCPolling,
+    ABCReturnManager,
     ABCRule,
-    ABCMessageRule,
-    Dispatch,
-    Telegrinder,
+    ABCScenario,
+    ABCStateView,
     ABCView,
-    ABCHandler,
-    MessageView,
+    BaseCute,
+    BaseReturnManager,
+    BaseStateView,
+    BaseView,
+    CallbackQueryCute,
+    CallbackQueryReturnManager,
     CallbackQueryView,
+    Checkbox,
+    Dispatch,
     FuncHandler,
-    MessageCute,
-    CallbackQueryCute,
     InlineQueryCute,
-    ABCMiddleware,
-    ABCScenario,
-    Checkbox,
+    InlineQueryReturnManager,
+    MessageCute,
+    MessageReplyHandler,
+    MessageReturnManager,
+    MessageRule,
+    MessageView,
+    Polling,
     SingleChoice,
+    Telegrinder,
+    ViewBox,
+    WaiterMachine,
+    register_manager,
 )
+from .client import ABCClient, AiohttpClient
+from .model import Model
+from .modules import logger
 from .tools import (
-    Keyboard,
+    ABCGlobalContext,
+    ABCLoopWrapper,
+    ABCTranslator,
+    ABCTranslatorMiddleware,
+    AnyMarkup,
     Button,
+    CtxVar,
+    DelayedTask,
+    FormatString,
+    GlobalContext,
+    HTMLFormatter,
+    I18nEnum,
     InlineButton,
     InlineKeyboard,
-    VarUnset,
-    magic_bundle,
+    Keyboard,
     KeyboardSetBase,
     KeyboardSetYAML,
-    AnyMarkup,
+    LoopWrapper,
+    ParseMode,
+    RowButtons,
+    SimpleI18n,
+    SimpleTranslator,
+    ctx_var,
+    keyboard_remove,
+    magic_bundle,
 )
-from .result import Result
 
-Message = MessageCute
-CallbackQuery = CallbackQueryCute
-InlineQuery = InlineQueryCute
+Message: typing.TypeAlias = MessageCute
+CallbackQuery: typing.TypeAlias = CallbackQueryCute
+InlineQuery: typing.TypeAlias = InlineQueryCute
+Bot: typing.TypeAlias = Telegrinder
+
+
+__all__ = (
+    "ABCAPI",
+    "ABCClient",
+    "ABCDispatch",
+    "ABCGlobalContext",
+    "ABCHandler",
+    "ABCLoopWrapper",
+    "ABCMiddleware",
+    "ABCPolling",
+    "ABCReturnManager",
+    "ABCRule",
+    "ABCScenario",
+    "ABCStateView",
+    "ABCTranslator",
+    "ABCTranslatorMiddleware",
+    "ABCView",
+    "API",
+    "APIError",
+    "APIResponse",
+    "AiohttpClient",
+    "AnyMarkup",
+    "BaseCute",
+    "BaseReturnManager",
+    "BaseStateView",
+    "BaseView",
+    "Bot",
+    "Button",
+    "CallbackQuery",
+    "CallbackQueryCute",
+    "CallbackQueryReturnManager",
+    "CallbackQueryView",
+    "Checkbox",
+    "CtxVar",
+    "DelayedTask",
+    "Dispatch",
+    "FormatString",
+    "FuncHandler",
+    "GlobalContext",
+    "HTMLFormatter",
+    "I18nEnum",
+    "InlineButton",
+    "InlineKeyboard",
+    "InlineQuery",
+    "InlineQueryCute",
+    "InlineQueryReturnManager",
+    "Keyboard",
+    "KeyboardSetBase",
+    "KeyboardSetYAML",
+    "LoopWrapper",
+    "Message",
+    "MessageCute",
+    "MessageReplyHandler",
+    "MessageReturnManager",
+    "MessageRule",
+    "MessageView",
+    "Model",
+    "ParseMode",
+    "Polling",
+    "RowButtons",
+    "SimpleI18n",
+    "SimpleTranslator",
+    "SingleChoice",
+    "Telegrinder",
+    "Token",
+    "ViewBox",
+    "WaiterMachine",
+    "ctx_var",
+    "keyboard_remove",
+    "logger",
+    "magic_bundle",
+    "register_manager",
+)

telegrinder/api/__init__.py

@@ -1,4 +1,13 @@
-from .abc import ABCAPI, APIError, Token
+from .abc import ABCAPI, Token
 from .api import API
+from .error import APIError, InvalidTokenError
 from .response import APIResponse
-from .error import APIError
+
+__all__ = (
+    "ABCAPI",
+    "API",
+    "APIError",
+    "APIResponse",
+    "InvalidTokenError",
+    "Token",
+)

telegrinder/api/abc.py

@@ -1,20 +1,33 @@
-from abc import ABC, abstractmethod
+import pathlib
 import typing
+from abc import ABC, abstractmethod
 
 import msgspec
+from envparse import env
+from fntypes.result import Result
 
-from telegrinder.client import ABCClient
-from telegrinder.result import Result
 from telegrinder.api.error import APIError
+from telegrinder.client import ABCClient
 
-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:token'.")
+        return super().__new__(cls, token)
+
     @classmethod
-    def from_env(cls, var_name: str = "BOT_TOKEN", is_read: bool = False) -> "Token":
+    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()
+            env.read_envfile(path_to_envfile)
         return cls(env.str(var_name))
 
     @property
@@ -29,15 +42,15 @@ class ABCAPI(ABC):
     async def request(
         self,
         method: str,
-        data: typing.Optional[dict] = None,
-    ) -> Result[typing.Union[list, dict, bool], APIError]:
+        data: dict | None = None,
+    ) -> Result[list | dict | bool, APIError]:
         pass
 
     @abstractmethod
     async def request_raw(
         self,
         method: str,
-        data: typing.Optional[dict] = None,
+        data: dict | None = None,
     ) -> Result[msgspec.Raw, APIError]:
         pass
 
@@ -50,3 +63,6 @@ class ABCAPI(ABC):
     @abstractmethod
     def id(self) -> int:
         pass
+
+
+__all__ = ("ABCAPI", "Token")

telegrinder/api/api.py

@@ -1,15 +1,17 @@
+import typing
+
 import msgspec
+from fntypes.result import Error, Ok, Result
 
-from .abc import ABCAPI, APIError, Token
-import typing
-from telegrinder.result import Result
+from telegrinder.api.response import APIResponse
 from telegrinder.client import ABCClient, AiohttpClient
+from telegrinder.model import convert, decoder
 from telegrinder.types.methods import APIMethods
-from telegrinder.model import convert
-from telegrinder.api.response import APIResponse
 
+from .abc import ABCAPI, APIError, Token
 
-def compose_data(client: ABCClient, data: dict) -> typing.Any:
+
+def compose_data(client: ABCClient, data: dict[str, typing.Any]) -> typing.Any:
     data = {k: convert(v) for k, v in data.items()}
     if any(isinstance(v, tuple) for v in data.values()):
         data = client.get_form(data)
@@ -17,16 +19,16 @@ def compose_data(client: ABCClient, data: dict) -> typing.Any:
 
 
 class API(ABCAPI, APIMethods):
-    API_URL = "https://api.telegram.org/"
+    API_URL: typing.ClassVar[str] = "https://api.telegram.org/"
 
-    def __init__(self, token: Token, http: typing.Optional[ABCClient] = None):
+    def __init__(self, token: Token, *, http: ABCClient | None = None):
         self.token = token
         self.http = http or AiohttpClient()
         super().__init__(self)
 
     @property
     def id(self) -> int:
-        return int(self.token.split(":")[0])
+        return self.token.bot_id
 
     @property
     def request_url(self) -> str:
@@ -35,27 +37,30 @@ class API(ABCAPI, APIMethods):
     async def request(
         self,
         method: str,
-        data: typing.Optional[dict] = None,
-    ) -> Result[typing.Union[dict, list, bool], APIError]:
-        data = compose_data(self.http, data)
-        response = await self.http.request_json(self.request_url + method, data=data)
+        data: dict | None = None,
+    ) -> Result[dict | list | bool, APIError]:
+        response = await self.http.request_json(
+            url=self.request_url + method,
+            data=compose_data(self.http, data or {})
+        )
         if response.get("ok"):
             assert "result" in response
-            return Result(True, value=response["result"])
-
-        code, msg = response.get("error_code"), response.get("description")
-        return Result(False, error=APIError(code, msg))
+            return Ok(response["result"])
+        return Error(APIError(
+            code=response.get("error_code", 0),
+            error=response.get("description"),
+        ))
 
     async def request_raw(
         self,
         method: str,
-        data: typing.Optional[dict] = None,
+        data: dict[str, typing.Any] | None = None,
     ) -> Result[msgspec.Raw, APIError]:
-        data = compose_data(self.http, data)
         response_bytes = await self.http.request_bytes(
-            self.request_url + method, data=data
+            url=self.request_url + method,
+            data=compose_data(self.http, data or {}),
         )
-        response_skeleton: APIResponse = msgspec.json.decode(
-            response_bytes, type=APIResponse
-        )
-        return response_skeleton.to_result()
+        return decoder.decode(response_bytes, type=APIResponse).to_result()
+
+
+__all__ = ("API",)

telegrinder/api/error.py

@@ -1,6 +1,16 @@
-import typing
-
-
 class APIError(BaseException):
-    def __init__(self, code: int, error: typing.Optional[str] = None):
+    def __init__(self, code: int, error: str | None = 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 InvalidTokenError(BaseException):
+    ...
+
+
+__all__ = ("APIError", "InvalidTokenError")

telegrinder/api/response.py

@@ -1,16 +1,20 @@
-from telegrinder.model import Model
-from telegrinder.result import Result
-from telegrinder.api.error import APIError
 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
-    result: msgspec.Raw = b""
+    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 Result(True, value=self.result)
-        return Result(False, error=APIError(self.error_code, self.description))
+            return Ok(self.result)
+        return Error(APIError(self.error_code, self.description))
+
+
+__all__ = ("APIResponse",)

telegrinder/bot/__init__.py

@@ -1,15 +1,76 @@
-from .polling import ABCPolling, Polling
+from .bot import Telegrinder
+from .cute_types import (
+    BaseCute,
+    CallbackQueryCute,
+    InlineQueryCute,
+    MessageCute,
+    UpdateCute,
+)
 from .dispatch import (
     ABCDispatch,
-    Dispatch,
     ABCHandler,
+    ABCMiddleware,
+    ABCReturnManager,
+    ABCStateView,
     ABCView,
+    BaseReturnManager,
+    BaseStateView,
+    BaseView,
+    CallbackQueryReturnManager,
+    CallbackQueryView,
+    CompositionDispatch,
+    Context,
+    Dispatch,
     FuncHandler,
+    InlineQueryReturnManager,
+    Manager,
+    MessageReplyHandler,
+    MessageReturnManager,
     MessageView,
-    CallbackQueryView,
-    ABCMiddleware,
+    ViewBox,
+    WaiterMachine,
+    register_manager,
 )
-from .bot import Telegrinder
-from .cute_types import MessageCute, CallbackQueryCute, InlineQueryCute
-from .rules import ABCRule, ABCMessageRule
+from .polling import ABCPolling, Polling
+from .rules import ABCRule, CallbackQueryRule, MessageRule
 from .scenario import ABCScenario, Checkbox, SingleChoice
+
+__all__ = (
+    "ABCDispatch",
+    "ABCHandler",
+    "ABCMiddleware",
+    "ABCPolling",
+    "ABCReturnManager",
+    "ABCRule",
+    "ABCScenario",
+    "ABCStateView",
+    "ABCView",
+    "BaseCute",
+    "BaseReturnManager",
+    "BaseStateView",
+    "BaseView",
+    "CallbackQueryCute",
+    "CallbackQueryReturnManager",
+    "CallbackQueryRule",
+    "CallbackQueryView",
+    "Checkbox",
+    "CompositionDispatch",
+    "Context",
+    "Dispatch",
+    "FuncHandler",
+    "InlineQueryCute",
+    "InlineQueryReturnManager",
+    "Manager",
+    "MessageCute",
+    "MessageReplyHandler",
+    "MessageReturnManager",
+    "MessageRule",
+    "MessageView",
+    "Polling",
+    "SingleChoice",
+    "Telegrinder",
+    "UpdateCute",
+    "ViewBox",
+    "WaiterMachine",
+    "register_manager",
+)

telegrinder/bot/bot.py

@@ -1,53 +1,59 @@
-import asyncio
+import typing_extensions as typing
 
 from telegrinder.api import API
-from telegrinder.bot.polling import ABCPolling, Polling
 from telegrinder.bot.dispatch import ABCDispatch, Dispatch
+from telegrinder.bot.polling import ABCPolling, Polling
 from telegrinder.modules import logger
-import typing
+from telegrinder.tools.loop_wrapper import ABCLoopWrapper, LoopWrapper
+
+DispatchT = typing.TypeVar("DispatchT", bound=ABCDispatch, default=Dispatch)
+PollingT = typing.TypeVar("PollingT", bound=ABCPolling, default=Polling)
+LoopWrapperT = typing.TypeVar("LoopWrapperT", bound=ABCLoopWrapper, default=LoopWrapper)
+
 
+class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
+    dispatch: DispatchT
+    polling: PollingT
+    loop_wrapper: LoopWrapperT
 
-class Telegrinder:
     def __init__(
         self,
         api: API,
-        polling: typing.Optional[ABCPolling] = None,
-        dispatch: typing.Optional[ABCDispatch] = None,
+        *,
+        polling: PollingT | None = None,
+        dispatch: DispatchT | None = None,
+        loop_wrapper: LoopWrapperT | None = None,
     ):
         self.api = api
-        self.polling = polling or Polling(api)
-        self.dispatch = dispatch or Dispatch()
+        self.dispatch = dispatch or Dispatch()  # type: ignore
+        self.polling = polling or Polling(api)  # type: ignore
+        self.loop_wrapper = loop_wrapper or LoopWrapper()  # type: ignore
 
     @property
-    def on(self) -> Dispatch:
-        return self.dispatch  # type: ignore
+    def on(self) -> DispatchT:
+        return self.dispatch
 
     async def reset_webhook(self) -> None:
         if not (await self.api.get_webhook_info()).unwrap().url:
             return
-
         await self.api.delete_webhook()
 
     async def run_polling(self, offset: int = 0, skip_updates: bool = False) -> None:
         if skip_updates:
-            logger.debug("dropping pending updates")
+            logger.debug("Dropping pending updates")
             await self.reset_webhook()
             await self.api.delete_webhook(drop_pending_updates=True)
         self.polling.offset = offset
 
-        loop = asyncio.get_running_loop()
-        assert loop, "No running loop"
-
         async for updates in self.polling.listen():
             for update in updates:
-                logger.debug("received update (update_id={})", update.update_id)
-                loop.create_task(self.dispatch.feed(update, self.api))
+                logger.debug("Received update (update_id={})", update.update_id)
+                self.loop_wrapper.add_task(self.dispatch.feed(update, self.api))
 
     def run_forever(self, offset: int = 0, skip_updates: bool = False) -> None:
-        logger.debug("running blocking polling (id={})", self.api.id)
-        loop = asyncio.new_event_loop()
-        loop.create_task(self.run_polling(offset, skip_updates=skip_updates))
-        try:
-            loop.run_forever()
-        except KeyboardInterrupt:
-            logger.info("KeyboardInterrupt")
+        logger.debug("Running blocking polling (id={})", self.api.id)
+        self.loop_wrapper.add_task(self.run_polling(offset, skip_updates=skip_updates))
+        self.loop_wrapper.run_event_loop()
+
+
+__all__ = ("Telegrinder",)

telegrinder/bot/cute_types/__init__.py

@@ -1,3 +1,13 @@
-from .message import MessageCute
+from .base import BaseCute
 from .callback_query import CallbackQueryCute
 from .inline_query import InlineQueryCute
+from .message import MessageCute
+from .update import UpdateCute
+
+__all__ = (
+    "BaseCute",
+    "CallbackQueryCute",
+    "InlineQueryCute",
+    "MessageCute",
+    "UpdateCute",
+)

telegrinder/bot/cute_types/base.py

@@ -0,0 +1,47 @@
+import typing
+
+from telegrinder.api import ABCAPI, API
+from telegrinder.model import Model
+
+UpdateT = typing.TypeVar("UpdateT", bound=Model)
+
+if typing.TYPE_CHECKING:
+
+    class BaseCute(Model, typing.Generic[UpdateT]):
+        api: ABCAPI
+
+        @classmethod
+        def from_update(cls, update: UpdateT, bound_api: ABCAPI) -> typing.Self:
+            ...
+
+        @property
+        def ctx_api(self) -> API:
+            ...
+
+        def to_dict(
+            self,
+            *,
+            exclude_fields: set[str] | None = None,
+        ) -> dict[str, typing.Any]:
+            ...
+
+else:
+
+    class BaseCute(typing.Generic[UpdateT]):
+        api: ABCAPI
+
+        @classmethod
+        def from_update(cls, update, bound_api):
+            return cls(**update.to_dict(), api=bound_api)
+
+        @property
+        def ctx_api(self):
+            assert isinstance(self.api, API)
+            return self.api
+
+        def to_dict(self, *, exclude_fields=None):
+            exclude_fields = exclude_fields or set()
+            return super().to_dict(exclude_fields={"api"} | exclude_fields)
+
+
+__all__ = ("BaseCute",)