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

telegrinder/tools/formatting/{html.py → html_formatter.py}

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+import dataclasses
 import html
 import string
 import typing
@@ -6,34 +9,29 @@ 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 .deep_links import tg_mention_link
 from .spec_html_formats import SpecialFormat, is_spec_format
 
-TAG_FORMAT = "<{tag}{data}>{content}</{tag}>"
-QUOT_MARK = '"'
+type HTMLFormat = str | TagFormat
+
+HTML_UNION_SPECIFIERS_SEPARATOR: typing.Final[str] = "+"
+TAG_FORMAT: typing.Final[str] = "<{tag}{data}>{content}</{tag}>"
+QUOT_MARK: typing.Final[str] = '"'
 
 
 class StringFormatterProto(typing.Protocol):
-    def format_field(self, value: typing.Any, fmt: str) -> "HTMLFormatter": ...
+    def format_field(self, value: typing.Any, fmt: str) -> HTMLFormatter: ...
 
-    def format(self, __string: str, *args: object, **kwargs: object) -> "HTMLFormatter": ...
+    def format(self, __string: str, *args: object, **kwargs: object) -> HTMLFormatter: ...
 
 
 class StringFormatter(string.Formatter):
     """String formatter, using substitutions from args and kwargs.
     The substitutions are identified by braces ('{' and '}') with
-    specifiers: `bold`, `italic`, etc.
+    specifiers: `bold`, `italic`, `underline`, `strike` etc...
     """
 
     __formats__: typing.ClassVar[tuple[str, ...]] = (
-        "blockquote",
         "bold",
         "code_inline",
         "italic",
@@ -42,9 +40,10 @@ class StringFormatter(string.Formatter):
         "underline",
     )
 
-    def is_html_format(self, value: typing.Any, fmt: str) -> str:
+    def validate_html_format(self, value: typing.Any, fmt: str) -> HTMLFormat:
         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(
@@ -52,12 +51,13 @@ class StringFormatter(string.Formatter):
                     type(value).__name__,
                 )
             )
+
         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":
+    def make_tag_format(self, value: typing.Any, fmts: list[HTMLFormat]) -> TagFormat:
         if is_spec_format(value):
             value = value.string
 
@@ -79,7 +79,7 @@ class StringFormatter(string.Formatter):
             else current_format
         )
 
-    def format_field(self, value: typing.Any, fmt: str) -> "HTMLFormatter":
+    def format_field(self, value: typing.Any, fmt: str) -> HTMLFormatter:
         with suppress(ValueError):
             return HTMLFormatter(
                 format(
@@ -87,7 +87,7 @@ class StringFormatter(string.Formatter):
                         value.formatting()
                         if isinstance(value, TagFormat)
                         else (
-                            self.get_spec_formatter(value)(**value.__dict__).formatting()
+                            self.get_spec_formatter(value)(**dataclasses.asdict(value)).formatting()
                             if is_spec_format(value)
                             else value
                         )
@@ -95,31 +95,35 @@ class StringFormatter(string.Formatter):
                     fmt,
                 )
             )
-        return self.format_raw_value(value, fmt)
 
-    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)
+        fmts = list(
+            map(
+                lambda fmt: self.validate_html_format(value, fmt),
+                fmt.split(HTML_UNION_SPECIFIERS_SEPARATOR),
+            ),
+        )
+        tag_format = self.make_tag_format(value, fmts)
 
         if is_spec_format(value):
             value.string = tag_format
-            tag_format = self.get_spec_formatter(value)(**value.__dict__)
+            tag_format = self.get_spec_formatter(value)(**dataclasses.asdict(value))
 
         return tag_format.formatting()
 
-    def format(self, __string: str, *args: object, **kwargs: object) -> "HTMLFormatter":
+    def format(self, __string: str, *args: object, **kwargs: object) -> HTMLFormatter:
         return HTMLFormatter(super().format(__string, *args, **kwargs))
 
 
 class FormatString(str):
     STRING_FORMATTER: StringFormatterProto = StringFormatter()
 
