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

telegrinder/bot/dispatch/handler/func.py

@@ -3,7 +3,7 @@ from functools import cached_property
 
 import typing_extensions as typing
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.cute_types import BaseCute, UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.process import check_rule
@@ -56,27 +56,27 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
     def required_nodes(self) -> dict[str, type[Node]]:
         return get_nodes(self.func)
 
-    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:
         if self.update_type is not None and self.update_type != event.update_type:
             return False
 
+        logger.debug("Checking handler {!r}...", self)
         ctx = Context(raw_update=event) if ctx is None else ctx
         temp_ctx = ctx.copy()
         temp_ctx |= self.preset_context
 
         nodes = self.required_nodes
         node_col = None
+        update = event
 
         if nodes:
-            node_col = await compose_nodes(
-                UpdateCute.from_update(event, api),
-                ctx,
-                nodes,
-            )
-
-            if node_col is None:
+            result = await compose_nodes(nodes, ctx, data={Update: event, API: api})
+            if not result:
+                logger.debug(f"Cannot compose nodes for handler. {result.error}")
                 return False
-            temp_ctx |= node_col.values()
+
+            node_col = result.value
+            temp_ctx |= node_col.values
 
             if EVENT_NODE_KEY in ctx:
                 for name, node in nodes.items():
@@ -84,15 +84,18 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
                         ctx[EVENT_NODE_KEY] = temp_ctx.pop(name)
 
         for rule in self.rules:
-            if not await check_rule(api, rule, event, temp_ctx):
+            if not await check_rule(api, rule, update, temp_ctx):
                 logger.debug("Rule {!r} failed!", rule)
                 return False
 
+        logger.debug("All checks passed for handler.")
+
         temp_ctx["node_col"] = node_col
         ctx |= temp_ctx
         return True
 
-    async def run(self, api: ABCAPI, event: Event, ctx: Context) -> typing.Any:
+    async def run(self, api: API, event: Event, ctx: Context) -> typing.Any:
+        logger.debug(f"Running func handler {self.func}")
         dataclass_type = typing.get_origin(self.dataclass) or self.dataclass
 
         if dataclass_type is Update and (event_node := ctx.pop(EVENT_NODE_KEY, None)) is not None:
@@ -106,8 +109,10 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
                     if issubclass(dataclass_type, BaseCute)
                     else self.dataclass(**update.to_dict())  # type: ignore
                 )
+
             elif issubclass(dataclass_type, UpdateCute) and isinstance(event, Update):
                 event = self.dataclass.from_update(event, bound_api=api)  # type: ignore
+
             else:
                 event = self.dataclass(**event.to_dict())  # type: ignore
 

telegrinder/bot/dispatch/handler/message_reply.py

@@ -1,15 +1,14 @@
 import typing
 
-from telegrinder.api.abc import ABCAPI
-from telegrinder.bot.cute_types import MessageCute
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
 from telegrinder.bot.dispatch.process import check_rule
 from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.modules import logger
 from telegrinder.types.objects import ReplyParameters, Update
 
-from .abc import ABCHandler
-
 
 class MessageReplyHandler(ABCHandler[MessageCute]):
     def __init__(
@@ -36,8 +35,8 @@ class MessageReplyHandler(ABCHandler[MessageCute]):
             self.text,
         )
 
-    async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
-        ctx = Context() if ctx is None else ctx
+    async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
+        ctx = Context(raw_update=event) if ctx is None else ctx
         temp_ctx = ctx.copy()
         temp_ctx |= self.preset_context
 
@@ -49,7 +48,7 @@ class MessageReplyHandler(ABCHandler[MessageCute]):
         ctx |= temp_ctx
         return True
 
