telegrinder 0.1.dev166__py3-none-any.whl → 0.1.dev167__py3-none-any.whl

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -41,19 +41,20 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         short_state: "ShortState[EventType] | None" = self.machine.storage[view_name].get(key)
         if not short_state:
             return True
-
+        
+        preset_context = Context(short_state=short_state)
         if (
             short_state.expiration_date is not None
             and datetime.datetime.now() >= short_state.expiration_date
         ):
-            await self.machine.drop(self.view, short_state.key)
+            await self.machine.drop(self.view, short_state.key, ctx.raw_update, **preset_context.copy())
             return True
 
         handler = FuncHandler(
             self.pass_runtime,
             list(short_state.rules),
             dataclass=None,
-            preset_context=Context(short_state=short_state),
+            preset_context=preset_context,
         )
         result = await handler.check(event.ctx_api, ctx.raw_update, ctx)
 
@@ -63,14 +64,20 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         elif short_state.default_behaviour is not None:
             await self.machine.call_behaviour(
                 self.view,
-                short_state.default_behaviour,
                 event,
+                ctx.raw_update,
+                behaviour=short_state.default_behaviour,
                 **handler.preset_context,
             )
 
         return False
 
-    async def pass_runtime(self, event: EventType, short_state: "ShortState[EventType]", ctx: Context) -> None:
+    async def pass_runtime(
+        self,
+        event: EventType,
+        short_state: "ShortState[EventType]",
+        ctx: Context,
+    ) -> None:
         setattr(short_state.event, "context", (event, ctx))
         short_state.event.set()
 

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -7,13 +7,15 @@ 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
+from telegrinder.model import Model
 
 if typing.TYPE_CHECKING:
     from .machine import Identificator
 
+T = typing.TypeVar("T", bound=Model)
 EventModel = typing.TypeVar("EventModel", bound=BaseCute)
 
-Behaviour: typing.TypeAlias = ABCHandler | None
+Behaviour: typing.TypeAlias = ABCHandler[T] | None
 
 
 @dataclasses.dataclass
@@ -26,14 +28,12 @@ class ShortState(typing.Generic[EventModel]):
     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)
+    default_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None)
+    on_drop_behaviour: Behaviour[EventModel] | 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
-        )
+        self.expiration_date = (datetime.datetime.now() - expiration) if expiration is not None else None
 
 
 __all__ = ("ShortState",)

telegrinder/bot/polling/polling.py

@@ -29,9 +29,7 @@ class Polling(ABCPolling):
             include_updates=include_updates,
             exclude_updates=exclude_updates,
         )
-        self.reconnection_timeout = (
-            5 if reconnection_timeout < 0 else reconnection_timeout
-        )
+        self.reconnection_timeout = 5 if reconnection_timeout < 0 else reconnection_timeout
         self.max_reconnetions = 10 if max_reconnetions < 0 else max_reconnetions
         self.offset = offset
         self._stop = False
@@ -62,9 +60,7 @@ class Polling(ABCPolling):
 
         if include_updates and exclude_updates:
             allowed_updates = [
-                x
-                for x in allowed_updates
-                if x in include_updates and x not in exclude_updates
+                x for x in allowed_updates if x in include_updates and x not in exclude_updates
             ]
         elif exclude_updates:
             allowed_updates = [x for x in allowed_updates if x not in exclude_updates]

telegrinder/bot/rules/adapter/event.py

@@ -45,9 +45,7 @@ class EventAdapter(ABCAdapter[Update, CuteT]):
                     AdapterError(f"Update is not an {self.event!r}."),
                 )
             return Ok(
-                self.cute_model.from_update(
-                    update_dct[self.event].unwrap(), bound_api=api
-                ),
+                self.cute_model.from_update(update_dct[self.event].unwrap(), bound_api=api),
             )
         event = update_dct[update.update_type.unwrap()].unwrap()
         if not update.update_type or not issubclass(event.__class__, self.event):

telegrinder/bot/rules/callback_data.py