-    def __new__(cls, string: str) -> typing.Self:
+    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":
+    def __add__(self, value: str) -> HTMLFormatter:
+        """Returns self+value."""
         return HTMLFormatter(
             str.__add__(
                 escape(self),
@@ -127,12 +131,12 @@ class FormatString(str):
             )
         )
 
-    def __radd__(self, value: str) -> "HTMLFormatter":
-        """Return value+self."""
+    def __radd__(self, value: str) -> HTMLFormatter:
+        """Returns value+self."""
         return HTMLFormatter(FormatString.__add__(FormatString(value), self).as_str())
 
     def as_str(self) -> str:
-        """Return self as a standart string."""
+        """Returns self as a standart string."""
         return self.__str__()
 
     def format(self, *args: object, **kwargs: object) -> "HTMLFormatter":
@@ -152,9 +156,10 @@ class TagFormat(FormatString):
     def __new__(
         cls,
         string: str,
+        /,
         *,
         tag: str,
-        **data: typing.Any,
+        **data: typing.Any | None,
     ) -> typing.Self:
         if isinstance(string, TagFormat):
             string = string.formatting()
@@ -166,15 +171,16 @@ class TagFormat(FormatString):
             ),
         ):
             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())
+        return "".join(f" {k}={v}" if v is not None else f" {k}" for k, v in self.data.items())
 
