telegrinder 0.1.dev19__py3-none-any.whl → 0.1.dev158__py3-none-any.whl

telegrinder/tools/__init__.py

@@ -1,5 +1,166 @@
-from .keyboard import Keyboard, Button, InlineButton, InlineKeyboard, AnyMarkup
-from .magic import VarUnset, resolve_arg_names, magic_bundle
+from .buttons import BaseButton
+from .error_handler import ABCErrorHandler, Catcher, ErrorHandler
+from .formatting import (
+    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,
+)
+from .global_context import (
+    ABCGlobalContext,
+    CtxVar,
+    GlobalContext,
+    GlobalCtxVar,
+    TelegrinderCtx,
+    ctx_var,
+)
+from .i18n import (
+    ABCI18n,
+    ABCTranslator,
+    ABCTranslatorMiddleware,
+    I18nEnum,
+    SimpleI18n,
+    SimpleTranslator,
+)
+from .inline_query import (
+    inline_query_article,
+    inline_query_audio,
+    inline_query_cached_audio,
+    inline_query_cached_document,
+    inline_query_cached_gif,
+    inline_query_cached_mpeg4_gif,
+    inline_query_cached_photo,
+    inline_query_cached_sticker,
+    inline_query_cached_video,
+    inline_query_cached_voice,
+    inline_query_contact,
+    inline_query_document,
+    inline_query_game,
+    inline_query_gif,
+    inline_query_location,
+    inline_query_mpeg4_gif,
+    inline_query_photo,
+    inline_query_venue,
+    inline_query_video,
+    inline_query_voice,
+    input_contact_message_content,
+    input_invoice_message_content,
+    input_location_message_content,
+    input_text_message_content,
+    input_venue_message_content,
+)
 from .kb_set import KeyboardSetBase, KeyboardSetYAML
-from .parse_mode import ParseMode, get_mention_link
-from .formatting import ABCFormatter, HTMLFormatter, MarkdownFormatter
+from .keyboard import (
+    AnyMarkup,
+    Button,
+    InlineButton,
+    InlineKeyboard,
+    Keyboard,
+    RowButtons,
+    keyboard_remove,
+)
+from .loop_wrapper import ABCLoopWrapper, DelayedTask, LoopWrapper
+from .magic import magic_bundle, resolve_arg_names
+from .parse_mode import ParseMode
+
+__all__ = (
+    "ABCErrorHandler",
+    "ABCGlobalContext",
+    "ABCI18n",
+    "ABCLoopWrapper",
+    "ABCTranslator",
+    "ABCTranslatorMiddleware",
+    "AnyMarkup",
+    "BaseButton",
+    "BaseSpecFormat",
+    "Button",
+    "Catcher",
+    "ChannelBoostLink",
+    "CtxVar",
+    "DelayedTask",
+    "ErrorHandler",
+    "FormatString",
+    "GlobalContext",
+    "GlobalCtxVar",
+    "HTMLFormatter",
+    "I18nEnum",
+    "InlineButton",
+    "InlineKeyboard",
+    "InviteChatLink",
+    "Keyboard",
+    "KeyboardSetBase",
+    "KeyboardSetYAML",
+    "Link",
+    "LoopWrapper",
+    "Mention",
+    "ParseMode",
+    "PreCode",
+    "ResolveDomain",
+    "RowButtons",
+    "SimpleI18n",
+    "SimpleTranslator",
+    "SpecialFormat",
+    "StartBotLink",
+    "StartGroupLink",
+    "TelegrinderCtx",
+    "TgEmoji",
+    "block_quote",
+    "bold",
+    "channel_boost_link",
+    "code_inline",
+    "ctx_var",
+    "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",
+    "keyboard_remove",
+    "link",
+    "magic_bundle",
+    "mention",
+    "pre_code",
+    "resolve_arg_names",
+    "resolve_domain",
+    "spoiler",
+    "start_bot_link",
+    "start_group_link",
+    "strike",
+    "tg_emoji",
+    "underline",
+)

telegrinder/tools/buttons.py

