telegrinder 0.3.4.post1__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/tools/error_handler/error_handler.py

@@ -6,29 +6,18 @@ from fntypes.result import Error, Ok, Result
 from telegrinder.api.api import API
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.modules import logger
-from telegrinder.node.base import is_node
-from telegrinder.tools.error_handler.abc import ABCErrorHandler, Event, Handler
+from telegrinder.tools.error_handler.abc import ABCErrorHandler
 from telegrinder.tools.error_handler.error import CatcherError
-from telegrinder.tools.magic import get_annotations, magic_bundle
+from telegrinder.tools.magic import magic_bundle
 
-F = typing.TypeVar("F", bound="FuncCatcher[typing.Any]")
-ExceptionT = typing.TypeVar("ExceptionT", bound=BaseException, contravariant=True)
-FuncCatcher = typing.Callable[typing.Concatenate[ExceptionT, ...], typing.Awaitable[typing.Any]]
-
-
-async def run_handler(
-    handler: Handler,
-    event: typing.Any,
-    ctx: dict[str, typing.Any],
-) -> typing.Any:
-    annotations = tuple(get_annotations(handler).values())
-    start_idx = 0 if is_node(None if not annotations else annotations[0]) else 1
-    context = magic_bundle(handler, ctx, start_idx=start_idx)
-    return await (handler(event, **context) if start_idx == 1 else handler(**context))
+type FuncCatcher[Exc: BaseException] = typing.Callable[
+    typing.Concatenate[Exc, ...],
+    typing.Awaitable[typing.Any],
+]
 
 
 @dataclasses.dataclass(frozen=True, repr=False, slots=True)
