telegrinder 0.1.dev163__py3-none-any.whl → 0.1.dev165__py3-none-any.whl

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -19,12 +19,18 @@ if typing.TYPE_CHECKING:
 class WaiterMachine:
     def __init__(self) -> None:
         self.storage: Storage = {}
+    
+    def __repr__(self) -> str:
+        return "<{}: storage={!r}>".format(
+            self.__class__.__name__,
+            self.storage,
+        )
 
     async def drop(
         self,
         state_view: "ABCStateView[EventModel]",
         id: Identificator,
-        **context,
+        **context: typing.Any,
     ) -> None:
         view_name = state_view.__class__.__name__
         if view_name not in self.storage:
@@ -60,9 +66,9 @@ class WaiterMachine:
         *rules: ABCRule[EventModel],
         default: Behaviour = None,
         on_drop: Behaviour = None,
-        expiration: datetime.timedelta | int | None = None,
+        expiration: datetime.timedelta | int | float | None = None,
     ) -> tuple[EventModel, Context]:
-        if isinstance(expiration, int):
+        if isinstance(expiration, int | float):
             expiration = datetime.timedelta(seconds=expiration)
 
         api: ABCAPI
@@ -77,9 +83,9 @@ class WaiterMachine:
 
         short_state = ShortState(
             key,
-            ctx_api=api,
-            event=event,
-            rules=rules,
+            api,
+            event,
+            rules,
             expiration=expiration,
             default_behaviour=default,
             on_drop_behaviour=on_drop,
@@ -104,13 +110,13 @@ class WaiterMachine:
         view: "ABCStateView[EventModel]",
         behaviour: Behaviour,
         event: asyncio.Event | EventModel,
-        **context,
+        **context: typing.Any,
     ) -> None:
         if behaviour is None:
             return
         # TODO: add behaviour check
         # TODO: support view as a behaviour
-        await behaviour.run(event)
+        await behaviour.run(event, context)  # type: ignore
 
 
 __all__ = ("WaiterMachine",)

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -38,32 +38,34 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         if key is None:
             raise RuntimeError("Unable to get state key.")
 
-        short_state: typing.Optional["ShortState"] = self.machine.storage[view_name].get(key)
+        short_state: typing.Optional["ShortState[EventType]"] = self.machine.storage[view_name].get(key)
         if not short_state:
             return True
 
         if (
-            short_state.expiration is not None
-            and datetime.datetime.now() >= short_state.expiration
+            short_state.expiration_date is not None
+            and datetime.datetime.now() >= short_state.expiration_date
         ):
             await self.machine.drop(self.view, short_state.key)
             return True
         
         handler = FuncHandler(
-            self.pass_runtime, list(short_state.rules), dataclass=None
+            self.pass_runtime,
+            list(short_state.rules),
+            dataclass=None,
         )
-        handler.ctx.set("short_state", short_state)
+        handler.preset_context.set("short_state", short_state)
         result = await handler.check(event.ctx_api, ctx.raw_update, ctx)
 
         if result is True:
-            await handler.run(event)
+            await handler.run(event, ctx)
 
         elif short_state.default_behaviour is not None:
             await self.machine.call_behaviour(
                 self.view,
                 short_state.default_behaviour,
                 event,
-                **handler.ctx,
+                **handler.preset_context,
             )
 
         return False

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -1,8 +1,9 @@
 import asyncio
+import dataclasses
 import datetime
 import typing
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import ABCAPI
 from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
 from telegrinder.bot.rules.abc import ABCRule
@@ -14,24 +15,22 @@ EventModel = typing.TypeVar("EventModel", bound=BaseCute)
 Behaviour: typing.TypeAlias = ABCHandler | None
 
 
+@dataclasses.dataclass
 class ShortState(typing.Generic[EventModel]):