@@ -16,7 +16,9 @@ from .markup import Markup, PatternLike, check_string
 
 CallbackQuery: typing.TypeAlias = CallbackQueryCute
 Validator: typing.TypeAlias = typing.Callable[[typing.Any], bool | typing.Awaitable[bool]]
-MapDict: typing.TypeAlias = dict[str, "typing.Any | type[typing.Any] | Validator | list[MapDict] | MapDict"]
+MapDict: typing.TypeAlias = dict[
+    str, "typing.Any | type[typing.Any] | Validator | list[MapDict] | MapDict"
+]
 CallbackMap: typing.TypeAlias = list[tuple[str, "typing.Any | type | Validator | CallbackMap"]]
 CallbackMapStrict: typing.TypeAlias = list[tuple[str, "Validator | CallbackMapStrict"]]
 

telegrinder/bot/rules/fuzzy.py

@@ -15,8 +15,7 @@ class FuzzyText(TextMessageRule):
 
     async def check(self, message: Message, ctx: Context) -> bool:
         match = max(
-            difflib.SequenceMatcher(a=message.text.unwrap(), b=text).ratio()
-            for text in self.texts
+            difflib.SequenceMatcher(a=message.text.unwrap(), b=text).ratio() for text in self.texts
         )
         if match < self.min_ratio:
             return False

telegrinder/bot/rules/is_from.py

@@ -42,7 +42,9 @@ class IsForward(MessageRule):
 
 
 class IsForwardType(MessageRule, requires=[IsForward()]):
-    def __init__(self, fwd_type: typing.Literal["user", "hidden_user", "chat", "channel"], /) -> None:
+    def __init__(
+        self, fwd_type: typing.Literal["user", "hidden_user", "chat", "channel"], /
+    ) -> None:
         self.fwd_type = fwd_type
 
     async def check(self, message: Message, ctx: Context) -> bool:
@@ -80,8 +82,8 @@ class IsLanguageCode(ABCRule[T], requires=[HasFrom()]):
 
     async def check(self, event: UpdateCute, ctx: Context) -> bool:
         return (
-            get_from_user(event.incoming_update.unwrap())
-            .language_code.unwrap_or_none() in self.lang_codes
+            get_from_user(event.incoming_update.unwrap()).language_code.unwrap_or_none()
+            in self.lang_codes
         )
 
 
@@ -131,7 +133,7 @@ class IsDiceEmoji(MessageRule, requires=[HasDice()]):
         self.dice_emoji = dice_emoji
 
     async def check(self, message: Message, ctx: Context) -> bool:
