telegrinder 0.1.dev171__py3-none-any.whl → 0.2.0__py3-none-any.whl

telegrinder/__init__.py

@@ -34,7 +34,7 @@ bot.run_forever()
 
 import typing
 
-from .api import ABCAPI, API, APIError, APIResponse, Token
+from .api import API, APIError, APIResponse, Token
 from .bot import (
     ABCDispatch,
     ABCHandler,
@@ -122,7 +122,7 @@ Bot: typing.TypeAlias = Telegrinder
 
 
 __all__ = (
-    "ABCAPI",
+    "API",
     "ABCClient",
     "ABCDispatch",
     "ABCErrorHandler",

telegrinder/api/__init__.py

@@ -1,10 +1,9 @@
-from .abc import ABCAPI, Token
 from .api import API
 from .error import APIError, InvalidTokenError
 from .response import APIResponse
+from .token import Token
 
 __all__ = (
-    "ABCAPI",
     "API",
     "APIError",
     "APIResponse",

telegrinder/api/api.py

@@ -4,13 +4,13 @@ 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
 
-from .abc import ABCAPI, APIError, Token
-
 
 def compose_data(
     client: ABCClient,
@@ -24,7 +24,7 @@ def compose_data(
     )
 
 
-class API(ABCAPI, APIMethods):
+class API(APIMethods):
     """Bot API with available API methods and http client."""
 
     API_URL = "https://api.telegram.org/"

telegrinder/api/token.py

@@ -0,0 +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",)

telegrinder/bot/__init__.py

@@ -1,5 +1,5 @@
-from .bot import Telegrinder
-from .cute_types import (
+from telegrinder.bot.bot import Telegrinder
+from telegrinder.bot.cute_types import (
     BaseCute,
     CallbackQueryCute,
     ChatJoinRequestCute,
@@ -8,7 +8,7 @@ from .cute_types import (
     MessageCute,
     UpdateCute,
 )
-from .dispatch import (
+from telegrinder.bot.dispatch import (
     ABCDispatch,
     ABCHandler,
     ABCMiddleware,
@@ -37,9 +37,15 @@ from .dispatch import (
     clear_wm_storage_worker,
     register_manager,
 )
-from .polling import ABCPolling, Polling
-from .rules import ABCRule, CallbackQueryRule, ChatJoinRequestRule, InlineQueryRule, MessageRule
-from .scenario import ABCScenario, Checkbox, Choice
+from telegrinder.bot.polling import ABCPolling, Polling
+from telegrinder.bot.rules import (
+    ABCRule,
+    CallbackQueryRule,
+    ChatJoinRequestRule,
+    InlineQueryRule,
+    MessageRule,
+)
+from telegrinder.bot.scenario import ABCScenario, Checkbox, Choice
 
 __all__ = (
     "ABCDispatch",

telegrinder/bot/bot.py

@@ -1,10 +1,13 @@
 import typing_extensions as typing
 
-from telegrinder.api import API
-from telegrinder.bot.dispatch import ABCDispatch, Dispatch
-from telegrinder.bot.polling import ABCPolling, Polling
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.abc import ABCDispatch
+from telegrinder.bot.dispatch.dispatch import Dispatch
+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, LoopWrapper
+from telegrinder.tools.loop_wrapper import ABCLoopWrapper
+from telegrinder.tools.loop_wrapper.loop_wrapper import LoopWrapper
 
 DispatchT = typing.TypeVar("DispatchT", bound=ABCDispatch, default=Dispatch)
 PollingT = typing.TypeVar("PollingT", bound=ABCPolling, default=Polling)
@@ -57,7 +60,11 @@ class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
 
         async for updates in self.polling.listen():
             for update in updates:
-                logger.debug("Received update (update_id={})", update.update_id)
+                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))
 
     def run_forever(self, *, offset: int = 0, skip_updates: bool = False) -> None:

telegrinder/bot/cute_types/__init__.py

@@ -1,10 +1,10 @@
-from .base import BaseCute
-from .callback_query import CallbackQueryCute
-from .chat_join_request import ChatJoinRequestCute
-from .chat_member_updated import ChatMemberUpdatedCute
-from .inline_query import InlineQueryCute
-from .message import MessageCute
-from .update import UpdateCute
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+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.update import UpdateCute
 
 __all__ = (
     "BaseCute",

telegrinder/bot/cute_types/base.py

@@ -6,13 +6,13 @@ from functools import wraps
 import typing_extensions
 from fntypes.result import Result
 
-from telegrinder.api import ABCAPI, API
+from telegrinder.api.api import API
 from telegrinder.model import Model, get_params
 
 F = typing.TypeVar("F", bound=typing.Callable[..., typing.Any])
 Cute = typing.TypeVar("Cute", bound="BaseCute")
 Update = typing_extensions.TypeVar("Update", bound=Model)
-CtxAPI = typing_extensions.TypeVar("CtxAPI", bound=ABCAPI, default=API)
+CtxAPI = typing_extensions.TypeVar("CtxAPI", bound=API, default=API)
 
 Executor: typing.TypeAlias = typing.Callable[
     [Cute, str, dict[str, typing.Any]],
@@ -22,10 +22,10 @@ Executor: typing.TypeAlias = typing.Callable[
 if typing.TYPE_CHECKING:
 
     class BaseCute(Model, typing.Generic[Update, CtxAPI]):
-        api: ABCAPI
+        api: API
 
         @classmethod
-        def from_update(cls, update: Update, bound_api: ABCAPI) -> typing.Self: ...
+        def from_update(cls, update: Update, bound_api: API) -> typing.Self: ...
 
         @property
         def ctx_api(self) -> CtxAPI: ...
@@ -55,29 +55,10 @@ if typing.TYPE_CHECKING:
             ...
 
 else:
-    from fntypes.co import Nothing, Some, Variative
-    from msgspec._utils import get_class_annotations as _get_class_annotations
+    from fntypes.co import Some, Variative
 
     from telegrinder.msgspec_utils import Option, decoder
-
-    _DEFAULT_API_CLASS = API
-
-    def _get_ctx_api_class(cute_class):
-        if hasattr(cute_class, "__ctx_api_class__"):
-            return cute_class.__ctx_api_class__
-
-        ctx_api_class = _DEFAULT_API_CLASS
-        for base in cute_class.__dict__.get("__orig_bases__", ()):
-            if ctx_api_class is not _DEFAULT_API_CLASS:
-                break
-            if issubclass(typing.get_origin(base) or base, BaseCute):
-                for generic_type in typing.get_args(base):
-                    if issubclass(typing.get_origin(generic_type) or generic_type, ABCAPI):
-                        ctx_api_class = generic_type
-                        break
-
-        cute_class.__ctx_api_class__ = ctx_api_class
-        return ctx_api_class
+    from telegrinder.msgspec_utils import get_class_annotations as _get_class_annotations
 
     def _get_cute_from_args(args):
         for hint in args:
@@ -86,9 +67,8 @@ else:
                 if not isinstance(hint, type):
                     continue
 
-            if hint is Variative or issubclass(hint, Option) or issubclass(hint, Some | Nothing):
+            if hint in (Variative, Some, Option):
                 return _get_cute_from_args(typing.get_args(hint))
-
             if issubclass(hint, BaseCute):
                 return hint
 
@@ -149,11 +129,6 @@ else:
 
         @property
         def ctx_api(self):
-            ctx_api_class = _get_ctx_api_class(self.__class__)
-            assert isinstance(
-                self.api,
-                ctx_api_class,
-            ), f"Bound API of type {self.api.__class__.__name__!r} is incompatible with {ctx_api_class.__name__!r}."
             return self.api
 
         def to_dict(self, *, exclude_fields=None):

telegrinder/bot/cute_types/callback_query.py

@@ -4,7 +4,9 @@ from contextlib import suppress
 import msgspec
 from fntypes.co import Nothing, Result, Some, Variative, unwrapping
 
-from telegrinder.api import ABCAPI, APIError
+from telegrinder.api import API, APIError
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
+from telegrinder.bot.cute_types.message import MediaType, MessageCute, ReplyMarkup, execute_method_edit
 from telegrinder.model import get_params
 from telegrinder.msgspec_utils import Option, decoder
 from telegrinder.types.objects import (
@@ -21,12 +23,9 @@ from telegrinder.types.objects import (
     User,
 )
 
-from .base import BaseCute, compose_method_params, shortcut
-from .message import MediaType, MessageCute, ReplyMarkup, execute_method_edit
 
-
-class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True, dict=True):
-    api: ABCAPI
+class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
+    api: API
 
     message: Option[Variative[MessageCute, InaccessibleMessage]] = Nothing()
     """Optional. Message sent by the bot with the callback button that originated

telegrinder/bot/cute_types/chat_join_request.py

@@ -2,15 +2,14 @@ import typing
 
 from fntypes.result import Result
 
-from telegrinder.api.abc import ABCAPI, APIError
+from telegrinder.api import API, APIError
+from telegrinder.bot.cute_types.base import BaseCute, shortcut
+from telegrinder.bot.cute_types.chat_member_updated import ChatMemberShortcuts, chat_member_interaction
 from telegrinder.types.objects import ChatJoinRequest, User
 
-from .base import BaseCute, shortcut
-from .chat_member_updated import ChatMemberShortcuts, chat_member_interaction
-
 
 class ChatJoinRequestCute(BaseCute[ChatJoinRequest], ChatJoinRequest, ChatMemberShortcuts, kw_only=True):
-    api: ABCAPI
+    api: API
 
     @property
     def from_user(self) -> User:

telegrinder/bot/cute_types/chat_member_updated.py

@@ -3,12 +3,11 @@ from datetime import datetime
 
 from fntypes.result import Result
 
-from telegrinder.api import ABCAPI, APIError
+from telegrinder.api import API, APIError
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
 from telegrinder.model import get_params
 from telegrinder.types.objects import ChatMemberUpdated, ChatPermissions, User
 
-from .base import BaseCute, compose_method_params, shortcut
-
 
 async def chat_member_interaction(
     update: BaseCute[typing.Any],
@@ -234,7 +233,7 @@ class ChatMemberShortcuts:
 class ChatMemberUpdatedCute(
     BaseCute[ChatMemberUpdated], ChatMemberUpdated, ChatMemberShortcuts, kw_only=True
 ):
-    api: ABCAPI
+    api: API
 
     @property
     def from_user(self) -> User:

telegrinder/bot/cute_types/inline_query.py

@@ -2,7 +2,8 @@ import typing
 
 from fntypes.result import Result
 
-from telegrinder.api import ABCAPI, APIError
+from telegrinder.api import API, APIError
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
 from telegrinder.model import get_params
 from telegrinder.types import (
     InlineQuery,
@@ -11,11 +12,9 @@ from telegrinder.types import (
     User,
 )
 
-from .base import BaseCute, compose_method_params, shortcut
-
 
 class InlineQueryCute(BaseCute[InlineQuery], InlineQuery, kw_only=True):
-    api: ABCAPI
+    api: API
 
     @property
     def from_user(self) -> User:

telegrinder/bot/cute_types/message.py

@@ -5,7 +5,14 @@ import typing
 import fntypes.option
 from fntypes.co import Result, Some, Variative
 
-from telegrinder.api import ABCAPI, APIError
+from telegrinder.api import API, APIError
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
+from telegrinder.bot.cute_types.utils import (
+    compose_link_preview_options,
+    compose_reactions,
+    compose_reply_params,
+    input_media,
+)
 from telegrinder.model import get_params
 from telegrinder.msgspec_utils import Nothing, Option
 from telegrinder.types.objects import (
@@ -30,14 +37,6 @@ from telegrinder.types.objects import (
     User,
 )
 
-from .base import BaseCute, compose_method_params, shortcut
-from .utils import (
-    compose_link_preview_options,
-    compose_reactions,
-    compose_reply_params,
-    input_media,
-)
-
 if typing.TYPE_CHECKING:
     from datetime import datetime
 
@@ -154,7 +153,7 @@ def get_entity_value(
 
 
 class MessageCute(BaseCute[Message], Message, kw_only=True):
-    api: ABCAPI
+    api: API
 
     reply_to_message: Option[MessageCute] = Nothing
     """Optional. For replies in the same chat and message thread, the original

telegrinder/bot/cute_types/update.py

@@ -2,22 +2,21 @@ import typing
 
 from fntypes.co import Nothing, Some
 
-from telegrinder.api import ABCAPI
+from telegrinder.api import API
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+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.msgspec_utils import Option
 from telegrinder.types import Model, Update
 
-from .base import BaseCute
-from .callback_query import CallbackQueryCute
-from .chat_join_request import ChatJoinRequestCute
-from .chat_member_updated import ChatMemberUpdatedCute
-from .inline_query import InlineQueryCute
-from .message import MessageCute
-
 ModelT = typing.TypeVar("ModelT", bound=Model)
 
 
 class UpdateCute(BaseCute[Update], Update, kw_only=True):
-    api: ABCAPI
+    api: API
 
     message: Option[MessageCute] = Nothing()
     """Optional. New incoming message of any kind - text, photo, sticker, etc."""

telegrinder/bot/cute_types/utils.py

@@ -1,7 +1,7 @@
 import typing
 
 from telegrinder.model import get_params
-from telegrinder.types import (
+from telegrinder.types.objects import (
     InputFile,
     InputMediaAnimation,
     InputMediaAudio,

telegrinder/bot/dispatch/__init__.py

@@ -1,10 +1,10 @@
-from .abc import ABCDispatch
-from .context import Context
-from .dispatch import Dispatch, TelegrinderContext
-from .handler import ABCHandler, FuncHandler, MessageReplyHandler
-from .middleware import ABCMiddleware
-from .process import check_rule, process_inner
-from .return_manager import (
+from telegrinder.bot.dispatch.abc import ABCDispatch
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.dispatch import Dispatch, TelegrinderContext
+from telegrinder.bot.dispatch.handler import ABCHandler, FuncHandler, MessageReplyHandler
+from telegrinder.bot.dispatch.middleware import ABCMiddleware
+from telegrinder.bot.dispatch.process import check_rule, process_inner
+from telegrinder.bot.dispatch.return_manager import (
     ABCReturnManager,
     BaseReturnManager,
     CallbackQueryReturnManager,
@@ -13,7 +13,7 @@ from .return_manager import (
     MessageReturnManager,
     register_manager,
 )
-from .view import (
+from telegrinder.bot.dispatch.view import (
     ABCStateView,
     ABCView,
     BaseStateView,
@@ -26,7 +26,7 @@ from .view import (
     RawEventView,
     ViewBox,
 )
-from .waiter_machine import ShortState, WaiterMachine, clear_wm_storage_worker
+from telegrinder.bot.dispatch.waiter_machine import ShortState, WaiterMachine, clear_wm_storage_worker
 
 __all__ = (
     "ABCDispatch",

telegrinder/bot/dispatch/abc.py

@@ -1,7 +1,7 @@
 import typing
 from abc import ABC, abstractmethod
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.tools.global_context.abc import ABCGlobalContext
 from telegrinder.types.objects import Update
 
@@ -13,7 +13,7 @@ class ABCDispatch(ABC):
         pass
 
     @abstractmethod
-    async def feed(self, event: Update, api: ABCAPI) -> bool:
+    async def feed(self, event: Update, api: API) -> bool:
         pass
 
     @abstractmethod

telegrinder/bot/dispatch/context.py

@@ -68,13 +68,22 @@ class Context(dict[str, AnyValue]):
     def set(self, key: Key, value: AnyValue) -> None:
         self[key] = value
 
-    def get(self, key: Key, default: T | None = None) -> T | AnyValue:
+    @typing.overload
+    def get(self, key: Key) -> AnyValue | None: ...
+
+    @typing.overload
+    def get(self, key: Key, default: T) -> T | AnyValue: ...
+
+    @typing.overload
+    def get(self, key: Key, default: None = None) -> AnyValue | None: ...
+
+    def get(self, key: Key, default: T | None = None) -> T | AnyValue | None:
         return dict.get(self, key, default)
 
     def get_or_set(self, key: Key, default: T) -> T:
         if key not in self:
             self.set(key, default)
-        return self.get(key)
+        return self.get(key, default)
 
     def delete(self, key: Key) -> None:
         del self[key]

telegrinder/bot/dispatch/dispatch.py

@@ -1,23 +1,14 @@
-import asyncio
 import dataclasses
 import typing
 
 from vbml.patcher import Patcher
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.cute_types.update import UpdateCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.bot.dispatch.abc import ABCDispatch
 from telegrinder.bot.dispatch.handler.func import ErrorHandlerT, FuncHandler
-from telegrinder.modules import logger
-from telegrinder.tools.error_handler.error_handler import ErrorHandler
-from telegrinder.tools.global_context import TelegrinderContext
-from telegrinder.types.enums import UpdateType
-from telegrinder.types.objects import Update
-
-from .abc import ABCDispatch
-from .view.box import (
+from telegrinder.bot.dispatch.view.box import (
     CallbackQueryView,
     ChatJoinRequestView,
     ChatMemberView,
@@ -26,6 +17,11 @@ from .view.box import (
     RawEventView,
     ViewBox,
 )
+from telegrinder.modules import logger
+from telegrinder.tools.error_handler.error_handler import ErrorHandler
+from telegrinder.tools.global_context import TelegrinderContext
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Update
 
 if typing.TYPE_CHECKING:
     from telegrinder.bot.rules.abc import ABCRule
@@ -49,10 +45,6 @@ class Dispatch(
         RawEventView,
     ],
 ):
-    default_handlers: list[ABCHandler] = dataclasses.field(
-        init=False,
-        default_factory=lambda: [],
-    )
     _global_context: TelegrinderContext = dataclasses.field(
         init=False,
         default_factory=lambda: TelegrinderContext(),
@@ -166,35 +158,28 @@ class Dispatch(
                 error_handler=error_handler or ErrorHandler(),
                 update_type=update_type,
             )
-            self.default_handlers.append(handler)
+            self.raw_event.handlers.append(handler)
             return handler
 
         return wrapper
 
-    async def feed(self, event: Update, api: ABCAPI) -> bool:
-        logger.debug("Processing update (update_id={})", event.update_id)
-        await self.raw_event.process(event, api)
-
+    async def feed(self, event: Update, api: API) -> bool:
+        logger.debug(
+            "Processing update (update_id={}, update_type={!r})",
+            event.update_id,
+            event.update_type.name,
+        )
         for view in self.get_views().values():
             if await view.check(event):
                 logger.debug(
-                    "Update (update_id={}) matched view {!r}.",
+                    "Update (update_id={}, update_type={!r}) matched view {!r}.",
                     event.update_id,
+                    event.update_type.name,
                     view,
                 )
                 if await view.process(event, api):
                     return True
-
-        ctx = Context(raw_update=event)
-        loop = asyncio.get_running_loop()
-        found = False
-        for handler in self.default_handlers:
-            if await handler.check(api, event, ctx):
-                found = True
-                loop.create_task(handler.run(api, event, ctx))
-                if handler.is_blocking:
-                    break
-        return found
+        return False
 
     def load(self, external: typing.Self) -> None:
         view_external = external.get_views()

telegrinder/bot/dispatch/handler/__init__.py

@@ -1,5 +1,5 @@
-from .abc import ABCHandler
-from .func import FuncHandler
-from .message_reply import MessageReplyHandler
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.bot.dispatch.handler.func import FuncHandler
+from telegrinder.bot.dispatch.handler.message_reply import MessageReplyHandler
 
 __all__ = ("ABCHandler", "FuncHandler", "MessageReplyHandler")

telegrinder/bot/dispatch/handler/abc.py

@@ -1,7 +1,7 @@
 import typing
 from abc import ABC, abstractmethod
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.model import Model
 from telegrinder.types.objects import Update
@@ -13,11 +13,11 @@ class ABCHandler(ABC, typing.Generic[T]):
     is_blocking: bool
 
     @abstractmethod
-    async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
+    async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
         pass
 
     @abstractmethod
-    async def run(self, api: ABCAPI, event: T, ctx: Context) -> typing.Any:
+    async def run(self, api: API, event: T, ctx: Context) -> typing.Any:
         pass