-    async def run(self, _: ABCAPI, event: MessageCute, __: Context) -> typing.Any:
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
         await event.answer(
             text=self.text,
             reply_parameters=ReplyParameters(event.message_id) if self.as_reply else None,

telegrinder/bot/dispatch/middleware/__init__.py

@@ -1,3 +1,3 @@
-from .abc import ABCMiddleware
+from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
 
 __all__ = ("ABCMiddleware",)

telegrinder/bot/dispatch/process.py

@@ -2,7 +2,7 @@ import typing
 
 from fntypes.result import Error, Ok
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types.update import UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
@@ -18,11 +18,10 @@ if typing.TYPE_CHECKING:
     from telegrinder.bot.rules.abc import ABCRule
 
 Event = typing.TypeVar("Event", bound=Model)
-_: typing.TypeAlias = typing.Any
 
 
 async def process_inner(
-    api: ABCAPI,
+    api: API,
     event: Event,
     raw_event: Update,
     middlewares: list[ABCMiddleware[Event]],
@@ -31,10 +30,13 @@ async def process_inner(
 ) -> bool:
     logger.debug("Processing {!r}...", event.__class__.__name__)
     ctx = Context(raw_update=raw_event)
-    ctx[CONTEXT_STORE_NODES_KEY] = {}  # for per-event shared nodes
+    ctx[CONTEXT_STORE_NODES_KEY] = {}  # For per-event shared nodes
 
+    logger.debug("Run pre middlewares...")
     for middleware in middlewares:
-        if await middleware.pre(event, ctx) is False:
+        middleware_result = await middleware.pre(event, ctx)
+        logger.debug("Middleware {!r} returned {!r}", middleware.__class__.__name__, middleware_result)
+        if middleware_result is False:
             return False
 
     found = False
@@ -43,6 +45,7 @@ async def process_inner(
 
     for handler in handlers:
         if await handler.check(api, raw_event, ctx):
+            logger.debug("Handler {!r} matched, run...", handler)
             found = True
             response = await handler.run(api, event, ctx)
             logger.debug("Handler {!r} returned: {!r}", handler, response)
@@ -54,17 +57,24 @@ async def process_inner(
 
         ctx = ctx_copy
 
+    logger.debug("Run post middlewares...")
     for middleware in middlewares:
+        logger.debug("Run post middleware {!r}", middleware.__class__.__name__)
         await middleware.post(event, responses, ctx)
 
     for session in ctx.get(CONTEXT_STORE_NODES_KEY, {}).values():
         await session.close(scopes=(NodeScope.PER_EVENT,))
 
+    logger.debug(
+        "{} handlers, returns {!r}",
+        "No found" if not found else "Found",
+        found,
+    )
     return found
 
 
 async def check_rule(
-    api: ABCAPI,
+    api: API,
     rule: "ABCRule",
     update: Update,
     ctx: Context,
@@ -73,13 +83,21 @@ async def check_rule(
     Returns check result."""
 
     # Running adapter
-    match await rule.adapter.adapt(api, update):
+    match await rule.adapter.adapt(api, update, ctx):
         case Ok(value):
             adapted_value = value
         case Error(err):
             logger.debug("Adapter failed with error message: {!r}", str(err))
             return False
 
+    # Preparing update
+    if isinstance(adapted_val := ctx.get(rule.adapter.ADAPTED_VALUE_KEY or ""), UpdateCute):
+        update = adapted_val
+    elif isinstance(adapted_value, UpdateCute):
+        update = adapted_value
+    else:
+        update = UpdateCute.from_update(update, bound_api=api)
+
     # Running subrules to fetch requirements
     ctx_copy = ctx.copy()
     for requirement in rule.requires:
@@ -88,7 +106,7 @@ async def check_rule(
 
     # Translating translatable rules
     if I18nEnum.I18N in ctx:
-        rule = await rule.translate(ctx.get(I18nEnum.I18N))
+        rule = await rule.translate(ctx[I18nEnum.I18N])
 
     ctx |= ctx_copy
 
@@ -96,12 +114,13 @@ async def check_rule(
     nodes = rule.required_nodes
     node_col = None
     if nodes:
-        node_col = await compose_nodes(UpdateCute.from_update(update, api), ctx, nodes)
-        if node_col is None:
+        result = await compose_nodes(nodes, ctx, data={Update: update, API: api})
+        if not result:
             return False
+        node_col = result.value
 
     # Running check
-    result = await rule.bounding_check(adapted_value, ctx, node_col)
+    result = await rule.bounding_check(adapted_value, ctx, node_col=node_col)
 
     # Closing node sessions if there are any
     if node_col is not None:

telegrinder/bot/dispatch/return_manager/__init__.py

@@ -1,12 +1,12 @@
-from .abc import (
+from telegrinder.bot.dispatch.return_manager.abc import (
     ABCReturnManager,
     BaseReturnManager,
     Manager,
     register_manager,
 )
-from .callback_query import CallbackQueryReturnManager
-from .inline_query import InlineQueryReturnManager
-from .message import MessageReturnManager
+from telegrinder.bot.dispatch.return_manager.callback_query import CallbackQueryReturnManager
+from telegrinder.bot.dispatch.return_manager.inline_query import InlineQueryReturnManager
+from telegrinder.bot.dispatch.return_manager.message import MessageReturnManager
 
 __all__ = (
     "ABCReturnManager",

telegrinder/bot/dispatch/return_manager/callback_query.py

@@ -2,8 +2,7 @@ import typing
 
 from telegrinder.bot.cute_types import CallbackQueryCute
 from telegrinder.bot.dispatch.context import Context
-
-from .abc import BaseReturnManager, register_manager
+from telegrinder.bot.dispatch.return_manager.abc import BaseReturnManager, register_manager
 
 
 class CallbackQueryReturnManager(BaseReturnManager[CallbackQueryCute]):

telegrinder/bot/dispatch/return_manager/inline_query.py

@@ -2,8 +2,7 @@ import typing
 
 from telegrinder.bot.cute_types import InlineQueryCute
 from telegrinder.bot.dispatch.context import Context
-
-from .abc import BaseReturnManager, register_manager
+from telegrinder.bot.dispatch.return_manager.abc import BaseReturnManager, register_manager
 
 
 class InlineQueryReturnManager(BaseReturnManager[InlineQueryCute]):

telegrinder/bot/dispatch/return_manager/message.py

@@ -2,10 +2,9 @@ import typing
 
 from telegrinder.bot.cute_types import MessageCute
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.return_manager.abc import BaseReturnManager, register_manager
 from telegrinder.tools.formatting import HTMLFormatter
 
-from .abc import BaseReturnManager, register_manager
-
 
 class MessageReturnManager(BaseReturnManager[MessageCute]):
     @register_manager(str)

telegrinder/bot/dispatch/view/__init__.py

@@ -1,11 +1,11 @@
-from .abc import ABCStateView, ABCView, BaseStateView, BaseView
-from .box import ViewBox
-from .callback_query import CallbackQueryView
-from .chat_join_request import ChatJoinRequestView
-from .chat_member import ChatMemberView
-from .inline_query import InlineQueryView
-from .message import MessageView
-from .raw import RawEventView
+from telegrinder.bot.dispatch.view.abc import ABCStateView, ABCView, BaseStateView, BaseView
+from telegrinder.bot.dispatch.view.box import ViewBox
+from telegrinder.bot.dispatch.view.callback_query import CallbackQueryView
+from telegrinder.bot.dispatch.view.chat_join_request import ChatJoinRequestView
+from telegrinder.bot.dispatch.view.chat_member import ChatMemberView
+from telegrinder.bot.dispatch.view.inline_query import InlineQueryView
+from telegrinder.bot.dispatch.view.message import MessageView
+from telegrinder.bot.dispatch.view.raw import RawEventView
 
 __all__ = (
     "ABCStateView",

telegrinder/bot/dispatch/view/abc.py

@@ -4,7 +4,7 @@ from functools import cached_property
 
 from fntypes.co import Nothing, Some
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
 from telegrinder.bot.dispatch.handler.func import FuncHandler
@@ -29,14 +29,14 @@ FuncType: typing.TypeAlias = typing.Callable[
 
 class ABCView(ABC):
     def __repr__(self) -> str:
-        return "<{!r}>".format(self.__class__.__name__)
+        return "<{}>".format(self.__class__.__name__)
 
     @abstractmethod
     async def check(self, event: Update) -> bool:
         pass
 
     @abstractmethod
-    async def process(self, event: Update, api: ABCAPI) -> bool:
+    async def process(self, event: Update, api: API) -> bool:
         pass
 
     @abstractmethod
@@ -44,6 +44,10 @@ class ABCView(ABC):
         pass
 
 
+class ABCEventRawView(ABCView, ABC, typing.Generic[Event]):
+    handlers: list[ABCHandler[Event]]
+
+
 class ABCStateView(ABCView, typing.Generic[Event]):
     @abstractmethod
     def get_state_key(self, event: Event) -> int | None:
@@ -184,7 +188,7 @@ class BaseView(ABCView, typing.Generic[Event]):
             case _:
                 return False
 
-    async def process(self, event: Update, api: ABCAPI) -> bool:
+    async def process(self, event: Update, api: API) -> bool:
         return await process_inner(
             api,
             self.get_event_type.unwrap().from_update(
@@ -211,6 +215,7 @@ class BaseStateView(ABCStateView[Event], BaseView[Event], ABC, typing.Generic[Ev
 
 __all__ = (
     "ABCStateView",
+    "ABCEventRawView",
     "ABCView",
     "BaseStateView",
     "BaseView",

telegrinder/bot/dispatch/view/box.py

@@ -10,7 +10,7 @@ from telegrinder.bot.dispatch.view import (
     message,
     raw,
 )
-from telegrinder.bot.dispatch.view.abc import ABCView
+from telegrinder.bot.dispatch.view.abc import ABCEventRawView, ABCView
 from telegrinder.types.enums import UpdateType
 
 CallbackQueryView = typing.TypeVar(
@@ -22,7 +22,7 @@ ChatJoinRequestView = typing.TypeVar(
 ChatMemberView = typing.TypeVar("ChatMemberView", bound=ABCView, default=chat_member.ChatMemberView)
 InlineQueryView = typing.TypeVar("InlineQueryView", bound=ABCView, default=inline_query.InlineQueryView)
 MessageView = typing.TypeVar("MessageView", bound=ABCView, default=message.MessageView)
-RawEventView = typing.TypeVar("RawEventView", bound=ABCView, default=raw.RawEventView)
+RawEventView = typing.TypeVar("RawEventView", bound=ABCEventRawView, default=raw.RawEventView)
 
 
 @dataclasses.dataclass(kw_only=True)

telegrinder/bot/dispatch/view/callback_query.py

@@ -1,7 +1,6 @@
 from telegrinder.bot.cute_types import CallbackQueryCute
 from telegrinder.bot.dispatch.return_manager import CallbackQueryReturnManager
-
-from .abc import BaseStateView
+from telegrinder.bot.dispatch.view.abc import BaseStateView
 
 
 class CallbackQueryView(BaseStateView[CallbackQueryCute]):

telegrinder/bot/dispatch/view/chat_join_request.py

@@ -1,6 +1,5 @@
 from telegrinder.bot.cute_types import ChatJoinRequestCute
-
-from .abc import BaseStateView
+from telegrinder.bot.dispatch.view.abc import BaseStateView
 
 
 class ChatJoinRequestView(BaseStateView[ChatJoinRequestCute]):

telegrinder/bot/dispatch/view/chat_member.py

@@ -1,9 +1,9 @@
 import typing
 
 from telegrinder.bot.cute_types import ChatMemberUpdatedCute
+from telegrinder.bot.dispatch.view.abc import BaseStateView
 from telegrinder.types.enums import UpdateType
-
-from .abc import BaseStateView
+from telegrinder.types.objects import Update
 
 ChatMemberUpdateType: typing.TypeAlias = typing.Literal[
     UpdateType.CHAT_MEMBER,
@@ -19,8 +19,22 @@ class ChatMemberView(BaseStateView[ChatMemberUpdatedCute]):
         self.return_manager = None
         self.update_type = update_type
 
+    def __repr__(self) -> str:
+        return "<{}: {!r}>".format(
+            self.__class__.__name__,
+            "chat_member_updated" if self.update_type is None else self.update_type.value,
+        )
+
     def get_state_key(self, event: ChatMemberUpdatedCute) -> int | None:
         return event.chat_id
 
 
+    async def check(self, event: Update) -> bool:
+        return not (
+            self.update_type is not None
+            and self.update_type != event.update_type
+            or not await super().check(event)
+        )
+
+
 __all__ = ("ChatMemberView",)

telegrinder/bot/dispatch/view/inline_query.py

@@ -1,7 +1,6 @@
 from telegrinder.bot.cute_types import InlineQueryCute
 from telegrinder.bot.dispatch.return_manager import InlineQueryReturnManager
-
-from .abc import BaseStateView
+from telegrinder.bot.dispatch.view.abc import BaseStateView
 
 
 class InlineQueryView(BaseStateView[InlineQueryCute]):

telegrinder/bot/dispatch/view/message.py

@@ -2,10 +2,9 @@ import typing
 
 from telegrinder.bot.cute_types import MessageCute
 from telegrinder.bot.dispatch.return_manager import MessageReturnManager
+from telegrinder.bot.dispatch.view.abc import BaseStateView
 from telegrinder.types import Update, UpdateType
 
-from .abc import BaseStateView
-
 MessageUpdateType: typing.TypeAlias = typing.Literal[
     UpdateType.MESSAGE,
     UpdateType.BUSINESS_MESSAGE,

telegrinder/bot/dispatch/view/raw.py

@@ -1,14 +1,14 @@
 import typing
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.cute_types import UpdateCute
 from telegrinder.bot.dispatch.handler.func import FuncHandler
 from telegrinder.bot.dispatch.process import process_inner
+from telegrinder.bot.dispatch.view.abc import ABCEventRawView, BaseView, ErrorHandlerT
 from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
-from telegrinder.types import Update, UpdateType
-
-from .abc import BaseView, ErrorHandlerT
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Update
 
 T = typing.TypeVar("T")
 
@@ -18,7 +18,7 @@ FuncType: typing.TypeAlias = typing.Callable[
 ]
 
 
-class RawEventView(BaseView[UpdateCute]):
+class RawEventView(ABCEventRawView[UpdateCute], BaseView[UpdateCute]):
     def __init__(self) -> None:
         self.auto_rules = []
         self.handlers = []
@@ -88,7 +88,7 @@ class RawEventView(BaseView[UpdateCute]):
         def wrapper(func: FuncType[typing.Any]):
             func_handler = FuncHandler(
                 func,
-                [*self.auto_rules, *rules],
+                rules=[*self.auto_rules, *rules],
                 is_blocking=is_blocking,
                 dataclass=dataclass,
                 error_handler=error_handler or ErrorHandler(),
@@ -100,11 +100,9 @@ class RawEventView(BaseView[UpdateCute]):
         return wrapper
 
     async def check(self, event: Update) -> bool:
-        return False
+        return bool(self.handlers) or bool(self.middlewares)
 
-    async def process(self, event: Update, api: ABCAPI) -> bool:
-        if not self.handlers or not self.middlewares:
-            return False
+    async def process(self, event: Update, api: API) -> bool:
         return await process_inner(
             api,
             UpdateCute.from_update(event, bound_api=api),

telegrinder/bot/dispatch/waiter_machine/__init__.py

@@ -1,6 +1,6 @@
-from .machine import WaiterMachine, clear_wm_storage_worker
-from .middleware import WaiterMiddleware
-from .short_state import ShortState
+from telegrinder.bot.dispatch.waiter_machine.machine import WaiterMachine, clear_wm_storage_worker
+from telegrinder.bot.dispatch.waiter_machine.middleware import WaiterMiddleware
+from telegrinder.bot.dispatch.waiter_machine.short_state import ShortState
 
 __all__ = (
     "ShortState",

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -2,16 +2,20 @@ import asyncio
 import datetime
 import typing
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.view.abc import ABCStateView, BaseStateView
+from telegrinder.bot.dispatch.waiter_machine.middleware import WaiterMiddleware
+from telegrinder.bot.dispatch.waiter_machine.short_state import (
+    Behaviour,
+    EventModel,
+    ShortState,
+    ShortStateContext,
+)
 from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.tools.limited_dict import LimitedDict
 from telegrinder.types import Update
 
-from .middleware import WaiterMiddleware
-from .short_state import Behaviour, EventModel, ShortState, ShortStateContext
-
 if typing.TYPE_CHECKING:
     from telegrinder.bot.dispatch import Dispatch
 
@@ -67,7 +71,7 @@ class WaiterMachine:
     async def wait(
         self,
         state_view: "BaseStateView[EventModel]",
-        linked: EventModel | tuple[ABCAPI, Identificator],
+        linked: EventModel | tuple[API, Identificator],
         *rules: ABCRule,
         default: Behaviour[EventModel] | None = None,
         on_drop: Behaviour[EventModel] | None = None,
@@ -77,7 +81,7 @@ class WaiterMachine:
         if isinstance(expiration, int | float):
             expiration = datetime.timedelta(seconds=expiration)
 
-        api: ABCAPI
+        api: API
         key: Identificator
         api, key = linked if isinstance(linked, tuple) else (linked.ctx_api, state_view.get_state_key(linked))  # type: ignore
         if not key:

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -3,7 +3,7 @@ import dataclasses
 import datetime
 import typing
 
-from telegrinder.api import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
@@ -27,7 +27,7 @@ class ShortStateContext(typing.Generic[EventModel], typing.NamedTuple):
 @dataclasses.dataclass(slots=True)
 class ShortState(typing.Generic[EventModel]):
     key: "Identificator"
-    ctx_api: ABCAPI
+    ctx_api: API
     event: asyncio.Event
     rules: tuple[ABCRule, ...]
     expiration: dataclasses.InitVar[datetime.timedelta | None] = dataclasses.field(

telegrinder/bot/polling/abc.py

@@ -3,7 +3,7 @@ from abc import ABC, abstractmethod
 
 import msgspec
 
-from telegrinder.types import Update
+from telegrinder.types.objects import Update
 
 
 class ABCPolling(ABC):

telegrinder/bot/polling/polling.py

@@ -5,18 +5,18 @@ import aiohttp
 import msgspec
 from fntypes.result import Error, Ok
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.api.error import InvalidTokenError
 from telegrinder.bot.polling.abc import ABCPolling
 from telegrinder.modules import logger
 from telegrinder.msgspec_utils import decoder
-from telegrinder.types import Update, UpdateType
+from telegrinder.types.objects import Update, UpdateType
 
 
 class Polling(ABCPolling):
     def __init__(
         self,
-        api: ABCAPI,
+        api: API,
         *,
         offset: int = 0,
         reconnection_timeout: float = 5,