-        return message.dice.unwrap().emoji == self.dice_emoji 
+        return message.dice.unwrap().emoji == self.dice_emoji
 
 
 __all__ = (

telegrinder/bot/rules/markup.py

@@ -28,8 +28,7 @@ class Markup(TextMessageRule):
         if not isinstance(patterns, list):
             patterns = [patterns]
         self.patterns = [
-            vbml.Pattern(pattern) if isinstance(pattern, str) else pattern
-            for pattern in patterns
+            vbml.Pattern(pattern) if isinstance(pattern, str) else pattern for pattern in patterns
         ]
 
     async def check(self, message: Message, ctx: Context) -> bool:

telegrinder/bot/rules/mention.py

@@ -8,10 +8,7 @@ class HasMention(TextMessageRule):
     async def check(self, message: Message, ctx: Context) -> bool:
         if not message.entities.unwrap_or_none():
             return False
-        return any(
-            entity.type == MessageEntityType.MENTION
-            for entity in message.entities.unwrap()
-        )
+        return any(entity.type == MessageEntityType.MENTION for entity in message.entities.unwrap())
 
 
 __all__ = ("HasMention",)

telegrinder/bot/rules/regex.py

@@ -19,8 +19,7 @@ class Regex(TextMessageRule):
                 self.regexp.append(re.compile(regex))
             case _:
                 self.regexp.extend(
-                    re.compile(regexp) if isinstance(regexp, str) else regexp
-                    for regexp in regexp
+                    re.compile(regexp) if isinstance(regexp, str) else regexp for regexp in regexp
                 )
 
     async def check(self, message: Message, ctx: Context) -> bool:

telegrinder/bot/rules/rule_enum.py

@@ -21,9 +21,7 @@ class RuleEnum(ABCRule[T]):
     __enum__: list[RuleEnumState]
 
     def __init_subclass__(cls, *args, **kwargs):
-        new_attributes = (
-            set(cls.__dict__) - set(RuleEnum.__dict__) - {"__enum__", "__init__"}
-        )
+        new_attributes = set(cls.__dict__) - set(RuleEnum.__dict__) - {"__enum__", "__init__"}
         enum_lst: list[RuleEnumState] = []
 
         self = cls.__new__(cls)

telegrinder/bot/rules/start.py

@@ -30,9 +30,7 @@ class StartCommand(
 
     async def check(self, _: Message, ctx: Context) -> bool:
         param: str | None = ctx.pop("param", None)
-        validated_param = (
-            self.validator(param) if self.validator and param is not None else param
-        )
+        validated_param = self.validator(param) if self.validator and param is not None else param
 
         if self.param_required and validated_param is None:
             return False

telegrinder/bot/scenario/checkbox.py

@@ -69,11 +69,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
                 choice = choices.pop(0)
                 kb.add(
                     InlineButton(
-                        text=(
-                            choice.default_text
-                            if not choice.is_picked
-                            else choice.picked_text
-                        ),
+                        text=(choice.default_text if not choice.is_picked else choice.picked_text),
                         callback_data=self.random_code + "/" + choice.code,
                     )
                 )

telegrinder/client/aiohttp.py

@@ -42,9 +42,7 @@ class AiohttpClient(ABCClient):
     ) -> "ClientResponse":
         if not self.session:
             self.session = ClientSession(
-                connector=TCPConnector(
-                    ssl=ssl.create_default_context(cafile=certifi.where())
-                ),
+                connector=TCPConnector(ssl=ssl.create_default_context(cafile=certifi.where())),
                 json_serialize=self.json_processing_module.dumps,
                 **self.session_params,
             )

telegrinder/model.py

@@ -10,11 +10,11 @@ from fntypes.co import Nothing, Result, Some
 
 from .msgspec_utils import decoder, encoder, get_origin
 
-T = typing.TypeVar("T")
-
 if typing.TYPE_CHECKING:
     from telegrinder.api.error import APIError
 
+T = typing.TypeVar("T")
+
 
 MODEL_CONFIG: typing.Final[dict[str, typing.Any]] = {
     "omit_defaults": True,
@@ -25,7 +25,8 @@ MODEL_CONFIG: typing.Final[dict[str, typing.Any]] = {
 
 @typing.overload
 def full_result(
-    result: Result[msgspec.Raw, "APIError"], full_t: type[T]
+    result: Result[msgspec.Raw, "APIError"],
+    full_t: type[T],
 ) -> Result[T, "APIError"]: ...
 
 

telegrinder/modules.py

@@ -147,9 +147,7 @@ elif logging_module == "logging":
     for level, settings in LEVEL_SETTINGS.items():
         fmt = FORMAT
         for name, color in settings.items():
-            fmt = fmt.replace(f"<{name}>", COLORS[color]).replace(
-                f"</{name}>", COLORS["reset"]
-            )
+            fmt = fmt.replace(f"<{name}>", COLORS[color]).replace(f"</{name}>", COLORS["reset"])
         LEVEL_FORMATS[level] = fmt
 
     class TelegrinderLoggingFormatter(logging.Formatter):

telegrinder/msgspec_utils.py

@@ -66,9 +66,7 @@ def variative_dec_hook(tp: type[Variative], obj: typing.Any) -> Variative:
         union_types = tuple(t for t in union_types if t not in struct_fields_match_sums)
         reverse = False
 
-        if len(set(struct_fields_match_sums.values())) != len(
-            struct_fields_match_sums.values()
-        ):
+        if len(set(struct_fields_match_sums.values())) != len(struct_fields_match_sums.values()):
             struct_fields_match_sums = {
                 m: len(m.__struct_fields__) for m in struct_fields_match_sums
             }

telegrinder/node/attachment.py

@@ -14,21 +14,15 @@ from .message import MessageNode
 class Attachment(DataNode):
     attachment_type: typing.Literal["audio", "document", "photo", "poll", "video"]
     _: dataclasses.KW_ONLY
-    audio: Option[telegrinder.types.Audio] = dataclasses.field(
-        default_factory=lambda: Nothing()
-    )
+    audio: Option[telegrinder.types.Audio] = dataclasses.field(default_factory=lambda: Nothing())
     document: Option[telegrinder.types.Document] = dataclasses.field(
         default_factory=lambda: Nothing()
     )
     photo: Option[list[telegrinder.types.PhotoSize]] = dataclasses.field(
         default_factory=lambda: Nothing()
     )
-    poll: Option[telegrinder.types.Poll] = dataclasses.field(
-        default_factory=lambda: Nothing()
-    )
-    video: Option[telegrinder.types.Video] = dataclasses.field(
-        default_factory=lambda: Nothing()
-    )
+    poll: Option[telegrinder.types.Poll] = dataclasses.field(default_factory=lambda: Nothing())
+    video: Option[telegrinder.types.Video] = dataclasses.field(default_factory=lambda: Nothing())
 
     @classmethod
     async def compose(cls, message: MessageNode) -> "Attachment":
@@ -44,31 +38,41 @@ class Photo(DataNode):
 
     @classmethod
     async def compose(cls, attachment: Attachment) -> typing.Self:
-        return cls(attachment.photo.expect(ComposeError("Attachment is not an photo")))
+        if not attachment.photo:
+            raise ComposeError("Attachment is not an photo")
+        return cls(attachment.photo.unwrap())
 
 
 class Video(ScalarNode, telegrinder.types.Video):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Video:
-        return attachment.video.expect(ComposeError("Attachment is not an video"))
+        if not attachment.video:
+            raise ComposeError("Attachment is not an video")
+        return attachment.video.unwrap()
 
 
 class Audio(ScalarNode, telegrinder.types.Audio):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Audio:
-        return attachment.audio.expect(ComposeError("Attachment is not an audio"))
+        if not attachment.audio:
+            raise ComposeError("Attachment is not an audio")
+        return attachment.audio.unwrap()
 
 
 class Document(ScalarNode, telegrinder.types.Document):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Document:
-        return attachment.document.expect(ComposeError("Attachment is not an document"))
+        if not attachment.document:
+            raise ComposeError("Attachment is not an document")
+        return attachment.document.unwrap()
 
 
 class Poll(ScalarNode, telegrinder.types.Poll):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Poll:
-        return attachment.poll.expect(ComposeError("Attachment is not an poll"))
+        if not attachment.poll:
+            raise ComposeError("Attachment is not an poll")
+        return attachment.poll.unwrap()
 
 
 __all__ = (

telegrinder/node/base.py

@@ -3,8 +3,7 @@ import inspect
 import typing
 
 ComposeResult: typing.TypeAlias = (
-    typing.Coroutine[typing.Any, typing.Any, typing.Any]
-    | typing.AsyncGenerator[typing.Any, None]
+    typing.Coroutine[typing.Any, typing.Any, typing.Any] | typing.AsyncGenerator[typing.Any, None]
 )
 
 
@@ -16,9 +15,7 @@ class Node(abc.ABC):
 
     @classmethod
     @abc.abstractmethod
-    def compose(
-        cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any
-    ) -> ComposeResult:
+    def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
         pass
 
     @classmethod
@@ -52,18 +49,14 @@ class DataNode(Node, abc.ABC):
     @typing.dataclass_transform()
     @classmethod
     @abc.abstractmethod
-    async def compose(
-        cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any
-    ) -> ComposeResult:
+    async def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
         pass
 
 
 class ScalarNodeProto(Node, abc.ABC):
     @classmethod
     @abc.abstractmethod
-    async def compose(
-        cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any
-    ) -> ComposeResult:
+    async def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
         pass
 
 

telegrinder/node/composer.py

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

telegrinder/node/message.py

@@ -9,8 +9,10 @@ from .update import UpdateNode
 class MessageNode(ScalarNode, MessageCute):
     @classmethod
     async def compose(cls, update: UpdateNode) -> typing.Self:
+        if not update.message:
+            raise ComposeError
         return cls(
-            **update.message.expect(ComposeError).to_dict(),
+            **update.message.unwrap().to_dict(),
             api=update.api,
         )
 

telegrinder/node/source.py

@@ -24,7 +24,9 @@ class Source(DataNode):
 
     async def send(self, text: str) -> Message:
         result = await self.api.send_message(
-            self.chat.id, message_thread_id=self.thread_id, text=text
+            chat_id=self.chat.id,
+            message_thread_id=self.thread_id,
+            text=text,
         )
         return result.unwrap()
 

telegrinder/node/text.py

@@ -7,7 +7,9 @@ from .message import MessageNode
 class Text(ScalarNode, str):
     @classmethod
     async def compose(cls, message: MessageNode) -> typing.Self:
-        return cls(message.text.expect(ComposeError("Message has no text")))
+        if not message.text:
+            raise ComposeError("Message has no text")
+        return cls(message.text.unwrap())
 
 
 __all__ = ("Text",)

telegrinder/tools/__init__.py

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

telegrinder/tools/buttons.py

@@ -63,15 +63,13 @@ class InlineButton(BaseButton):
     url: str | None = None
     login_url: dict[str, typing.Any] | LoginUrl | None = None
     pay: bool | None = None
-    callback_data: (
-        str | dict[str, typing.Any] | DataclassInstance | msgspec.Struct | None
-    ) = None
+    callback_data: str | dict[str, typing.Any] | DataclassInstance | msgspec.Struct | None = None
     callback_game: dict[str, typing.Any] | CallbackGame | None = None
     switch_inline_query: str | None = None
     switch_inline_query_current_chat: str | None = None
-    switch_inline_query_chosen_chat: (
-        dict[str, typing.Any] | SwitchInlineQueryChosenChat | None
-    ) = None
+    switch_inline_query_chosen_chat: dict[str, typing.Any] | SwitchInlineQueryChosenChat | None = (
+        None
+    )
     web_app: dict[str, typing.Any] | WebAppInfo | None = None
 
 

telegrinder/tools/error_handler/abc.py

@@ -16,9 +16,7 @@ class ABCErrorHandler(ABC, typing.Generic[EventT]):
         self,
         *args: typing.Any,
         **kwargs: typing.Any,
-    ) -> typing.Callable[
-        [typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]
-    ]:
+    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]]:
         """Decorator for registering callback as an error handler."""
 
     @abstractmethod

telegrinder/tools/error_handler/error.py

@@ -1,10 +1,7 @@
-import typing
-
-
-class CatcherError(TypeError):
-    def __init__(self, exc: typing.Any, error: str) -> None:
+class CatcherError(BaseException):
+    def __init__(self, exc: BaseException, message: str) -> None:
         self.exc = exc
-        self.error = error
+        self.message = message
 
 
 __all__ = ("CatcherError",)

telegrinder/tools/error_handler/error_handler.py

@@ -13,9 +13,7 @@ from .error import CatcherError
 
 F = typing.TypeVar("F", bound="FuncCatcher")
 ExceptionT = typing.TypeVar("ExceptionT", bound=BaseException, contravariant=True)
-FuncCatcher = typing.Callable[
-    typing.Concatenate[ExceptionT, ...], typing.Awaitable[typing.Any]
-]
+FuncCatcher = typing.Callable[typing.Concatenate[ExceptionT, ...], typing.Awaitable[typing.Any]]
 
 
 @dataclasses.dataclass(frozen=True, repr=False)
@@ -59,8 +57,7 @@ class Catcher(typing.Generic[EventT]):
     ) -> Result[typing.Any, BaseException]:
         if self.match_exception(exception):
             logger.debug(
-                "Catcher {!r} caught an exception in handler {!r}, "
-                "running catcher...".format(
+                "Catcher {!r} caught an exception in handler {!r}, " "running catcher...".format(
                     self.func.__name__,
                     handler_name,
                 )
@@ -109,7 +106,8 @@ class ErrorHandler(ABCErrorHandler[EventT]):
         ignore_errors: bool = False,
     ):
         """Register the catcher.
-        :param logging: Error logging in stderr.
+
+        :param logging: Logging the result of the catcher at the level 'DEBUG'.
         :param raise_exception: Raise an exception if the catcher hasn't started.
         :param ignore_errors: Ignore errors that may occur.
         """
@@ -142,21 +140,21 @@ class ErrorHandler(ABCErrorHandler[EventT]):
             return Error(
                 CatcherError(
                     exc,
-                    "Exception {!r} was occurred during the running catcher {!r}.".format(
+                    "Exception {} was occurred during the running catcher {!r}.".format(
                         repr(exc), self.catcher.func.__name__
                     ),
                 )
             )
 
-    def process_catcher_error(self, error: CatcherError) -> Result[None, str]:
+    def process_catcher_error(self, error: CatcherError) -> Result[None, BaseException]:
         assert self.catcher is not None
 
         if self.catcher.raise_exception:
             raise error.exc from None
-        if not self.catcher.ignore_errors:
-            return Error(error.error)
         if self.catcher.logging:
-            logger.error(error.error)
+            logger.error(error.message)
+        if not self.catcher.ignore_errors:
+            return Error(error.exc)
 
         return Ok(None)
 
@@ -166,12 +164,18 @@ class ErrorHandler(ABCErrorHandler[EventT]):
         event: EventT,
         api: ABCAPI,
         ctx: Context,
-    ) -> Result[typing.Any, typing.Any]:
+    ) -> Result[typing.Any, BaseException]:
         if not self.catcher:
             return Ok(await handler(event, **magic_bundle(handler, ctx)))  # type: ignore
 
         match await self.process(handler, event, api, ctx):
