telegrinder 0.1.dev164__py3-none-any.whl → 0.1.dev166__py3-none-any.whl

telegrinder/bot/rules/is_from.py

@@ -1,24 +1,34 @@
 import typing
 
+from fntypes.co import Nothing, Some
+
 from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.cute_types.update import UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.msgspec_utils import Option
 from telegrinder.types.enums import ChatType, DiceEmoji
 from telegrinder.types.objects import User
 
-from .abc import ABCRule, Message, MessageRule
+from .abc import ABCRule, Message
+from .message import MessageRule
 
 T = typing.TypeVar("T", bound=BaseCute)
 
 
+def get_from_user(obj: typing.Any) -> User:
+    assert isinstance(obj, FromUserProto)
+    return obj.from_.unwrap() if isinstance(obj.from_, Some | Nothing) else obj.from_
+
+
 @typing.runtime_checkable
 class FromUserProto(typing.Protocol):
     from_: User | Option[User]
 
 
 class HasFrom(ABCRule[T]):
-    async def check(self, event: T, ctx: Context) -> bool:
-        return isinstance(event, FromUserProto) and bool(event.from_)
+    async def check(self, event: UpdateCute, ctx: Context) -> bool:
+        event_model = event.incoming_update.unwrap()
+        return isinstance(event_model, FromUserProto) and bool(event_model.from_)
 
 
 class HasDice(MessageRule):
@@ -49,29 +59,30 @@ class IsSticker(MessageRule):
         return bool(message.sticker)
 
 
-class IsBot(MessageRule, requires=[HasFrom()]):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.from_user.is_bot
+class IsBot(ABCRule[T], requires=[HasFrom()]):
+    async def check(self, event: UpdateCute, ctx: Context) -> bool:
+        return get_from_user(event.incoming_update.unwrap()).is_bot
 
 
-class IsUser(MessageRule, requires=[HasFrom()]):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return not message.from_user.is_bot
+class IsUser(ABCRule[T], requires=[HasFrom()]):
+    async def check(self, event: UpdateCute, ctx: Context) -> bool:
+        return not get_from_user(event.incoming_update.unwrap()).is_bot
 
 
-class IsPremium(MessageRule, requires=[HasFrom()]):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.from_user.is_premium.unwrap_or(False)
+class IsPremium(ABCRule[T], requires=[HasFrom()]):
+    async def check(self, event: UpdateCute, ctx: Context) -> bool:
+        return get_from_user(event.incoming_update.unwrap()).is_premium.unwrap_or(False)
 
 
-class IsLanguageCode(MessageRule, requires=[HasFrom()]):
+class IsLanguageCode(ABCRule[T], requires=[HasFrom()]):
     def __init__(self, lang_codes: str | list[str], /) -> None:
         self.lang_codes = [lang_codes] if isinstance(lang_codes, str) else lang_codes
 
-    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() in self.lang_codes
+    async def check(self, event: UpdateCute, ctx: Context) -> bool:
+        return (
+            get_from_user(event.incoming_update.unwrap())
+            .language_code.unwrap_or_none() in self.lang_codes
+        )
 
 
 class IsForum(MessageRule):
@@ -79,12 +90,12 @@ class IsForum(MessageRule):
         return message.chat.is_forum.unwrap_or(False)
 
 
-class IsUserId(MessageRule, requires=[HasFrom()]):
+class IsUserId(ABCRule[T], requires=[HasFrom()]):
     def __init__(self, user_ids: int | list[int], /) -> None:
         self.user_ids = [user_ids] if isinstance(user_ids, int) else user_ids
 
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.from_user.id in self.user_ids
+    async def check(self, event: UpdateCute, ctx: Context) -> bool:
+        return get_from_user(event.incoming_update.unwrap()).id in self.user_ids
 
 
 class IsChatId(MessageRule):
@@ -115,44 +126,19 @@ class IsChat(MessageRule):
         return message.chat.type in (ChatType.GROUP, ChatType.SUPERGROUP)
 
 