-    def __init__(
-        self,
-        key: "Identificator",
-        ctx_api: ABCAPI,
-        event: asyncio.Event,
-        rules: tuple[ABCRule[EventModel], ...],
-        expiration: datetime.timedelta | None = None,
-        default_behaviour: Behaviour | None = None,
-        on_drop_behaviour: Behaviour | None = None,
-    ) -> None:
-        self.key = key
-        self.ctx_api = ctx_api
-        self.event = event
-        self.rules = rules
-        self.default_behaviour = default_behaviour
-        self.expiration = (datetime.datetime.now() + expiration) if expiration else None
-        self.on_drop_behaviour = on_drop_behaviour
+    key: "Identificator"
+    ctx_api: ABCAPI
+    event: asyncio.Event
+    rules: tuple[ABCRule[EventModel], ...]
+    _: dataclasses.KW_ONLY
+    expiration: dataclasses.InitVar[datetime.timedelta | None] = dataclasses.field(default=None)
+    default_behaviour: Behaviour | None = dataclasses.field(default=None)
+    on_drop_behaviour: Behaviour | None = dataclasses.field(default=None)
+    expiration_date: datetime.datetime | None = dataclasses.field(init=False)
+
+    def __post_init__(self, expiration: datetime.timedelta | None = None) -> None:
+        self.expiration_date = (
+            datetime.datetime.now() - expiration
+        ) if expiration is not None else None
 
 
 __all__ = ("ShortState",)

telegrinder/bot/polling/polling.py

@@ -33,6 +33,20 @@ class Polling(ABCPolling):
         self.max_reconnetions = 10 if max_reconnetions < 0 else max_reconnetions
         self.offset = offset
         self._stop = False