-            case Ok(_) as ok:
+            case Ok(value) as ok:
+                if self.catcher.logging:
+                    logger.debug(
+                        "Catcher {!r} returned a value: {!r}",
+                        self.catcher.func.__name__,
+                        value,
+                    )
                 return ok
             case Error(exc) as err:
                 if isinstance(exc, CatcherError):

telegrinder/tools/formatting/html.py

@@ -49,9 +49,7 @@ class StringFormatter(string.Formatter):
             )
         return fmt
 
-    def get_spec_formatter(
-        self, value: SpecialFormat
-    ) -> typing.Callable[..., "TagFormat"]:
+    def get_spec_formatter(self, value: SpecialFormat) -> typing.Callable[..., "TagFormat"]:
         return globals()[value.__formatter_name__]
 
     def check_formats(self, value: typing.Any, fmts: list[str]) -> "TagFormat":
@@ -241,9 +239,7 @@ def start_bot_link(bot_id: str | int, data: str, string: str | None = None) -> T
     return link(get_start_bot_link(bot_id, data), string)
 
 
-def start_group_link(
-    bot_id: str | int, data: str, string: str | None = None
-) -> TagFormat:
+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)
 
 

telegrinder/tools/formatting/links.py

@@ -29,9 +29,7 @@ def get_invite_chat_link(invite_link: str) -> str:
 
 
 def user_open_message_link(user_id: int, message: str | None = None) -> str:
-    return f"tg://openmessage?user_id={user_id}" + (
-        "" if not message else f"&msg?text={message}"
-    )
+    return f"tg://openmessage?user_id={user_id}" + ("" if not message else f"&msg?text={message}")
 
 
 __all__ = (