-class Catcher(typing.Generic[Event]):
+class Catcher[Event]:
     func: FuncCatcher[BaseException]
     exceptions: list[type[BaseException] | BaseException] = dataclasses.field(
         default_factory=lambda: [],
@@ -48,15 +37,12 @@ class Catcher(typing.Generic[Event]):
 
     async def __call__(
         self,
-        handler: Handler,
+        exception: BaseException,
         event: Event,
         api: API,
         ctx: Context,
     ) -> Result[typing.Any, BaseException]:
-        try:
-            return Ok(await run_handler(handler, event, ctx))
-        except BaseException as exc:
-            return await self.run(api, event, ctx, exc, handler.__name__)
+        return await self.run(api, event, ctx, exception)
 
     def match_exception(self, exception: BaseException) -> bool:
         for exc in self.exceptions:
@@ -73,27 +59,27 @@ class Catcher(typing.Generic[Event]):
         event: Event,
         ctx: Context,
         exception: BaseException,
-        handler_name: str,
     ) -> Result[typing.Any, BaseException]:
         if self.match_exception(exception):
             logger.debug(
-                "Error handler caught an exception {!r} in handler {!r}, running catcher {!r}...".format(
-                    exception, handler_name, self.func.__name__
+                "Error handler caught an exception {!r}, running catcher {!r}...".format(
+                    exception,
+                    self.func.__name__,
                 )
             )
-            return Ok(await run_handler(self.func, event, {"event": event, "api": api} | ctx))
+            return Ok(await self.func(exception, **magic_bundle(self.func, {"event": event, "api": api} | ctx)))
 
         logger.debug("Failed to match exception {!r}.", exception.__class__.__name__)
         return Error(exception)
 
 
-class ErrorHandler(ABCErrorHandler[Event]):
+class ErrorHandler[Event](ABCErrorHandler[Event]):
     def __init__(self, catcher: Catcher[Event] | None = None, /) -> None:
         self.catcher = catcher
 
     def __repr__(self) -> str:
         return (
-            "<{}: exceptions_handled=[{}], catcher={!r}>".format(
+            "<{}: exceptions=[{}], catcher={!r}>".format(
                 self.__class__.__name__,
                 ", ".join(e.__name__ if isinstance(e, type) else repr(e) for e in self.catcher.exceptions),
                 self.catcher,
@@ -116,16 +102,16 @@ class ErrorHandler(ABCErrorHandler[Event]):
         :param ignore_errors: Ignore errors that may occur.
         """
 
-        def decorator(func: F) -> F:
+        def decorator[Func: FuncCatcher](catcher: Func, /) -> Func:
             if not self.catcher:
                 self.catcher = Catcher(
-                    func,
+                    catcher,
                     exceptions=list(exceptions),
                     logging=logging,
                     raise_exception=raise_exception,
                     ignore_errors=ignore_errors,
                 )
-            return func
+            return catcher
 
         return decorator
 
@@ -141,53 +127,53 @@ class ErrorHandler(ABCErrorHandler[Event]):
 
         return Ok(None)
 
-    async def process(
+    async def suppress(
         self,
-        handler: Handler,
+        exception: BaseException,
         event: Event,
         api: API,
         ctx: Context,
     ) -> Result[typing.Any, BaseException]:
         assert self.catcher is not None
-        logger.debug("Processing the error handler for handler {!r}...", handler.__name__)
 
         try:
-            return await self.catcher(handler, event, api, ctx)
+            return await self.catcher(exception, event, api, ctx)
         except BaseException as exc:
             return Error(
                 CatcherError(
                     exc,
-                    "Exception {} was occurred during the running catcher {!r}.".format(
-                        repr(exc), self.catcher.func.__name__
+                    "{!r} was occurred during the running catcher {!r}.".format(
+                        exc,
+                        self.catcher.func.__name__,
                     ),
                 )
             )
 
     async def run(
         self,
-        handler: Handler,
+        exception: BaseException,
         event: Event,
         api: API,
         ctx: Context,
-    ) -> Result[typing.Any, BaseException]:
+    ) -> typing.Any:
         if not self.catcher:
-            return Ok(await run_handler(handler, event, ctx))
+            raise exception from None
 
-        match await self.process(handler, event, api, ctx):
-            case Ok(value) as ok:
+        match await self.suppress(exception, event, api, ctx):
+            case Ok(value):
                 if self.catcher.logging:
                     logger.debug(
                         "Catcher {!r} returned: {!r}",
                         self.catcher.func.__name__,
                         value,
                     )
-                return ok
-            case Error(exc) as err:
+                return value
+            case Error(exc):
                 if isinstance(exc, CatcherError):
-                    return self._process_catcher_error(exc)
+                    return self._process_catcher_error(exc).unwrap()
                 if self.catcher.ignore_errors:
-                    return Ok(None)
-                return err
+                    return None
+                raise exc from None
 
 
 __all__ = ("Catcher", "ErrorHandler")

telegrinder/tools/formatting/__init__.py

@@ -1,81 +1,101 @@
-from .html import (
+from .deep_links import (
+    tg_bot_attach_open_any_chat,
+    tg_bot_attach_open_current_chat,
+    tg_bot_attach_open_specific_chat,
+    tg_bot_start_link,
+    tg_bot_startchannel_link,
+    tg_bot_startgroup_link,
+    tg_chat_folder_link,
+    tg_chat_invite_link,
+    tg_direct_mini_app_link,
+    tg_emoji_link,
+    tg_emoji_stickerset_link,
+    tg_invoice_link,
+    tg_language_pack_link,
+    tg_main_mini_app_link,
+    tg_mention_link,
+    tg_open_message_link,
+    tg_premium_multigift_link,
+    tg_premium_offer_link,
+    tg_private_channel_boost_link,
+    tg_private_message_link,
+    tg_public_channel_boost_link,
+    tg_public_message_link,
+    tg_public_username_link,
+    tg_share_link,
+    tg_story_link,
+)
+from .html_formatter import (
     FormatString,
     HTMLFormatter,
     block_quote,
     bold,
-    channel_boost_link,
     code_inline,
     escape,
-    invite_chat_link,
     italic,
     link,
     mention,
     pre_code,
-    resolve_domain,
     spoiler,
-    start_bot_link,
-    start_group_link,
     strike,
     tg_emoji,
     underline,
 )
-from .links import (
-    get_channel_boost_link,
-    get_invite_chat_link,
-    get_mention_link,
-    get_resolve_domain_link,
-    get_start_bot_link,
-    get_start_group_link,
-)
 from .spec_html_formats import (
-    BaseSpecFormat,
-    ChannelBoostLink,
-    InviteChatLink,
+    Base,
+    BlockQuote,
     Link,
     Mention,
     PreCode,
-    ResolveDomain,
     SpecialFormat,
-    StartBotLink,
-    StartGroupLink,
     TgEmoji,
 )
 
 __all__ = (
-    "BaseSpecFormat",
-    "ChannelBoostLink",
+    "Base",
+    "BlockQuote",
     "FormatString",
     "HTMLFormatter",
-    "InviteChatLink",
     "Link",
     "Mention",
     "PreCode",
-    "ResolveDomain",
     "SpecialFormat",
-    "StartBotLink",
-    "StartGroupLink",
     "TgEmoji",
     "block_quote",
     "bold",
-    "channel_boost_link",
     "code_inline",
     "escape",
-    "get_channel_boost_link",
-    "get_invite_chat_link",
-    "get_mention_link",
-    "get_resolve_domain_link",
-    "get_start_bot_link",
-    "get_start_group_link",
-    "invite_chat_link",
     "italic",
     "link",
     "mention",
     "pre_code",
-    "resolve_domain",
     "spoiler",
-    "start_bot_link",
-    "start_group_link",
     "strike",
+    "tg_bot_attach_open_any_chat",
+    "tg_bot_attach_open_current_chat",
+    "tg_bot_attach_open_specific_chat",
+    "tg_bot_start_link",
+    "tg_bot_startchannel_link",
+    "tg_bot_startgroup_link",
+    "tg_chat_folder_link",
+    "tg_chat_invite_link",
+    "tg_direct_mini_app_link",
     "tg_emoji",
+    "tg_emoji_link",
+    "tg_emoji_stickerset_link",
+    "tg_invoice_link",
+    "tg_language_pack_link",
+    "tg_main_mini_app_link",
+    "tg_mention_link",
+    "tg_open_message_link",
+    "tg_premium_multigift_link",
+    "tg_premium_offer_link",
+    "tg_private_channel_boost_link",
+    "tg_private_message_link",
+    "tg_public_channel_boost_link",
+    "tg_public_message_link",
+    "tg_public_username_link",
+    "tg_share_link",
+    "tg_story_link",
     "underline",
 )