+    
+    def __repr__(self) -> str:
+        return (
+            "<{}: with api={!r}, stopped={}, offset={}, allowed_updates={!r}, "
+            "max_reconnetions={}, reconnection_timeout={}>"
+        ).format(
+            self.__class__.__name__,
+            self.api,
+            self._stop,
+            self.offset,
+            self.allowed_updates,
+            self.max_reconnetions,
+            self.reconnection_timeout,
+        )
 
     def get_allowed_updates(
         self,

telegrinder/bot/rules/markup.py

@@ -24,7 +24,7 @@ def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
 
 
 class Markup(TextMessageRule):
-    def __init__(self, patterns: PatternLike | list[PatternLike]):
+    def __init__(self, patterns: PatternLike | list[PatternLike], /):
         if not isinstance(patterns, list):
             patterns = [patterns]
         self.patterns = [

telegrinder/bot/rules/text.py

@@ -14,7 +14,7 @@ class TextMessageRule(MessageRule, ABC, requires=[HasText()]):
 
 
 class Text(TextMessageRule):
-    def __init__(self, texts: str | list[str], ignore_case: bool = False):
+    def __init__(self, texts: str | list[str], *, ignore_case: bool = False) -> None:
         if not isinstance(texts, list):
             texts = [texts]
         self.texts = texts if not ignore_case else list(map(str.lower, texts))

telegrinder/bot/scenario/checkbox.py

@@ -45,6 +45,21 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         self.max_in_row = max_in_row
         self.random_code = secrets.token_hex(8)
         self.waiter_machine = waiter_machine
+    
+    def __repr__(self) -> str:
+        return (
+            "<{}@{!r}: (choices={!r}, max_in_row={}) with waiter_machine={!r}, ready_text={!r} "
+            "for chat_id={} with message={!r}>"
+        ).format(
+            self.__class__.__name__,
+            self.random_code,
+            self.choices,
+            self.max_in_row,
+            self.waiter_machine,
+            self.ready,
+            self.chat_id,
+            self.msg,
+        )
 
     def get_markup(self) -> InlineKeyboardMarkup:
         kb = InlineKeyboard()
@@ -70,6 +85,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         name: str,
         default_text: str,
         picked_text: str,
+        *,
         is_picked: bool = False,
     ) -> typing.Self:
         self.choices.append(

telegrinder/model.py

@@ -57,6 +57,10 @@ def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
 
 
 class Model(msgspec.Struct, **MODEL_CONFIG):
+    @classmethod
+    def from_bytes(cls, data: bytes) -> typing.Self:
+        return decoder.decode(data, type=cls)
+
     def to_dict(
         self,
         *,
@@ -76,6 +80,12 @@ class Model(msgspec.Struct, **MODEL_CONFIG):
 class DataConverter:
     files: dict[str, tuple[str, bytes]] = dataclasses.field(default_factory=lambda: {})
 
+    def __repr__(self) -> str:
+        return "<{}: {}>".format(
+            self.__class__.__name__,
+            ", ".join(f"{k}={v!r}" for k, v in self.converters),
+        )
+
     @property
     def converters(self) -> dict[type[typing.Any], typing.Callable[..., typing.Any]]:
         return {

telegrinder/msgspec_utils.py

@@ -51,8 +51,7 @@ def msgspec_convert(obj: typing.Any, t: type[T]) -> Result[T, msgspec.Validation
 def option_dec_hook(tp: type[Option[typing.Any]], obj: typing.Any) -> Option[typing.Any]:
     if obj is None:
         return Nothing
-    generic_args = typing.get_args(tp)
-    value_type: typing.Any | type[typing.Any] = typing.Any if not generic_args else generic_args[0]
+    value_type, = typing.get_args(tp) or (typing.Any,)
     return msgspec_convert({"value": obj}, fntypes.option.Some[value_type]).unwrap()
 
 
@@ -123,6 +122,12 @@ class Decoder:
             Variative: variative_dec_hook,
             datetime: lambda t, obj: t.fromtimestamp(obj),
         }
+    
+    def __repr__(self) -> str:
+        return "<{}: dec_hooks={!r}>".format(
+            self.__class__.__name__,
+            self.dec_hooks,
+        )
 
     def add_dec_hook(self, t: T):  # type: ignore
         def decorator(func: DecHook[T]) -> DecHook[T]:
@@ -216,6 +221,12 @@ class Encoder:
             datetime: lambda date: int(date.timestamp()),
         }
 
+    def __repr__(self) -> str:
+        return "<{}: enc_hooks={!r}>".format(
+            self.__class__.__name__,
+            self.enc_hooks,
+        )
+
     def add_dec_hook(self, t: type[T]):
         def decorator(func: EncHook[T]) -> EncHook[T]:
             encode_hook = self.enc_hooks.setdefault(get_origin(t), func)

telegrinder/node/base.py

@@ -6,7 +6,7 @@ ComposeResult: typing.TypeAlias = typing.Coroutine[typing.Any, typing.Any, typin
 
 
 class ComposeError(BaseException):
-    pass
+    ...
 
 
 class Node(abc.ABC):

telegrinder/node/composer.py

@@ -27,7 +27,7 @@ class NodeSession:
             self.generator = None
 
     def __repr__(self) -> str:
-        return f"<NodeSession {self.value}" + ("ACTIVE>" if self.generator else ">")
+        return f"<{self.__class__.__name__}: {self.value}" + ("ACTIVE>" if self.generator else ">")
 
 
 class NodeCollection:

telegrinder/tools/__init__.py

@@ -66,7 +66,7 @@ from .keyboard import (
     Keyboard,
     RowButtons,
 )
-from .loop_wrapper import ABCLoopWrapper, DelayedTask, LoopWrapper
+from .loop_wrapper import ABCLoopWrapper, DelayedTask, Lifespan, LoopWrapper
 from .magic import magic_bundle, resolve_arg_names
 from .parse_mode import ParseMode
 
@@ -99,6 +99,7 @@ __all__ = (
     "KeyboardSetBase",
     "KeyboardSetYAML",
     "Link",
+    "Lifespan",
     "LoopWrapper",
     "Mention",
     "ParseMode",

telegrinder/tools/error_handler/abc.py

@@ -13,12 +13,12 @@ Handler = typing.Callable[typing.Concatenate[EventT, ...], typing.Awaitable[typi
 
 class ABCErrorHandler(ABC, typing.Generic[EventT]):
     @abstractmethod
-    def register_catcher(
+    def __call__(
         self,
         *args: typing.Any,
         **kwargs: typing.Any,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]]:
-        ...
+        """Decorator for registering callback as an error handler."""
 
     @abstractmethod
     async def run(
@@ -28,7 +28,7 @@ class ABCErrorHandler(ABC, typing.Generic[EventT]):
         api: ABCAPI,
         ctx: Context,
     ) -> Result[typing.Any, typing.Any]:
-        ...
+        """Run error handler."""
 
 
 __all__ = ("ABCErrorHandler",)

telegrinder/tools/error_handler/error_handler.py

@@ -97,27 +97,8 @@ class ErrorHandler(ABCErrorHandler[EventT]):
             if self.catcher is not None
             else "<ErrorHandler: No catcher>"
         )
-    
-    async def __call__(
-        self,
-        handler: Handler[EventT],
-        event: EventT,
-        api: ABCAPI,
-        ctx: Context,
-    ) -> Result[typing.Any, BaseException]:
-        assert self.catcher is not None
 
-        try:
-            return await self.catcher(handler, event, api, ctx)
-        except BaseException as exc:
-            return Error(CatcherError(
-                exc,
-                "Exception {!r} was occurred during the running catcher {!r}.".format(
-                    repr(exc), self.catcher.func.__name__
-                )
-            ))
-    
-    def register_catcher(
+    def __call__(
         self,
         *exceptions: type[BaseException] | BaseException,
         logging: bool = False,
@@ -142,6 +123,25 @@ class ErrorHandler(ABCErrorHandler[EventT]):
             return func
         return decorator
     
+    async def process(
+        self,
+        handler: Handler[EventT],
+        event: EventT,
+        api: ABCAPI,
+        ctx: Context,
+    ) -> Result[typing.Any, BaseException]:
+        assert self.catcher is not None
+
+        try:
+            return await self.catcher(handler, event, api, ctx)
+        except BaseException as exc:
+            return Error(CatcherError(
+                exc,
+                "Exception {!r} was occurred during the running catcher {!r}.".format(
+                    repr(exc), self.catcher.func.__name__
+                )
+            ))
+        
     def process_catcher_error(self, error: CatcherError) -> Result[None, str]:
         assert self.catcher is not None
         
@@ -164,7 +164,7 @@ class ErrorHandler(ABCErrorHandler[EventT]):
         if not self.catcher:
             return Ok(await handler(event, **magic_bundle(handler, ctx)))  # type: ignore
         
-        match await self(handler, event, api, ctx):
+        match await self.process(handler, event, api, ctx):
             case Ok(_) as ok:
                 return ok
             case Error(exc) as err:

telegrinder/tools/formatting/html.py

@@ -200,11 +200,8 @@ def bold(string: str) -> TagFormat:
     return TagFormat(string, tag="b")
 
 
-def channel_boost_link(channel_username: str, string: str | None = None):
-    return link(
-        get_channel_boost_link(channel_username),
-        string or f"t.me/{channel_username}?boost",
-    )
+def channel_boost_link(channel_id: str | int, string: str | None = None):
+    return link(get_channel_boost_link(channel_id), string)
 
 
 def code_inline(string: str) -> TagFormat:
@@ -234,15 +231,12 @@ def spoiler(string: str) -> TagFormat:
     return TagFormat(string, tag="tg-spoiler")
 
 
-def start_bot_link(bot_username: str, data: str, string: str | None = None) -> TagFormat:
-    return link(
-        get_start_bot_link(bot_username, data),
-        string or f"t.me/{bot_username}?start={data}"
-    )
+def start_bot_link(bot_id: str | int, data: str, string: str | None = None) -> TagFormat:
+    return link(get_start_bot_link(bot_id, data), string)
 
 
-def start_group_link(bot_username: str, data: str, string: str | None = None) -> TagFormat:
-    return link(get_start_group_link(bot_username, data), string)
+def start_group_link(bot_id: str | int, data: str, string: str | None = None) -> TagFormat:
+    return link(get_start_group_link(bot_id, data), string)
 
 
 def strike(string: str) -> TagFormat:

telegrinder/tools/formatting/links.py

@@ -6,16 +6,22 @@ def get_resolve_domain_link(username: str) -> str:
     return f"tg://resolve?domain={username}"
 
 
-def get_start_bot_link(bot_username: str, data: str) -> str:
-    return get_resolve_domain_link(bot_username) + f"&start={data}"
+def get_start_bot_link(bot_id: str | int, data: str) -> str:
+    if isinstance(bot_id, int):
+        return get_mention_link(bot_id) + f"&start={data}"
+    return get_resolve_domain_link(bot_id) + f"&start={data}"
 
 
-def get_start_group_link(bot_username: str, data: str) -> str:
-    return get_resolve_domain_link(bot_username) + f"&startgroup={data}"
+def get_start_group_link(bot_id: str | int, data: str) -> str:
+    if isinstance(bot_id, int):
+        return get_mention_link(bot_id) + f"&startgroup={data}"
+    return get_resolve_domain_link(bot_id) + f"&startgroup={data}"
 
 
-def get_channel_boost_link(channel_username: str) -> str:
-    return get_resolve_domain_link(channel_username) + "&boost"
+def get_channel_boost_link(channel_id: str | int) -> str:
+    if isinstance(channel_id, int):
+        return get_mention_link(channel_id) + "&boost"
+    return get_resolve_domain_link(channel_id) + "&boost"
 
 
 def get_invite_chat_link(invite_link: str) -> str:

telegrinder/tools/formatting/spec_html_formats.py

@@ -3,14 +3,13 @@ import typing
 
 from telegrinder.types.enums import ProgrammingLanguage
 
-SpecialFormat = typing.Union[
+SpecialFormat: typing.TypeAlias = typing.Union[
     "ChannelBoostLink",
     "InviteChatLink",
     "Link",
     "Mention",
     "PreCode",
     "ResolveDomain",
-    "SpecialFormat",
     "StartBotLink",
     "StartGroupLink",
     "TgEmoji",
@@ -38,7 +37,7 @@ class BaseSpecFormat:
 class ChannelBoostLink(BaseSpecFormat):
     __formatter_name__ = "channel_boost_link"
 
-    channel_username: str
+    channel_id: str | int
     string: str | None = None
 
 
@@ -86,7 +85,7 @@ class TgEmoji(BaseSpecFormat):
 class StartBotLink(BaseSpecFormat):
     __formatter_name__ = "start_bot_link"
 
-    bot_username: str
+    bot_id: str | int
     data: str
     string: str | None
 
@@ -95,7 +94,7 @@ class StartBotLink(BaseSpecFormat):
 class StartGroupLink(BaseSpecFormat):
     __formatter_name__ = "start_group_link"
 
-    bot_username: str
+    bot_id: str | int
     data: str
     string: str | None = None
 

telegrinder/tools/global_context/global_context.py

@@ -199,8 +199,8 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
             self.set_context_variables(variables)
 
     def __repr__(self) -> str:
-        return "<{!r} -> ({})>".format(
-            f"{self.__class__.__name__}@{self.ctx_name}",
+        return "<{} -> ({})>".format(
+            f"{self.__class__.__name__}@{self.ctx_name!r}",
             ", ".join(repr(var) for var in self),
         )
 

telegrinder/tools/loop_wrapper/__init__.py

@@ -1,4 +1,4 @@
 from .abc import ABCLoopWrapper
-from .loop_wrapper import DelayedTask, LoopWrapper
+from .loop_wrapper import DelayedTask, Lifespan, LoopWrapper
 
-__all__ = ("ABCLoopWrapper", "DelayedTask", "LoopWrapper")
+__all__ = ("ABCLoopWrapper", "DelayedTask", "Lifespan", "LoopWrapper")

telegrinder/tools/loop_wrapper/abc.py

@@ -1,13 +1,10 @@
 import typing
 from abc import ABC, abstractmethod
 
-CoroutineTask: typing.TypeAlias = typing.Coroutine[typing.Any, typing.Any, typing.Any]
-CoroutineFunc: typing.TypeAlias = typing.Callable[..., CoroutineTask]
-
 
 class ABCLoopWrapper(ABC):
     @abstractmethod
-    def add_task(self, task: CoroutineFunc | CoroutineTask) -> None:
+    def add_task(self, task: typing.Any) -> None:
         pass
 
     @abstractmethod