telegrinder 0.1.dev20__py3-none-any.whl → 0.1.dev159__py3-none-any.whl

telegrinder/tools/error_handler/error_handler.py

@@ -0,0 +1,156 @@
+import dataclasses
+import typing
+
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api import ABCAPI
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.modules import logger
+from telegrinder.tools.magic import magic_bundle
+
+from .abc import ABCErrorHandler, EventT, Handler
+
+F = typing.TypeVar("F", bound="FuncCatcher")
+ExceptionT = typing.TypeVar("ExceptionT", bound=BaseException, contravariant=True)
+FuncCatcher = typing.Callable[typing.Concatenate[ExceptionT, ...], typing.Awaitable[typing.Any]]
+
+
+@dataclasses.dataclass(frozen=True)
+class Catcher(typing.Generic[EventT]):
+    func: FuncCatcher
+    _: dataclasses.KW_ONLY
+    exceptions: list[type[BaseException] | BaseException] = dataclasses.field(
+        default_factory=lambda: []
+    )
+    logging: bool = dataclasses.field(default=False)
+    raise_exception: bool = dataclasses.field(default=False)
+    ignore_errors: bool = dataclasses.field(default=False)
+
+    def match_exception(self, exception: BaseException) -> bool:
+        for exc in self.exceptions:
+            if isinstance(exc, type) and type(exception) == exc:
+                return True
+            if isinstance(exc, object) and type(exception) == type(exc):
+                return True if not exc.args else exc.args == exception.args
+        return False        
+
+    async def __call__(
+        self,
+        handler: Handler[EventT],
+        event: EventT,
+        api: ABCAPI,
+        ctx: Context,
+    ) -> Result[typing.Any, typing.Any]:
+        try:
+            result = Ok(await handler(event, **magic_bundle(handler, ctx)))  # type: ignore
+        except BaseException as exc:
+            logger.debug(
+                "Exception {!r} occurred while running handler {!r}. Matching  "
+                "exceptions it with exception that can be caught by the catcher {!r}...",
+                exc.__class__.__name__,
+                handler.__name__,
+                self.func.__name__,
+            )
+            
+            if self.match_exception(exc):
+                logger.debug(
+                    "Catcher {!r} caught an exception in handler {!r}, "
+                    "running catcher...".format(
+                        self.func.__name__,
+                        handler.__name__,
+                    )
+                )
+                result = Ok(
+                    await self.func(
+                        exc,
+                        **magic_bundle(
+                            self.func,
+                            {"event": event, "api": api} | ctx  # type: ignore
+                        )
+                    )
+                )
+            else:
+                logger.debug("Failed to match exception {!r}!", exc.__class__.__name__)
+                result = Error(exc)
+        
+        logger.debug(
+            "Catcher {!r} {} with result: {!r}",
+            self.func.__name__,
+            "completed" if result else "failed",
+            result,
+        )
+        return result
+    
+
+class ErrorHandler(ABCErrorHandler[EventT]):
+    def __init__(self, __catcher: Catcher[EventT] | None = None):
+        self.catcher = __catcher
+    
+    def __repr__(self) -> str:
+        return f"<ErrorHandler: {self.catcher!r}>"
+    
+    def catch(
+        self,
+        *exceptions: type[BaseException] | BaseException,
+        logging: bool = False,
+        raise_exception: bool = False,
+        ignore_errors: bool = False,
+    ):
+        """Catch an exception while the handler is running.
+        :param logging: Error logging in stderr.
+        :param raise_exception: Raise an exception if the catcher hasn't started.
+        :param ignore_errors: Ignore errors that may occur in the catcher.
+        """
+
+        def decorator(func: F) -> F:
+            if not self.catcher:
+                self.catcher = Catcher(
+                    func,
+                    exceptions=list(exceptions),
+                    logging=logging,
+                    raise_exception=raise_exception,
+                    ignore_errors=ignore_errors,
+                )
+            return func
+        return decorator
+
+    async def run(
+        self,
+        handler: Handler[EventT],
+        event: EventT,
+        api: ABCAPI,
+        ctx: Context,
+    ) -> Result[typing.Any, typing.Any]:
+        if not self.catcher:
+            return Ok(await handler(event, **magic_bundle(handler, ctx)))  # type: ignore
+        
+        ok_none = Ok(None)
+        
+        try:
+            result = await self.catcher(handler, event, api, ctx)
+        except BaseException as e:
+            error_msg = "Exception {} was occurred during the running catcher {!r}.".format(
+                repr(e.__class__.__name__)
+                if not e.args
+                else f"{e.__class__.__name__!r}: {str(e)!r}",
+                self.catcher.func.__name__,
+            )
+            result = ok_none
+            
+            if not self.catcher.ignore_errors:
+                return Error(error_msg)
+            if self.catcher.logging:
+                logger.error(error_msg)
+           
+        if self.catcher.raise_exception and not result:
+            return result
+        
+        if self.catcher.logging and not result:
+            logger.error(
+                "Catcher {!r} failed with error: {!r}",
+                self.catcher.func.__name__,
+                result.error,
+            )
+            return ok_none
+        
+        return result or ok_none

