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

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

telegrinder/tools/formatting/spec_html_formats.py

@@ -0,0 +1,121 @@
+import dataclasses
+import typing
+
+from telegrinder.types.enums import ProgrammingLanguage
+
+SpecialFormat = typing.Union[
+    "ChannelBoostLink",
+    "Mention",
+    "Link",
+    "PreCode",
+    "TgEmoji",
+    "StartBotLink",
+    "StartGroupLink",
+    "ResolveDomain",
+    "InviteChatLink",
+]
+
+
+def is_spec_format(obj: typing.Any) -> typing.TypeGuard[SpecialFormat]:
+    return (
+        dataclasses.is_dataclass(obj)
+        and hasattr(obj, "__formatter_name__")
+        and isinstance(obj, BaseSpecFormat)
+    )
+
+
+@dataclasses.dataclass(repr=False)
+class BaseSpecFormat:
+    __formatter_name__: typing.ClassVar[str]
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__!r}: {self.__formatter_name__!r}>"
+
+
+@dataclasses.dataclass
+class ChannelBoostLink(BaseSpecFormat):
+    __formatter_name__ = "channel_boost_link"
+
+    channel_username: str
+    string: str | None = None
+
+
+@dataclasses.dataclass
+class InviteChatLink(BaseSpecFormat):
+    __formatter_name__ = "invite_chat_link"
+
+    invite_link: str
+    string: str | None = None
+
+
+@dataclasses.dataclass
+class Mention(BaseSpecFormat):
+    __formatter_name__ = "mention"
+
+    string: str
+    user_id: int
+
+
+@dataclasses.dataclass
+class Link(BaseSpecFormat):
+    __formatter_name__ = "link"
+
+    href: str
+    string: str | None = None
+
+
+@dataclasses.dataclass
+class PreCode(BaseSpecFormat):
+    __formatter_name__ = "pre_code"
+
+    string: str
+    lang: str | ProgrammingLanguage | None = None
+
+
+@dataclasses.dataclass
+class TgEmoji(BaseSpecFormat):
+    __formatter_name__ = "tg_emoji"
+    
+    string: str
+    emoji_id: int
+
+
+@dataclasses.dataclass
+class StartBotLink(BaseSpecFormat):
+    __formatter_name__ = "start_bot_link"
+
+    bot_username: str
+    data: str
+    string: str | None
+
+
+@dataclasses.dataclass
+class StartGroupLink(BaseSpecFormat):
+    __formatter_name__ = "start_group_link"
+
+    bot_username: str
+    data: str
+    string: str | None = None
+
+
+@dataclasses.dataclass
+class ResolveDomain(BaseSpecFormat):
+    __formatter_name__ = "resolve_domain"
+
+    username: str
+    string: str | None = None
+
+
+__all__ = (
+    "BaseSpecFormat",
+    "ChannelBoostLink",
+    "InviteChatLink",
+    "Link",
+    "Mention",
+    "PreCode",
+    "ResolveDomain",
+    "SpecialFormat",
+    "StartBotLink",
+    "StartGroupLink",
+    "TgEmoji",
+)

telegrinder/tools/global_context/__init__.py

@@ -0,0 +1,12 @@
+from .abc import ABCGlobalContext, CtxVar, GlobalCtxVar
+from .global_context import GlobalContext, ctx_var
+from .telegrinder_ctx import TelegrinderCtx
+
+__all__ = (
+    "ABCGlobalContext",
+    "CtxVar",
+    "GlobalContext",
+    "GlobalCtxVar",
+    "TelegrinderCtx",
+    "ctx_var",
+)

telegrinder/tools/global_context/abc.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import dataclasses
+from abc import ABC, abstractmethod
+
+import typing_extensions as typing
+
+T = typing.TypeVar("T", default=typing.Any)
+
+
+@dataclasses.dataclass(repr=False, frozen=True)
+class CtxVar(typing.Generic[T]):
+    value: T
+    const: bool = dataclasses.field(default=False, kw_only=True)
+
+    def __repr__(self) -> str:
+        return "<{}(value={!r})>".format(
+            ("Const" if self.const else "") + CtxVar.__name__,
+            self.value,
+        )
+
+
+@dataclasses.dataclass(repr=False, frozen=True)
+class GlobalCtxVar(typing.Generic[T]):
+    name: str
+    value: T
+    const: bool = dataclasses.field(default=False, kw_only=True)
+
+    def __repr__(self) -> str:
+        return "<{}({}={})>".format(
+            self.__class__.__name__,
+            self.name,
+            repr(CtxVar(self.value, const=self.const)),
+        )
+
+    @classmethod
+    def collect(cls, name: str, ctx_value: T | CtxVariable[T]) -> typing.Self:
+        ctx_value = CtxVar(ctx_value) if not isinstance(ctx_value, CtxVar | GlobalCtxVar) else ctx_value
+        params = ctx_value.__dict__
+        params["name"] = name
+        return cls(**params)
+
+
+class ABCGlobalContext(ABC, typing.Generic[T]):
+    @abstractmethod
+    def __getattr__(self, __name: str) -> typing.Any:
+        pass
+
+    @abstractmethod
+    def __setattr__(self, __name: str, __value: T | CtxVariable[T]) -> None:
+        pass
+
+    @abstractmethod
+    def __delattr__(self, __name: str) -> None:
+        pass
+
+
+CtxVariable = CtxVar[T] | GlobalCtxVar[T]
+
+
+__all__ = (
+    "ABCGlobalContext",
+    "CtxVar",
+    "CtxVariable",
+    "GlobalCtxVar",
+)