telegrinder 0.1.dev161__py3-none-any.whl → 0.1.dev163__py3-none-any.whl

telegrinder/bot/rules/__init__.py

@@ -30,6 +30,8 @@ from .is_from import (
     IsDartDice,
     IsDice,
     IsForum,
+    IsForward,
+    IsForwardType,
     IsGroup,
     IsLanguageCode,
     IsPremium,
@@ -78,6 +80,8 @@ __all__ = (
     "IsDartDice",
     "IsDice",
     "IsForum",
+    "IsForward",
+    "IsForwardType",
     "IsGroup",
     "IsLanguageCode",
     "IsPremium",

telegrinder/bot/rules/is_from.py

@@ -12,13 +12,13 @@ T = typing.TypeVar("T", bound=BaseCute)
 
 
 @typing.runtime_checkable
-class HasFromProto(typing.Protocol):
+class FromUserProto(typing.Protocol):
     from_: User | Option[User]
 
 
 class HasFrom(ABCRule[T]):
     async def check(self, event: T, ctx: Context) -> bool:
-        return isinstance(event, HasFromProto) and bool(event.from_)
+        return isinstance(event, FromUserProto) and bool(event.from_)
 
 
 class HasDice(MessageRule):
@@ -26,6 +26,19 @@ class HasDice(MessageRule):
         return bool(message.dice)
 
 
+class IsForward(MessageRule):
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return bool(message.forward_origin)
+
+
+class IsForwardType(MessageRule, requires=[IsForward()]):
+    def __init__(self, fwd_type: typing.Literal["user", "hidden_user", "chat", "channel"], /) -> None:
+        self.fwd_type = fwd_type
+
+    async def check(self, message: Message, ctx: Context) -> bool:
+        return message.forward_origin.unwrap().v.type == self.fwd_type
+
+
 class IsReply(MessageRule):
     async def check(self, message: Message, ctx: Context) -> bool:
         return bool(message.reply_to_message)
@@ -58,7 +71,7 @@ class IsLanguageCode(MessageRule, requires=[HasFrom()]):
     async def check(self, message: Message, ctx: Context) -> bool:
         if not message.from_user.language_code:
             return False
-        return message.from_user.language_code.unwrap_or_none() in self.lang_codes
+        return message.from_user.language_code.unwrap() in self.lang_codes
 
 
 class IsForum(MessageRule):
@@ -141,6 +154,8 @@ __all__ = (
     "IsDartDice",
     "IsDice",
     "IsForum",
+    "IsForward",
+    "IsForwardType",
     "IsGroup",
     "IsLanguageCode",
     "IsPremium",

telegrinder/bot/scenario/checkbox.py

@@ -43,7 +43,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         self.choices: list[Choice] = []
         self.ready = ready_text
         self.max_in_row = max_in_row
-        self.random_code = secrets.token_hex(16)
+        self.random_code = secrets.token_hex(8)
         self.waiter_machine = waiter_machine
 
     def get_markup(self) -> InlineKeyboardMarkup:
@@ -73,7 +73,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         is_picked: bool = False,
     ) -> typing.Self:
         self.choices.append(
-            Choice(name, is_picked, default_text, picked_text, secrets.token_hex(16)),
+            Choice(name, is_picked, default_text, picked_text, secrets.token_hex(8)),
         )
         return self
 
@@ -103,7 +103,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         assert len(self.choices) > 1
         message = (
             await api.send_message(
-                self.chat_id,
+                chat_id=self.chat_id,
                 text=self.msg,
                 parse_mode=self.PARSE_MODE,
                 reply_markup=self.get_markup(),
@@ -111,7 +111,6 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         ).unwrap()
         
         while True:
-            q: CallbackQueryCute
             q, _ = await self.waiter_machine.wait(view, (api, message.message_id))
             should_continue = await self.handle(q)
             await q.answer(self.CALLBACK_ANSWER)

telegrinder/client/aiohttp.py

@@ -1,4 +1,3 @@
-import secrets
 import ssl
 import typing
 
@@ -31,7 +30,7 @@ class AiohttpClient(ABCClient):
             self.__class__.__name__,
             self.session,
             self.timeout,
-            False if self.session is None else self.session.closed,
+            True if self.session is None else self.session.closed,
         )
     
     async def request_raw(

telegrinder/modules.py

@@ -4,14 +4,16 @@ import typing
 from choicelib import choice_in_order
 
 
+@typing.runtime_checkable
 class JSONModule(typing.Protocol):
-    def loads(self, s: str | bytes) -> dict[str, typing.Any] | list[typing.Any]:
+    def loads(self, s: str | bytes) -> typing.Any:
         ...
 
-    def dumps(self, o: dict[str, typing.Any] | list[typing.Any]) -> str:
+    def dumps(self, o: typing.Any) -> str:
         ...
 
 
+@typing.runtime_checkable
 class LoggerModule(typing.Protocol):
     def debug(self, __msg: object, *args: object, **kwargs: object) -> None:
         ...
@@ -47,7 +49,7 @@ class LoggerModule(typing.Protocol):
 
 logger: LoggerModule
 json: JSONModule = choice_in_order(
-    ["ujson", "hyperjson", "orjson"], do_import=True, default="telegrinder.msgspec_json"
+    ["orjson", "ujson", "hyperjson"], do_import=True, default="telegrinder.msgspec_json"
 )
 logging_module = choice_in_order(["loguru"], default="logging")
 logging_level = os.getenv("LOGGER_LEVEL", default="DEBUG").upper()

telegrinder/msgspec_json.py

@@ -3,11 +3,11 @@ import typing
 from .msgspec_utils import decoder, encoder
 
 
-def loads(s: str | bytes) -> dict[str, typing.Any] | list[typing.Any]:
-    return decoder.decode(s, type=dict[str, typing.Any] | list[typing.Any])  # type: ignore
+def loads(s: str | bytes) -> typing.Any:
+    return decoder.decode(s)
 
 
-def dumps(o: dict[str, typing.Any] | list[typing.Any]) -> str:
+def dumps(o: typing.Any) -> str:
     return encoder.encode(o)
 
 

telegrinder/msgspec_utils.py

@@ -4,11 +4,7 @@ import fntypes.option
 import msgspec
 from fntypes.co import Error, Ok, Result, Variative
 
-T = typing.TypeVar("T")
-Ts = typing.TypeVarTuple("Ts")
-
 if typing.TYPE_CHECKING:
-    import types
     from datetime import datetime
 
     from fntypes.option import Option
@@ -19,6 +15,7 @@ else:
 
     datetime = type("datetime", (dt,), {})
 
+
     class OptionMeta(type):
         def __instancecheck__(cls, __instance: typing.Any) -> bool:
             return isinstance(__instance, fntypes.option.Some | fntypes.option.Nothing)
@@ -27,6 +24,9 @@ else:
     class Option(typing.Generic[Value], metaclass=OptionMeta):
         pass
 
+T = typing.TypeVar("T")
+Ts = typing.TypeVarTuple("Ts")
+
 DecHook: typing.TypeAlias = typing.Callable[[type[T], typing.Any], object]
 EncHook: typing.TypeAlias = typing.Callable[[T], typing.Any]
 
@@ -48,10 +48,6 @@ def msgspec_convert(obj: typing.Any, t: type[T]) -> Result[T, msgspec.Validation
         return Error(exc)
 
 
-def datetime_dec_hook(tp: type[datetime], obj: int | float) -> datetime:
-    return tp.fromtimestamp(obj)
-
-
 def option_dec_hook(tp: type[Option[typing.Any]], obj: typing.Any) -> Option[typing.Any]:
     if obj is None:
         return Nothing
@@ -88,37 +84,49 @@ def variative_dec_hook(tp: type[Variative], obj: typing.Any) -> Variative:
 
     raise TypeError(
         "Object of type `{}` does not belong to types `{}`".format(
-            repr_type(type(obj)),
+            repr_type(obj.__class__),
             " | ".join(map(repr_type, union_types)),
         )
     )
 
 
-def datetime_enc_hook(obj: datetime) -> int:
-    return int(obj.timestamp())
+class Decoder:
+    """Class `Decoder` for `msgspec` module with decode hook
+    for objects with the specified type.
+    
+    ```
+    import enum
+
+    from datetime import datetime as dt
 
+    class Digit(enum.IntEnum):
+        ONE = 1
+        TWO = 2
+        THREE = 3
 
-def option_enc_hook(obj: Option[typing.Any]) -> typing.Any | None:
-    return obj.value if isinstance(obj, fntypes.option.Some) else None
+    decoder = Encoder()
+    decoder.dec_hooks[dt] = lambda t, timestamp: t.fromtimestamp(timestamp)
 
+    decoder.dec_hook(dt, 1713354732)  #> datetime.datetime(2024, 4, 17, 14, 52, 12)
+    decoder.dec_hook(int, "123")  #> TypeError: Unknown type `int`. You can implement decode hook for this type.
 
-def variative_enc_hook(obj: Variative[typing.Any]) -> typing.Any:
-    return obj.v
+    decoder.convert("123", type=int, strict=False)  #> 123
+    decoder.convert(1, type=Digit)  #> <Digit.ONE: 1>
 
+    decoder.decode(b'{"digit":3}', type=dict[str, Digit])  #> {'digit': <Digit.THREE: 3>}
+    ```
+    """
 
-class Decoder:
     def __init__(self) -> None:
-        self.dec_hooks: dict[
-            typing.Union[type[typing.Any], "types.UnionType"], DecHook[typing.Any]
-        ] = {
+        self.dec_hooks: dict[typing.Any, DecHook[typing.Any]] = {
             Option: option_dec_hook,
             Variative: variative_dec_hook,
-            datetime: datetime_dec_hook,
+            datetime: lambda t, obj: t.fromtimestamp(obj),
         }
 
-    def add_dec_hook(self, tp: type[T]):
+    def add_dec_hook(self, t: T):  # type: ignore
         def decorator(func: DecHook[T]) -> DecHook[T]:
-            return self.dec_hooks.setdefault(get_origin(tp), func)
+            return self.dec_hooks.setdefault(get_origin(t), func)  # type: ignore
         
         return decorator
     
@@ -138,7 +146,7 @@ class Decoder:
         type: type[T] = dict,
         strict: bool = True,
         from_attributes: bool = False,
-        builtin_types: typing.Iterable[type] | None = None,
+        builtin_types: typing.Iterable[type[typing.Any]] | None = None,
         str_keys: bool = False,
     ) -> T:
         return msgspec.convert(
@@ -150,12 +158,30 @@ class Decoder:
             builtin_types=builtin_types,
             str_keys=str_keys,
         )
+    
+    @typing.overload
+    def decode(self, buf: str | bytes) -> typing.Any:
+        ...
+    
+    @typing.overload
+    def decode(self, buf: str | bytes, *, strict: bool = True) -> typing.Any:
+        ...
 
+    @typing.overload
     def decode(
         self,
         buf: str | bytes,
         *,
-        type: type[T] = dict,
+        type: type[T],
+        strict: bool = True,
+    ) -> T:
+        ...
+
+    def decode(
+        self,
+        buf: str | bytes,
+        *,
+        type: type[T] = typing.Any,  # type: ignore
         strict: bool = True,
     ) -> T:
         return msgspec.json.decode(
@@ -167,35 +193,55 @@ class Decoder:
 
 
 class Encoder:
+    """Class `Encoder` for `msgspec` module with encode hooks for objects.
+    
+    ```
+    from datetime import datetime as dt
+
+    encoder = Encoder()
+    encoder.enc_hooks[dt] = lambda d: int(d.timestamp())
+
+    encoder.enc_hook(dt.now())  #> 1713354732
+    encoder.enc_hook(123)  #> NotImplementedError: Not implemented encode hook for object of type `int`.
+
+    encoder.encode({'digit': Digit.ONE})  #> '{"digit":1}'
+    ```
+    """
+
     def __init__(self) -> None:
-        self.enc_hooks: dict[type, EncHook] = {
-            fntypes.option.Some: option_enc_hook,
-            fntypes.option.Nothing: option_enc_hook,
-            Variative: variative_enc_hook,
-            datetime: datetime_enc_hook,
+        self.enc_hooks: dict[typing.Any, EncHook[typing.Any]] = {
+            fntypes.option.Some: lambda opt: opt.value,
+            fntypes.option.Nothing: lambda _: None,
+            Variative: lambda variative: variative.v,
+            datetime: lambda date: int(date.timestamp()),
         }
 
-    def add_dec_hook(self, tp: type[T]):
+    def add_dec_hook(self, t: type[T]):
         def decorator(func: EncHook[T]) -> EncHook[T]:
-            return self.enc_hooks.setdefault(get_origin(tp), func)
+            encode_hook = self.enc_hooks.setdefault(get_origin(t), func)
+            return func if encode_hook is not func else encode_hook
         
         return decorator
     
     def enc_hook(self, obj: object) -> object:
-        origin_type = get_origin(type(obj))
+        origin_type = get_origin(obj.__class__)
         if origin_type not in self.enc_hooks:
             raise NotImplementedError(
                 "Not implemented encode hook for "
                 f"object of type `{repr_type(origin_type)}`."
             )
         return self.enc_hooks[origin_type](obj)
+
+    @typing.overload
+    def encode(self, obj: typing.Any) -> str:
+        ...
     
     @typing.overload
-    def encode(self, obj: typing.Any, *, as_str: typing.Literal[True] = True) -> str:
+    def encode(self, obj: typing.Any, *, as_str: typing.Literal[True]) -> str:
         ...
 
     @typing.overload
-    def encode(self, obj: typing.Any, *, as_str: typing.Literal[False] = False) -> bytes:
+    def encode(self, obj: typing.Any, *, as_str: typing.Literal[False]) -> bytes:
         ...
 
     def encode(self, obj: typing.Any, *, as_str: bool = True) -> str | bytes:
@@ -215,12 +261,8 @@ __all__ = (
     "get_origin",
     "repr_type",
     "msgspec_convert",
-    "datetime_dec_hook",
-    "datetime_enc_hook",
     "option_dec_hook",
-    "option_enc_hook",
     "variative_dec_hook",
-    "variative_enc_hook",
     "datetime",
     "decoder",
     "encoder",

telegrinder/node/source.py

@@ -2,7 +2,6 @@ import dataclasses
 import typing
 
 from telegrinder.api import API
-from telegrinder.msgspec_utils import Nothing, Option
 from telegrinder.types import Chat, Message
 
 from .base import DataNode
@@ -13,14 +12,14 @@ from .message import MessageNode
 class Source(DataNode):
     api: API
     chat: Chat
-    thread_id: Option[int] = dataclasses.field(default_factory=lambda: Nothing)
+    thread_id: int | None = None
 
     @classmethod
     async def compose(cls, message: MessageNode) -> typing.Self:
         return cls(
             api=message.ctx_api,
             chat=message.chat,
-            thread_id=message.message_thread_id,
+            thread_id=message.message_thread_id.unwrap_or_none(),
         )
     
     async def send(self, text: str) -> Message:

telegrinder/tools/__init__.py

@@ -14,6 +14,7 @@ from .formatting import (
     StartBotLink,
     StartGroupLink,
     TgEmoji,
+    UserOpenMessage,
     block_quote,
     bold,
     channel_boost_link,
@@ -37,6 +38,8 @@ from .formatting import (
     strike,
     tg_emoji,
     underline,
+    user_open_message,
+    user_open_message_link,
 )
 from .global_context import (
     ABCGlobalContext,
@@ -109,6 +112,7 @@ __all__ = (
     "StartGroupLink",
     "TelegrinderCtx",
     "TgEmoji",
+    "UserOpenMessage",
     "block_quote",
     "bold",
     "channel_boost_link",
@@ -135,4 +139,6 @@ __all__ = (
     "strike",
     "tg_emoji",
     "underline",
+    "user_open_message",
+    "user_open_message_link",
 )

telegrinder/tools/buttons.py

@@ -26,13 +26,11 @@ class DataclassInstance(typing.Protocol):
 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)
+            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]
@@ -65,18 +63,15 @@ class InlineButton(BaseButton):
     url: str | None = None
     login_url: dict[str, typing.Any] | LoginUrl | None = None
     pay: bool | None = None
-    callback_data: typing.Union[
-        str,
-        dict[str, typing.Any],
-        DataclassInstance,
-        msgspec.Struct,
-    ] | None = None
+    callback_data: (
+        str | dict[str, typing.Any] | DataclassInstance | msgspec.Struct | None
+    ) = None
     callback_game: dict[str, typing.Any] | CallbackGame | None = None
     switch_inline_query: str | None = None
     switch_inline_query_current_chat: str | None = None
-    switch_inline_query_chosen_chat: dict[
-        str, typing.Any
-    ] | SwitchInlineQueryChosenChat | None = None
+    switch_inline_query_chosen_chat: (
+        dict[str, typing.Any] | SwitchInlineQueryChosenChat | None
+    ) = None
     web_app: dict[str, typing.Any] | WebAppInfo | None = None
 
 

telegrinder/tools/error_handler/error_handler.py

@@ -74,9 +74,9 @@ class Catcher(typing.Generic[EventT]):
     
     def match_exception(self, exception: BaseException) -> bool:
         for exc in self.exceptions:
-            if isinstance(exc, type) and type(exception) == exc:
+            if isinstance(exc, type) and type(exception) is exc:
                 return True
-            if isinstance(exc, object) and type(exception) == type(exc):
+            if isinstance(exc, object) and type(exception) is type(exc):
                 return True if not exc.args else exc.args == exception.args
         return False
 

telegrinder/tools/formatting/__init__.py

@@ -18,6 +18,7 @@ from .html import (
     strike,
     tg_emoji,
     underline,
+    user_open_message,
 )
 from .links import (
     get_channel_boost_link,
@@ -26,6 +27,7 @@ from .links import (
     get_resolve_domain_link,
     get_start_bot_link,
     get_start_group_link,
+    user_open_message_link,
 )
 from .spec_html_formats import (
     BaseSpecFormat,
@@ -39,6 +41,7 @@ from .spec_html_formats import (
     StartBotLink,
     StartGroupLink,
     TgEmoji,
+    UserOpenMessage,
 )
 
 __all__ = (
@@ -55,6 +58,7 @@ __all__ = (
     "StartBotLink",
     "StartGroupLink",
     "TgEmoji",
+    "UserOpenMessage",
     "block_quote",
     "bold",
     "channel_boost_link",
@@ -78,4 +82,6 @@ __all__ = (
     "strike",
     "tg_emoji",
     "underline",
+    "user_open_message",
+    "user_open_message_link",
 )

telegrinder/tools/formatting/html.py

@@ -13,6 +13,7 @@ from .links import (
     get_resolve_domain_link,
     get_start_bot_link,
     get_start_group_link,
+    user_open_message_link,
 )
 from .spec_html_formats import SpecialFormat, is_spec_format
 
@@ -274,6 +275,14 @@ def underline(string: str) -> TagFormat:
     return TagFormat(string, tag="u")
 
 
+def user_open_message(
+    user_id: int,
+    message: str | None = None,
+    string: str | None = None,
+) -> TagFormat:
+    return link(user_open_message_link(user_id, message), string)
+
+
 __all__ = (
     "FormatString",
     "HTMLFormatter",
@@ -301,4 +310,5 @@ __all__ = (
     "strike",
     "tg_emoji",
     "underline",
+    "user_open_message",
 )

telegrinder/tools/formatting/links.py

@@ -22,6 +22,12 @@ def get_invite_chat_link(invite_link: str) -> str:
     return f"tg://join?invite={invite_link}"
 
 
+def user_open_message_link(user_id: int, message: str | None = None) -> str:
+    return f"tg://openmessage?user_id={user_id}" + (
+        "" if not message else f"&msg?text={message}"
+    )
+
+
 __all__ = (
     "get_channel_boost_link",
     "get_invite_chat_link",
@@ -29,4 +35,5 @@ __all__ = (
     "get_resolve_domain_link",
     "get_start_bot_link",
     "get_start_group_link",
+    "user_open_message_link",
 )