telegrinder/tools/formatting/__init__.py

@@ -1,3 +1,81 @@
-from .abc import ABCFormatter
-from .html import HTMLFormatter
-from .markdown import MarkdownFormatter
+from .html 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,
+    Link,
+    Mention,
+    PreCode,
+    ResolveDomain,
+    SpecialFormat,
+    StartBotLink,
+    StartGroupLink,
+    TgEmoji,
+)
+
+__all__ = (
+    "BaseSpecFormat",
+    "ChannelBoostLink",
+    "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_emoji",
+    "underline",
+)

telegrinder/tools/formatting/html.py

@@ -1,58 +1,304 @@
-from .abc import ABCFormatter
+import html
+import string
 import typing
+from contextlib import suppress
+
 from telegrinder.tools.parse_mode import ParseMode
+from telegrinder.types.enums import ProgrammingLanguage
+
+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 SpecialFormat, is_spec_format
 
+TAG_FORMAT = "<{tag}{data}>{content}</{tag}>"
 QUOT_MARK = '"'
 
 
-def wrap_tag(
-    tag_name: str, content: str, data: typing.Optional[dict] = None
-) -> "HTMLFormatter":
-    s = "<" + tag_name
-    if data:
-        for k, v in data.items():
-            s += f" {k}={v}"
-    s += ">" + content + "</" + tag_name + ">"
-    return HTMLFormatter(s)
+class StringFormatter(string.Formatter):
+    """String formatter, using substitutions from args and kwargs.
+    The substitutions are identified by braces ('{' and '}') with
+    specifiers: `bold`, `italic`, etc.
+    """
 
+    __formats__: typing.ClassVar[tuple[str, ...]] = (
+        "blockquote",
+        "bold",
+        "code_inline",
+        "italic",
+        "spoiler",
+        "strike",
+        "underline",
+    )
 
-class HTMLFormatter(ABCFormatter):
-    PARSE_MODE = ParseMode.HTML
+    def is_html_format(self, value: typing.Any, fmt: str) -> str:
+        if not fmt:
+            raise ValueError("Formats union should be: format+format.")
+        if fmt not in self.__formats__:
+            raise ValueError(
+                "Unknown format {!r} for object of type {!r}.".format(
+                    fmt,
+                    type(value).__name__,
+                )
+            )
+        return fmt
 