@@ -1,51 +1,75 @@
-from typing import Optional
-from abc import ABC, abstractmethod
-
-
-class ABCButton(ABC):
-    @abstractmethod
-    def __init__(self, **kwargs):
-        pass
-
-    def get_data(self) -> dict:
-        return {k: v for k, v in self.__dict__.items() if v is not None}
-
-
-class Button(ABCButton):
-    def __init__(
-        self,
-        text: str,
-        request_contact: Optional[bool] = False,
-        request_location: Optional[bool] = False,
-        request_poll: Optional[dict] = None,
-        web_app: Optional[dict] = None,
-    ):
-        self.text = text
-        self.request_contact = request_contact
-        self.request_location = request_location
-        self.request_poll = request_poll
-        self.web_app = web_app
-
-
-class InlineButton(ABCButton):
-    def __init__(
-        self,
-        text: str,
-        url: str = None,
-        login_url: dict = None,
-        pay: bool = None,
-        callback_data: str = None,
-        callback_game: dict = None,
-        switch_inline_query: str = None,
-        switch_inline_query_current_chat: str = None,
-        web_app: Optional[dict] = None,
-    ):
-        self.text = text
-        self.url = url
-        self.login_url = login_url
-        self.pay = pay
-        self.callback_data = callback_data
-        self.callback_game = callback_game
-        self.switch_inline_query = switch_inline_query
-        self.switch_inline_query_current_chat = switch_inline_query_current_chat
-        self.web_app = web_app
+import dataclasses
+import typing
+
+import msgspec
+
+from telegrinder.model import encoder
+
+ButtonT = typing.TypeVar("ButtonT", bound="BaseButton")
+
+
+@typing.runtime_checkable
+class DataclassInstance(typing.Protocol):
+    __dataclass_fields__: typing.ClassVar[dict[str, dataclasses.Field[typing.Any]]]
+
+
+@dataclasses.dataclass
+class BaseButton:
+    def get_data(self) -> dict[str, typing.Any]:
+        return {
+            k: v
+            if k != "callback_data" or isinstance(v, str)
+            else encoder.encode(v)
+            for k, v in dataclasses.asdict(self).items()
+            if v is not None
+        }
+    
+
+class RowButtons(typing.Generic[ButtonT]):
+    buttons: list[ButtonT]
+    auto_row: bool
+
+    def __init__(self, *buttons: ButtonT, auto_row: bool = True) -> None:
+        self.buttons = list(buttons)
+        self.auto_row = auto_row
+
+    def get_data(self) -> list[dict[str, typing.Any]]:
+        return [b.get_data() for b in self.buttons]
+
+
+@dataclasses.dataclass
+class Button(BaseButton):
+    text: str
+    _: dataclasses.KW_ONLY
+    request_contact: bool = False
+    request_location: bool = False
+    request_poll: dict | None = None
+    web_app: dict | None = None
+
+
+@dataclasses.dataclass
+class InlineButton(BaseButton):
+    text: str
+    _: dataclasses.KW_ONLY
+    url: str | None = None
+    login_url: dict | None = None
+    pay: bool | None = None
+    callback_data: typing.Union[
+        str,
+        dict[str, typing.Any],
+        DataclassInstance,
+        msgspec.Struct,
+    ] | None = None
+    callback_game: dict | None = None
+    switch_inline_query: str | None = None
+    switch_inline_query_current_chat: str | None = None
+    web_app: dict | None = None
+
+
+__all__ = (
+    "BaseButton",
+    "Button",
+    "DataclassInstance",
+    "InlineButton",
+    "RowButtons",
+)

telegrinder/tools/error_handler/__init__.py

@@ -0,0 +1,8 @@
+from .abc import ABCErrorHandler
+from .error_handler import Catcher, ErrorHandler
+
+__all__ = (
+    "ABCErrorHandler",
+    "Catcher",
+    "ErrorHandler",
+)

telegrinder/tools/error_handler/abc.py

@@ -0,0 +1,30 @@
+import typing
+from abc import ABC, abstractmethod
+
+from fntypes.result import Result
+
+from telegrinder.api import ABCAPI
+from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.dispatch.context import Context
+
+EventT = typing.TypeVar("EventT", bound=BaseCute)
+Handler = typing.Callable[typing.Concatenate[EventT, ...], typing.Awaitable[typing.Any]]
+
+
+class ABCErrorHandler(ABC, typing.Generic[EventT]):
+    @abstractmethod
+    def catch(self) -> typing.Callable[[typing.Callable], typing.Callable]:
+        ...
+
+    @abstractmethod
+    async def run(
+        self,
+        handler: Handler[EventT],
+        event: EventT,
+        api: ABCAPI,
+        ctx: Context,
+    ) -> Result[typing.Any, typing.Any]:
+        ...
+
+
+__all__ = ("ABCErrorHandler",)

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",
+)