-class IsDice(MessageRule, requires=[HasDice()]):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.dice.unwrap().emoji == DiceEmoji.DICE
-
-
-class IsDartDice(MessageRule, requires=[HasDice()]):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.dice.unwrap().emoji == DiceEmoji.DART
-
-
-class IsBasketballDice(MessageRule, requires=[HasDice()]):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.dice.unwrap().emoji == DiceEmoji.BASKETBALL
-
-
-class IsFootballDice(MessageRule, requires=[HasDice()]):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.dice.unwrap().emoji == DiceEmoji.FOOTBALL
-
-
-class IsSlotMachineDice(MessageRule, requires=[HasDice()]):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return message.dice.unwrap().emoji == DiceEmoji.SLOT_MACHINE
-
+class IsDiceEmoji(MessageRule, requires=[HasDice()]):
+    def __init__(self, dice_emoji: DiceEmoji, /) -> None:
+        self.dice_emoji = dice_emoji
 
-class IsBowlingDice(MessageRule, requires=[HasDice()]):
     async def check(self, message: Message, ctx: Context) -> bool:
-        return message.dice.unwrap().emoji == DiceEmoji.BOWLING
+        return message.dice.unwrap().emoji == self.dice_emoji 
 
 
 __all__ = (
-    "IsBasketballDice",
     "IsBot",
-    "IsBowlingDice",
     "IsChat",
     "IsChatId",
-    "IsDartDice",
-    "IsDice",
+    "IsDiceEmoji",
     "IsForum",
     "IsForward",
     "IsForwardType",

telegrinder/bot/rules/markup.py

@@ -24,7 +24,7 @@ def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
 
 
 class Markup(TextMessageRule):
-    def __init__(self, patterns: PatternLike | list[PatternLike]):
+    def __init__(self, patterns: PatternLike | list[PatternLike], /):
         if not isinstance(patterns, list):
             patterns = [patterns]
         self.patterns = [

telegrinder/bot/rules/message.py

@@ -0,0 +1,17 @@
+import abc
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.types.objects import Message as MessageEvent
+
+from .abc import ABCRule, Message
+from .adapter import EventAdapter
+
+
+class MessageRule(ABCRule[Message], abc.ABC):
+    adapter = EventAdapter(MessageEvent, Message)
+
+    @abc.abstractmethod
+    async def check(self, message: Message, ctx: Context) -> bool: ...
+
+
+__all__ = ("MessageRule",)

telegrinder/bot/rules/message_entities.py

@@ -4,7 +4,7 @@ from telegrinder.bot.dispatch.context import Context
 from telegrinder.types.enums import MessageEntityType
 from telegrinder.types.objects import MessageEntity
 
-from .abc import Message, MessageRule
+from .message import Message, MessageRule
 
 Entity: typing.TypeAlias = str | MessageEntityType
 

telegrinder/bot/rules/start.py

@@ -3,17 +3,19 @@ import typing
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.types.enums import MessageEntityType
 
-from .abc import MessageRule
 from .is_from import IsPrivate
 from .markup import Markup, Message
+from .message import MessageRule
 from .message_entities import MessageEntities
 
 
 class StartCommand(
-    MessageRule, requires=[
-        IsPrivate() & MessageEntities(MessageEntityType.BOT_COMMAND)
+    MessageRule,
+    requires=[
+        IsPrivate()
+        & MessageEntities(MessageEntityType.BOT_COMMAND)
         & Markup(["/start <param>", "/start"]),
-    ]
+    ],
 ):
     def __init__(
         self,

telegrinder/bot/rules/text.py

@@ -1,7 +1,8 @@
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.tools.i18n.base import ABCTranslator
 
-from .abc import ABC, Message, MessageRule, with_caching_translations
+from .abc import ABC, Message, with_caching_translations
+from .message import MessageRule
 
 
 class HasText(MessageRule):

telegrinder/bot/rules/update.py

@@ -0,0 +1,16 @@
+from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.types.enums import UpdateType
+
+from .abc import ABCRule, T
+
+
+class IsUpdate(ABCRule[T]):
+    def __init__(self, update_type: UpdateType, /) -> None:
+        self.update_type = update_type
+
+    async def check(self, event: UpdateCute, ctx: Context) -> bool:
+        return event.update_type.unwrap_or_none() == self.update_type
+
+
+__all__ = ("IsUpdate",)

telegrinder/bot/scenario/checkbox.py

@@ -45,7 +45,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         self.max_in_row = max_in_row
         self.random_code = secrets.token_hex(8)
         self.waiter_machine = waiter_machine
-    
+
     def __repr__(self) -> str:
         return (
             "<{}@{!r}: (choices={!r}, max_in_row={}) with waiter_machine={!r}, ready_text={!r} "
@@ -69,14 +69,16 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
                 choice = choices.pop(0)
                 kb.add(
                     InlineButton(
-                        text=choice.default_text
-                        if not choice.is_picked
-                        else choice.picked_text,
+                        text=(
+                            choice.default_text
+                            if not choice.is_picked
+                            else choice.picked_text
+                        ),
                         callback_data=self.random_code + "/" + choice.code,
                     )
                 )
             kb.row()
-        
+
         kb.add(InlineButton(self.ready, callback_data=self.random_code + "/ready"))
         return kb.get_markup()
 
@@ -125,14 +127,14 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
                 reply_markup=self.get_markup(),
             )
         ).unwrap()
-        
+
         while True:
             q, _ = await self.waiter_machine.wait(view, (api, message.message_id))
             should_continue = await self.handle(q)
             await q.answer(self.CALLBACK_ANSWER)
             if not should_continue:
                 break
-        
+
         return (
             {choice.name: choice.is_picked for choice in self.choices},
             message.message_id,

telegrinder/client/aiohttp.py

@@ -24,7 +24,7 @@ class AiohttpClient(ABCClient):
         self.json_processing_module = json_processing_module or json
         self.session_params = session_params
         self.timeout = timeout or aiohttp.ClientTimeout(total=0)
-    
+
     def __repr__(self) -> str:
         return "<{}: session={!r}, timeout={}, closed={}>".format(
             self.__class__.__name__,
@@ -32,7 +32,7 @@ class AiohttpClient(ABCClient):
             self.timeout,
             True if self.session is None else self.session.closed,
         )
-    
+
     async def request_raw(
         self,
         url: str,
@@ -118,10 +118,10 @@ class AiohttpClient(ABCClient):
         form = aiohttp.formdata.FormData(quote_fields=False)
         for k, v in data.items():
             form.add_field(k, str(v))
-        
+
         for n, f in files.items():
             form.add_field(n, f[1], filename=f[0])
-        
+
         return form
 
     def __del__(self) -> None:

telegrinder/model.py

@@ -14,7 +14,7 @@ T = typing.TypeVar("T")
 
 if typing.TYPE_CHECKING:
     from telegrinder.api.error import APIError
-    
+
 
 MODEL_CONFIG: typing.Final[dict[str, typing.Any]] = {
     "omit_defaults": True,
@@ -26,16 +26,14 @@ MODEL_CONFIG: typing.Final[dict[str, typing.Any]] = {
 @typing.overload
 def full_result(
     result: Result[msgspec.Raw, "APIError"], full_t: type[T]
-) -> Result[T, "APIError"]:
-    ...
+) -> Result[T, "APIError"]: ...
 
 
 @typing.overload
 def full_result(
     result: Result[msgspec.Raw, "APIError"],
     full_t: tuple[type[T], ...],
-) -> Result[T, "APIError"]:
-    ...
+) -> Result[T, "APIError"]: ...
 
 
 def full_result(
@@ -57,11 +55,15 @@ def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
 
 
 class Model(msgspec.Struct, **MODEL_CONFIG):
+    @classmethod
+    def from_bytes(cls, data: bytes) -> typing.Self:
+        return decoder.decode(data, type=cls)
+
     def to_dict(
         self,
         *,
         exclude_fields: set[str] | None = None,
-    ) -> dict[str, typing.Any]:  
+    ) -> dict[str, typing.Any]:
         exclude_fields = exclude_fields or set()
         if "model_as_dict" not in self.__dict__:
             self.__dict__["model_as_dict"] = msgspec.structs.asdict(self)
@@ -76,18 +78,24 @@ class Model(msgspec.Struct, **MODEL_CONFIG):
 class DataConverter:
     files: dict[str, tuple[str, bytes]] = dataclasses.field(default_factory=lambda: {})
 
+    def __repr__(self) -> str:
+        return "<{}: {}>".format(
+            self.__class__.__name__,
+            ", ".join(f"{k}={v!r}" for k, v in self.converters),
+        )
+
     @property
     def converters(self) -> dict[type[typing.Any], typing.Callable[..., typing.Any]]:
         return {
             get_origin(value.__annotations__["data"]): value
             for key, value in vars(self.__class__).items()
-            if key.startswith("convert_") and callable(value)   
+            if key.startswith("convert_") and callable(value)
         }
 
     @staticmethod
     def convert_enum(data: enum.Enum, _: bool = True) -> typing.Any:
         return data.value
-    
+
     @staticmethod
     def convert_datetime(data: datetime, _: bool = True) -> int:
         return int(data.timestamp())
@@ -99,29 +107,45 @@ class DataConverter:
                 return converter(data, serialize)
             return converter(self, data, serialize)
         return data
-    
+
     def get_converter(self, t: type[typing.Any]):
         for type, converter in self.converters.items():
             if issubclass(t, type):
                 return converter
         return None
-    
-    def convert_model(self, data: Model, serialize: bool = True) -> str | dict[str, typing.Any]:
+
+    def convert_model(
+        self,
+        data: Model,
+        serialize: bool = True,
+    ) -> str | dict[str, typing.Any]:
         converted_dct = self(data.to_dict(), serialize=False)
         return encoder.encode(converted_dct) if serialize is True else converted_dct
-    
-    def convert_dct(self, data: dict[str, typing.Any], serialize: bool = True) -> dict[str, typing.Any]:
+
+    def convert_dct(
+        self,
+        data: dict[str, typing.Any],
+        serialize: bool = True,
+    ) -> dict[str, typing.Any]:
         return {
             k: self(v, serialize=serialize)
             for k, v in data.items()
             if type(v) not in (NoneType, Nothing)
         }
-    
-    def convert_lst(self, data: list[typing.Any], serialize: bool = True) -> str | list[typing.Any]:
+
+    def convert_lst(
+        self,
+        data: list[typing.Any],
+        serialize: bool = True,
+    ) -> str | list[typing.Any]:
         converted_lst = [self(x, serialize=False) for x in data]
         return encoder.encode(converted_lst) if serialize is True else converted_lst
-    
-    def convert_tpl(self, data: tuple[typing.Any, ...], _: bool = True) -> str | tuple[typing.Any, ...]:
+
+    def convert_tpl(
+        self,
+        data: tuple[typing.Any, ...],
+        _: bool = True,
+    ) -> str | tuple[typing.Any, ...]:
         if (
             isinstance(data, tuple)
             and len(data) == 2
@@ -132,12 +156,12 @@ class DataConverter:
             self.files[attach_name] = data
             return "attach://{}".format(attach_name)
         return data
-    
+
 
 __all__ = (
     "DataConverter",
+    "MODEL_CONFIG",
     "Model",
     "full_result",
     "get_params",
-    "MODEL_CONFIG",
 )

telegrinder/modules.py

@@ -6,32 +6,24 @@ from choicelib import choice_in_order
 
 @typing.runtime_checkable
 class JSONModule(typing.Protocol):
-    def loads(self, s: str | bytes) -> typing.Any:
-        ...
+    def loads(self, s: str | bytes) -> typing.Any: ...
 
-    def dumps(self, o: 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:
-        ...
+    def debug(self, __msg: object, *args: object, **kwargs: object) -> None: ...
 
-    def info(self, __msg: object, *args: object, **kwargs: object) -> None:
-        ...
+    def info(self, __msg: object, *args: object, **kwargs: object) -> None: ...
 
-    def warning(self, __msg: object, *args: object, **kwargs: object) -> None:
-        ...
+    def warning(self, __msg: object, *args: object, **kwargs: object) -> None: ...
 
-    def error(self, __msg: object, *args: object, **kwargs: object) -> None:
-        ...
+    def error(self, __msg: object, *args: object, **kwargs: object) -> None: ...
 
-    def critical(self, __msg: object, *args: object, **kwargs: object) -> None:
-        ...
+    def critical(self, __msg: object, *args: object, **kwargs: object) -> None: ...
 
-    def exception(self, __msg: object, *args: object, **kwargs: object) -> None:
-        ...
+    def exception(self, __msg: object, *args: object, **kwargs: object) -> None: ...
 
     def set_level(
         self,
@@ -43,8 +35,7 @@ class LoggerModule(typing.Protocol):
             "CRITICAL",
             "EXCEPTION",
         ],
-    ) -> None:
-        ...
+    ) -> None: ...
 
 
 logger: LoggerModule
@@ -147,8 +138,7 @@ elif logging_module == "logging":
         },
     }
     FORMAT = (
-        FORMAT
-        .replace("<white>", COLORS["white"])
+        FORMAT.replace("<white>", COLORS["white"])
         .replace("</white>", COLORS["reset"])
         .replace("<green>", COLORS["green"])
         .replace("</green>", COLORS["reset"])
@@ -157,24 +147,20 @@ elif logging_module == "logging":
     for level, settings in LEVEL_SETTINGS.items():
         fmt = FORMAT
         for name, color in settings.items():
-            fmt = (
-                fmt
-                .replace(f"<{name}>", COLORS[color])
-                .replace(f"</{name}>", COLORS["reset"])
+            fmt = fmt.replace(f"<{name}>", COLORS[color]).replace(
+                f"</{name}>", COLORS["reset"]
             )
         LEVEL_FORMATS[level] = fmt
 
-
     class TelegrinderLoggingFormatter(logging.Formatter):
-        def format(self, record: logging.LogRecord) -> str:  
+        def format(self, record: logging.LogRecord) -> str:
             if not record.funcName or record.funcName == "<module>":
                 record.funcName = "\b"
             frame = next(
                 (
                     frame
                     for frame in inspect.stack()
-                    if frame.filename == record.pathname
-                    and frame.lineno == record.lineno
+                    if frame.filename == record.pathname and frame.lineno == record.lineno
                 ),
                 None,
             )
@@ -187,7 +173,6 @@ elif logging_module == "logging":
                 style="{",
             ).format(record)
 
-
     class LogMessage:
         def __init__(self, fmt: typing.Any, args: typing.Any, kwargs: typing.Any) -> None:
             self.fmt = fmt
@@ -197,7 +182,6 @@ elif logging_module == "logging":
         def __str__(self) -> str:
             return self.fmt.format(*self.args, **self.kwargs)
 
-
     class TelegrinderLoggingStyleAdapter(logging.LoggerAdapter):
         def __init__(
             self,
@@ -223,7 +207,7 @@ elif logging_module == "logging":
                 for key in inspect.getfullargspec(self.logger._log).args[1:]
                 if key in kwargs
             }
-            
+
             if isinstance(msg, str):
                 msg = LogMessage(msg, args, kwargs)
                 args = tuple()
@@ -245,7 +229,7 @@ def _set_logger_level(level):
         logging.getLogger("telegrinder").setLevel(logging.getLevelName(level))
     elif logging_module == "loguru":
         import loguru  # type: ignore
-        
+
         if handler_id in loguru.logger._core.handlers:  # type: ignore
             loguru.logger._core.handlers[handler_id]._levelno = loguru.logger.level(level).no  # type: ignore