-    def escape(self) -> "HTMLFormatter":
-        return HTMLFormatter(
-            self.replace("&", "&amp;").replace(">", "&gt;").replace("<", "&lt;")
+    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":
+        if is_spec_format(value):
+            value = value.string
+
+        current_format = globals()[fmts.pop(0)](
+            str(value)
+            if isinstance(value, TagFormat)
+            else escape(FormatString(value) if not isinstance(value, str) else value)
+        )
+        for fmt in fmts:
+            current_format = globals()[fmt](current_format)
+
+        return (
+            TagFormat(
+                current_format,
+                tag=value.tag,
+                **value.data,
+            )
+            if isinstance(value, TagFormat)
+            else current_format
         )
 
-    def bold(self) -> "HTMLFormatter":
-        return wrap_tag("b", self)
+    def format_field(self, value: typing.Any, fmt: str) -> "HTMLFormatter":
+        with suppress(ValueError):
+            return HTMLFormatter(
+                format(
+                    value.formatting()
+                    if isinstance(value, TagFormat)
+                    else self.get_spec_formatter(value)(**value.__dict__).formatting()
+                    if is_spec_format(value)
+                    else value,
+                    fmt,
+                )
+            )
+        return self.format_raw_value(value, fmt)
 
-    def italic(self) -> "HTMLFormatter":
-        return wrap_tag("i", self)
+    def format_raw_value(self, value: typing.Any, fmt: str) -> "HTMLFormatter":
+        fmts = list(map(lambda fmt: self.is_html_format(value, fmt), fmt.split("+")))
+        tag_format = self.check_formats(value, fmts)
 
-    def underline(self) -> "HTMLFormatter":
-        return wrap_tag("u", self)
+        if is_spec_format(value):
+            value.string = tag_format
+            tag_format = self.get_spec_formatter(value)(**value.__dict__)
 
-    def strike(self) -> "HTMLFormatter":
-        return wrap_tag("s", self)
+        return tag_format.formatting()
 
-    def spoiler(self) -> "HTMLFormatter":
-        return wrap_tag("tg-spoiler", self)
+    def format(self, __string: str, *args: object, **kwargs: object) -> "HTMLFormatter":
+        return HTMLFormatter(super().format(__string, *args, **kwargs))
 
-    def link(self, href: str) -> "HTMLFormatter":
-        return wrap_tag(
-            "a",
-            self.escape(),
-            data={"href": QUOT_MARK + HTMLFormatter(href).escape() + QUOT_MARK},
+
+class FormatString(str):
+    string_formatter = StringFormatter()
+
+    def __new__(cls, string: str) -> typing.Self:
+        if isinstance(string, TagFormat):
+            return super().__new__(cls, string.formatting())
+        return super().__new__(cls, string)
+
+    def __add__(self, value: str) -> "HTMLFormatter":
+        return HTMLFormatter(
+            str.__add__(
+                escape(self),
+                value.formatting() if isinstance(value, TagFormat) else escape(value),
+            )
         )
 
-    def code_block(self) -> "HTMLFormatter":
-        return wrap_tag("pre", self.escape())
+    def __radd__(self, value: str) -> "HTMLFormatter":
+        """Return value+self."""
+        return HTMLFormatter(FormatString.__add__(FormatString(value), self).as_str())
+
+    def as_str(self) -> str:
+        """Return self as a standart string."""
+        return self.__str__()
+
+    def format(self, *args: object, **kwargs: object) -> "HTMLFormatter":
+        return self.string_formatter.format(self, *args, **kwargs)
+
 
-    def code_block_with_lang(self, lang: str) -> "HTMLFormatter":
-        return wrap_tag(
-            "pre", wrap_tag("code", self.escape(), data={"class": f"language-{lang}"})
+class EscapedString(FormatString):
+    @property
+    def former_string(self) -> str:
+        return html.unescape(self)
+
+
+class TagFormat(FormatString):
+    tag: str
+    data: dict[str, typing.Any]
+
+    def __new__(
+        cls,
+        string: str,
+        *,
+        tag: str,
+        **data: typing.Any,
+    ) -> typing.Self:
+        if isinstance(string, TagFormat):
+            string = string.formatting()
+        elif not isinstance(
+            string,
+            (
+                EscapedString,
+                HTMLFormatter,
+            ),
+        ):
+            string = escape(string)
+        obj = super().__new__(cls, string)
+        obj.tag = tag
+        obj.data = data
+        return obj
+
+    def get_tag_data(self) -> str:
+        return "".join(f" {k}={v}" for k, v in self.data.items())
+
+    def formatting(self) -> "HTMLFormatter":
+        return HTMLFormatter(
+            TAG_FORMAT.format(
+                tag=self.tag,
+                data=self.get_tag_data(),
+                content=self,
+            )
         )
 
-    def code_inline(self) -> "HTMLFormatter":
-        return wrap_tag("code", self.escape())
+
+class HTMLFormatter(FormatString):
+    """
+    >>> HTMLFormatter(bold("Hello, World"))
+    '<b>Hello, World</b>'
+    HTMLFormatter("Hi, {name:italic}").format(name="Max")
+    'Hi, <i>Max</i>'
+    """
+
+    PARSE_MODE = ParseMode.HTML
+
+
+def escape(string: str) -> EscapedString:
+    if isinstance(string, EscapedString | HTMLFormatter):
+        return EscapedString(string)
+    return EscapedString(html.escape(string, quote=False))
+
+
+def block_quote(string: str) -> TagFormat:
+    return TagFormat(string, tag="blockquote")
+
+
+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 code_inline(string: str) -> TagFormat:
+    return TagFormat(string, tag="code")
+
+
+def italic(string: str) -> TagFormat:
+    return TagFormat(string, tag="i")
+
+
+def link(href: str, string: str | None = None) -> TagFormat:
+    return TagFormat(
+        string or href,
+        tag="a",
+        href=QUOT_MARK + href + QUOT_MARK,
+    )
+
+
+def pre_code(string: str, lang: str | ProgrammingLanguage | None = None) -> TagFormat:
+    if lang is None:
+        return TagFormat(string, tag="pre")
+    lang = lang.value if isinstance(lang, ProgrammingLanguage) else lang
+    return pre_code(TagFormat(string, tag="code", **{"class": f"language-{lang}"}))
+
+
+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_group_link(bot_username: str, data: str, string: str | None = None) -> TagFormat:
+    return link(get_start_group_link(bot_username, data), string)
+
+
+def strike(string: str) -> TagFormat:
+    return TagFormat(string, tag="s")
+
+
+def mention(string: str, user_id: int) -> TagFormat:
+    return link(get_mention_link(user_id), string)
+
+
+def tg_emoji(string: str, emoji_id: int) -> TagFormat:
+    return TagFormat(string, tag="tg-emoji", **{"emoji-id": emoji_id})
+
+
+def invite_chat_link(invite_link: str, string: str | None = None) -> TagFormat:
+    return link(
+        get_invite_chat_link(invite_link),
+        string or f"https://t.me/joinchat/{invite_link}",
+    )
+
+
+def resolve_domain(username: str, string: str | None = None) -> TagFormat:
+    return link(
+        get_resolve_domain_link(username),
+        string or f"t.me/{username}",
+    )
+
+
+def underline(string: str) -> TagFormat:
+    return TagFormat(string, tag="u")
+
+
+__all__ = (
+    "FormatString",
+    "HTMLFormatter",
+    "SpecialFormat",
+    "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_emoji",
+    "underline",
+)

telegrinder/tools/formatting/links.py

@@ -0,0 +1,32 @@
+def get_mention_link(user_id: int) -> str:
+    return f"tg://user?id={user_id}"
+
+
+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_group_link(bot_username: str, data: str) -> str:
+    return get_resolve_domain_link(bot_username) + f"&startgroup={data}"
+
+
+def get_channel_boost_link(channel_username: str) -> str:
+    return get_resolve_domain_link(channel_username) + "&boost"
+
+
+def get_invite_chat_link(invite_link: str) -> str:
+    return f"tg://join?invite={invite_link}"
+
+
+__all__ = (
+    "get_channel_boost_link",
+    "get_invite_chat_link",
+    "get_mention_link",
+    "get_resolve_domain_link",
+    "get_start_bot_link",
+    "get_start_group_link",
+)