-    def formatting(self) -> "HTMLFormatter":
+    def formatting(self) -> HTMLFormatter:
         return HTMLFormatter(
             TAG_FORMAT.format(
                 tag=self.tag,
@@ -185,11 +191,10 @@ class TagFormat(FormatString):
 
 
 class HTMLFormatter(FormatString):
-    """
-    >>> HTMLFormatter(bold("Hello, World"))
-    '<b>Hello, World</b>'
-    HTMLFormatter("Hi, {name:italic}").format(name="Max")
-    'Hi, <i>Max</i>'
+    """>>> HTMLFormatter(bold("Hello, World"))
+    >>> '<b>Hello, World</b>'
+    >>> HTMLFormatter("Hi, {name:italic}").format(name="Max")
+    >>> 'Hi, <i>Max</i>'
     """
 
     PARSE_MODE = ParseMode.HTML
@@ -201,18 +206,18 @@ def escape(string: str) -> EscapedString:
     return EscapedString(html.escape(string, quote=False))
 
 
-def block_quote(string: str) -> TagFormat:
-    return TagFormat(string, tag="blockquote")
+def block_quote(string: str, expandable: bool = False) -> TagFormat:
+    return TagFormat(
+        string,
+        tag="blockquote",
+        **{} if not expandable else {"expandable": None},
+    )
 
 
 def bold(string: str) -> TagFormat:
     return TagFormat(string, tag="b")
 
 
-def channel_boost_link(channel_id: str | int, string: str | None = None):
-    return link(get_channel_boost_link(channel_id), string)
-
-
 def code_inline(string: str) -> TagFormat:
     return TagFormat(string, tag="code")
 
@@ -240,38 +245,16 @@ def spoiler(string: str) -> TagFormat:
     return TagFormat(string, tag="tg-spoiler")
 
 
-def start_bot_link(bot_id: str | int, data: str, string: str | None = None) -> TagFormat:
-    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:
-    return link(get_start_group_link(bot_id, 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)
+    return link(tg_mention_link(user_id=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}",
-    )
+    return TagFormat(string, tag="tg-emoji", emoji_id=emoji_id)
 
 
 def underline(string: str) -> TagFormat:
@@ -284,24 +267,13 @@ __all__ = (
     "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/spec_html_formats.py

@@ -4,28 +4,20 @@ import typing
 from telegrinder.types.enums import ProgrammingLanguage
 
 SpecialFormat: typing.TypeAlias = typing.Union[
-    "ChannelBoostLink",
-    "InviteChatLink",
+    "BlockQuote",
     "Link",
     "Mention",
     "PreCode",
-    "ResolveDomain",
-    "StartBotLink",
-    "StartGroupLink",
     "TgEmoji",
 ]
 
 
 def is_spec_format(obj: typing.Any) -> typing.TypeGuard[SpecialFormat]:
-    return (
-        dataclasses.is_dataclass(obj)
-        and hasattr(obj, "__formatter_name__")
-        and isinstance(obj, BaseSpecFormat)
-    )
+    return dataclasses.is_dataclass(obj) and hasattr(obj, "__formatter_name__") and isinstance(obj, Base)
 
 
-@dataclasses.dataclass(repr=False, slots=True)
-class BaseSpecFormat:
+@dataclasses.dataclass(repr=False)
+class Base:
     __formatter_name__: typing.ClassVar[str] = dataclasses.field(init=False, repr=False)
 
     def __repr__(self) -> str:
@@ -33,23 +25,7 @@ class BaseSpecFormat:
 
 
 @dataclasses.dataclass(repr=False, slots=True)
-class ChannelBoostLink(BaseSpecFormat):
-    __formatter_name__ = "channel_boost_link"
-
-    channel_id: str | int
-    string: str | None = None
-
-
-@dataclasses.dataclass(repr=False, slots=True)
-class InviteChatLink(BaseSpecFormat):
-    __formatter_name__ = "invite_chat_link"
-
-    invite_link: str
-    string: str | None = None
-
-
-@dataclasses.dataclass(repr=False, slots=True)
-class Mention(BaseSpecFormat):
+class Mention(Base):
     __formatter_name__ = "mention"
 
     string: str
@@ -57,7 +33,7 @@ class Mention(BaseSpecFormat):
 
 
 @dataclasses.dataclass(repr=False, slots=True)
-class Link(BaseSpecFormat):
+class Link(Base):
     __formatter_name__ = "link"
 
     href: str
@@ -65,7 +41,7 @@ class Link(BaseSpecFormat):
 
 
 @dataclasses.dataclass(repr=False, slots=True)
-class PreCode(BaseSpecFormat):
+class PreCode(Base):
     __formatter_name__ = "pre_code"
 
     string: str
@@ -73,7 +49,7 @@ class PreCode(BaseSpecFormat):
 
 
 @dataclasses.dataclass(repr=False, slots=True)
-class TgEmoji(BaseSpecFormat):
+class TgEmoji(Base):
     __formatter_name__ = "tg_emoji"
 
     string: str
@@ -81,41 +57,19 @@ class TgEmoji(BaseSpecFormat):
 
 
 @dataclasses.dataclass(repr=False, slots=True)
-class StartBotLink(BaseSpecFormat):
-    __formatter_name__ = "start_bot_link"
+class BlockQuote(Base):
+    __formatter_name__ = "block_quote"
 
-    bot_id: str | int
-    data: str
-    string: str | None
-
-
-@dataclasses.dataclass(repr=False, slots=True)
-class StartGroupLink(BaseSpecFormat):
-    __formatter_name__ = "start_group_link"
-
-    bot_id: str | int
-    data: str
-    string: str | None = None
-
-
-@dataclasses.dataclass(repr=False, slots=True)
-class ResolveDomain(BaseSpecFormat):
-    __formatter_name__ = "resolve_domain"
-
-    username: str
-    string: str | None = None
+    string: str
+    expandable: bool = False
 
 
 __all__ = (
-    "BaseSpecFormat",
-    "ChannelBoostLink",
-    "InviteChatLink",
+    "Base",
+    "BlockQuote",
     "Link",
     "Mention",
     "PreCode",
-    "ResolveDomain",
     "SpecialFormat",
-    "StartBotLink",
-    "StartGroupLink",
     "TgEmoji",
 )

telegrinder/tools/functional.py

@@ -1,11 +1,7 @@
-import typing
-
 from fntypes import Nothing, Option, Some
 
-T = typing.TypeVar("T")
-
 
-def from_optional(value: T | None) -> Option[T]:
+def from_optional[Value](value: Value | None, /) -> Option[Value]:
     return Some(value) if value is not None else Nothing()
 
 

telegrinder/tools/global_context/global_context.py

@@ -65,20 +65,19 @@ def root_protection(func: F) -> F:
     return wrapper  # type: ignore
 
 
-def ctx_var(value: T, *, const: bool = False) -> T:
+def ctx_var(*, default: T, frozen: bool = False) -> T:
     """Example:
     ```
     class MyCtx(GlobalContext):
-        name: typing.Final[str]
-        URL: typing.Final = ctx_var("https://google.com", const=True)
+        name: str
+        URL: str = ctx_var("https://google.com", frozen=True)
 
-    ctx = MyCtx(name=ctx_var("Alex", const=True))
+    ctx = MyCtx(name=ctx_var("Alex", frozen=True))
     ctx.URL  #: 'https://google.com'
     ctx.URL = '...'  #: type checking error & exception 'TypeError'
     ```
     """
-
-    return typing.cast(T, CtxVar(value, const=const))
+    return typing.cast(T, CtxVar(default, const=frozen))
 
 
 @dataclasses.dataclass(frozen=True, eq=False, slots=True)
@@ -113,9 +112,7 @@ class Storage:
         return Some(ctx) if ctx is not None else Nothing()
 
     def delete(self, ctx_name: str) -> None:
-        assert (
-            self._storage.pop(ctx_name, None) is not None
-        ), f"Context {ctx_name!r} is not defined in storage."
+        assert self._storage.pop(ctx_name, None) is not None, f"Context {ctx_name!r} is not defined in storage."
 
 
 @typing.dataclass_transform(
@@ -151,7 +148,6 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         **variables: typing.Any | CtxVar[CtxValueT],
     ) -> typing.Self:
         """Create or get from storage a new `GlobalContext` object."""
-
         if not issubclass(GlobalContext, cls):
             defaults = {}
             for name in cls.__annotations__:
@@ -180,9 +176,7 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         ctx_name: str | None = None,
         /,
         **variables: CtxValueT | CtxVariable[CtxValueT],
-    ):
-        """Initialization of `GlobalContext` with passed variables."""
-
+    ) -> None:
         if not hasattr(self, "__ctx_name__"):
             self.__ctx_name__ = ctx_name
 
@@ -197,8 +191,8 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
 
     def __eq__(self, __value: "GlobalContext") -> bool:
         """Returns True if the names of context stores
-        that use self and __value instances are equivalent."""
-
+        that use self and __value instances are equivalent.
+        """
         return isinstance(__value, GlobalContext) and self.__ctx_name__ == __value.__ctx_name__
 
     def __setitem__(self, __name: str, __value: CtxValueT | CtxVariable[CtxValueT]):
@@ -210,7 +204,7 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         dict.__setitem__(self, __name, GlobalCtxVar.collect(__name, __value))
 
     def __getitem__(self, __name: str) -> CtxValueT:
-        return self.get(__name).unwrap().value
+        return self.get(__name).unwrap().value  # type: ignore
 
     def __delitem__(self, __name: str):
         var = self.get(__name).unwrap()
@@ -221,7 +215,6 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
     @root_protection
     def __setattr__(self, __name: str, __value: CtxValueT | CtxVariable[CtxValueT]):
         """Setting a context variable."""
-
         if is_dunder(__name):
             return object.__setattr__(self, __name, __value)
         self.__setitem__(__name, __value)
@@ -229,7 +222,6 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
     @root_protection
     def __getattr__(self, __name: str) -> CtxValueT:
         """Getting a context variable."""
-
         if is_dunder(__name):
             return object.__getattribute__(self, __name)
         return self.__getitem__(__name)
@@ -237,7 +229,6 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
     @root_protection
     def __delattr__(self, __name: str) -> None:
         """Removing a context variable."""
-
         if is_dunder(__name):
             return object.__delattr__(self, __name)
         self.__delitem__(__name)
@@ -245,27 +236,22 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
     @property
     def ctx_name(self) -> str:
         """Context name."""
-
         return self.__ctx_name__ or "<Unnamed ctx at %#x>" % id(self)
 
     @classmethod
     def is_root_attribute(cls, name: str) -> bool:
         """Returns True if exists root attribute
-        otherwise False."""
-
+        otherwise False.
+        """
         return name in cls.__root_attributes__
 
-    def set_context_variables(
-        self, variables: typing.Mapping[str, CtxValueT | CtxVariable[CtxValueT]]
-    ) -> None:
+    def set_context_variables(self, variables: typing.Mapping[str, CtxValueT | CtxVariable[CtxValueT]]) -> None:
         """Set context variables from mapping."""
-
         for name, var in variables.items():
             self[name] = var
 
     def get_root_attribute(self, name: str) -> Option[RootAttr]:
         """Get root attribute by name."""
-
         if self.is_root_attribute(name):
             for rattr in self.__root_attributes__:
                 if rattr.name == name:
@@ -274,33 +260,27 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
 
     def items(self) -> list[tuple[str, GlobalCtxVar[CtxValueT]]]:
         """Return context variables as set-like items."""
-
         return list(dict.items(self))
 
     def keys(self) -> list[str]:
         """Returns context variable names as keys."""
-
         return list(dict.keys(self))
 
     def values(self) -> list[GlobalCtxVar[CtxValueT]]:
         """Returns context variables as values."""
-
         return list(dict.values(self))
 
     def update(self, other: typing.Self) -> None:
         """Update context."""
-
         dict.update(dict(other.items()))
 
     def copy(self) -> typing.Self:
         """Copy context. Returns copied context without ctx_name."""
-
         return self.__class__(**self.dict())
 
     def dict(self) -> dict[str, GlobalCtxVar[CtxValueT]]:
         """Returns context as dict."""
-
-        return {name: deepcopy(var) for name, var in self.items()}
+        return {name: deepcopy(var) for name, var in self.items()}  # type: ignore
 
     @typing.overload
     def pop(self, var_name: str) -> Option[GlobalCtxVar[CtxValueT]]: ...
@@ -314,7 +294,6 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
 
     def pop(self, var_name: str, var_value_type=object):  # type: ignore
         """Pop context variable by name."""
-
         val = self.get(var_name, var_value_type)  # type: ignore
         if val:
             del self[var_name]
@@ -333,7 +312,6 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
 
     def get(self, var_name, var_value_type=object):  # type: ignore
         """Get context variable by name."""
-
         var_value_type = typing.Any if var_value_type is object else var_value_type
         generic_types = typing.get_args(get_orig_class(self))
         if generic_types and var_value_type is object:
@@ -341,15 +319,15 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         var = dict.get(self, var_name)
         if var is None:
             return Nothing()
-        assert type_check(
-            var.value, var_value_type
-        ), "Context variable value type of {!r} does not correspond to the expected type {!r}.".format(
-            type(var.value).__name__,
-            (
-                getattr(var_value_type, "__name__")
-                if isinstance(var_value_type, type)
-                else repr(var_value_type)
-            ),
+        assert type_check(var.value, var_value_type), (
+            "Context variable value type of {!r} does not correspond to the expected type {!r}.".format(
+                type(var.value).__name__,
+                (
+                    getattr(var_value_type, "__name__")
+                    if isinstance(var_value_type, type)
+                    else repr(var_value_type)
+                ),
+            )
         )
         return Some(var)
 
@@ -365,23 +343,21 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
 
     def get_value(self, var_name, var_value_type=object):  # type: ignore
         """Get context variable value by name."""
-
         return self.get(var_name, var_value_type).map(lambda var: var.value)
 
     def rename(self, old_var_name: str, new_var_name: str) -> Result[_, str]:
         """Rename context variable."""
-
         var = self.get(old_var_name).unwrap()
         if var.const:
-            return Error(f"Unable to rename variable {old_var_name!r}, " "because it's a constant.")
+            return Error(f"Unable to rename variable {old_var_name!r}, because it's a constant.")
         del self[old_var_name]
         self[new_var_name] = var.value
         return Ok(_())
 
     def clear(self, *, include_consts: bool = False) -> None:
         """Clear context. If `include_consts = True`,
-        then the context is completely cleared."""
-
+        then the context is completely cleared.
+        """
         if not self:
             return
         if include_consts:
@@ -397,7 +373,6 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
 
     def delete_ctx(self) -> Result[_, str]:
         """Delete context by `ctx_name`."""
-
         if not self.__ctx_name__:
             return Error("Cannot delete unnamed context.")
         ctx = self.__storage__.get(self.ctx_name).unwrap()