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

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -19,12 +19,18 @@ if typing.TYPE_CHECKING:
 class WaiterMachine:
     def __init__(self) -> None:
         self.storage: Storage = {}
+    
+    def __repr__(self) -> str:
+        return "<{}: storage={!r}>".format(
+            self.__class__.__name__,
+            self.storage,
+        )
 
     async def drop(
         self,
         state_view: "ABCStateView[EventModel]",
         id: Identificator,
-        **context,
+        **context: typing.Any,
     ) -> None:
         view_name = state_view.__class__.__name__
         if view_name not in self.storage:
@@ -60,9 +66,9 @@ class WaiterMachine:
         *rules: ABCRule[EventModel],
         default: Behaviour = None,
         on_drop: Behaviour = None,
-        expiration: datetime.timedelta | int | None = None,
+        expiration: datetime.timedelta | int | float | None = None,
     ) -> tuple[EventModel, Context]:
-        if isinstance(expiration, int):
+        if isinstance(expiration, int | float):
             expiration = datetime.timedelta(seconds=expiration)
 
         api: ABCAPI
@@ -77,9 +83,9 @@ class WaiterMachine:
 
         short_state = ShortState(
             key,
-            ctx_api=api,
-            event=event,
-            rules=rules,
+            api,
+            event,
+            rules,
             expiration=expiration,
             default_behaviour=default,
             on_drop_behaviour=on_drop,
@@ -104,13 +110,13 @@ class WaiterMachine:
         view: "ABCStateView[EventModel]",
         behaviour: Behaviour,
         event: asyncio.Event | EventModel,
-        **context,
+        **context: typing.Any,
     ) -> None:
         if behaviour is None:
             return
         # TODO: add behaviour check
         # TODO: support view as a behaviour
-        await behaviour.run(event)
+        await behaviour.run(event, context)  # type: ignore
 
 
 __all__ = ("WaiterMachine",)

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -38,32 +38,34 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         if key is None:
             raise RuntimeError("Unable to get state key.")
 
-        short_state: typing.Optional["ShortState"] = self.machine.storage[view_name].get(key)
+        short_state: typing.Optional["ShortState[EventType]"] = self.machine.storage[view_name].get(key)
         if not short_state:
             return True
 
         if (
-            short_state.expiration is not None
-            and datetime.datetime.now() >= short_state.expiration
+            short_state.expiration_date is not None
+            and datetime.datetime.now() >= short_state.expiration_date
         ):
             await self.machine.drop(self.view, short_state.key)
             return True
         
         handler = FuncHandler(
-            self.pass_runtime, list(short_state.rules), dataclass=None
+            self.pass_runtime,
+            list(short_state.rules),
+            dataclass=None,
         )
-        handler.ctx.set("short_state", short_state)
+        handler.preset_context.set("short_state", short_state)
         result = await handler.check(event.ctx_api, ctx.raw_update, ctx)
 
         if result is True:
-            await handler.run(event)
+            await handler.run(event, ctx)
 
         elif short_state.default_behaviour is not None:
             await self.machine.call_behaviour(
                 self.view,
                 short_state.default_behaviour,
                 event,
-                **handler.ctx,
+                **handler.preset_context,
             )
 
         return False

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -1,8 +1,9 @@
 import asyncio
+import dataclasses
 import datetime
 import typing
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import ABCAPI
 from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
 from telegrinder.bot.rules.abc import ABCRule
@@ -14,24 +15,22 @@ EventModel = typing.TypeVar("EventModel", bound=BaseCute)
 Behaviour: typing.TypeAlias = ABCHandler | None
 
 
+@dataclasses.dataclass
 class ShortState(typing.Generic[EventModel]):
-    def __init__(
-        self,
-        key: "Identificator",
-        ctx_api: ABCAPI,
-        event: asyncio.Event,
-        rules: tuple[ABCRule[EventModel], ...],
-        expiration: datetime.timedelta | None = None,
-        default_behaviour: Behaviour | None = None,
-        on_drop_behaviour: Behaviour | None = None,
-    ) -> None:
-        self.key = key
-        self.ctx_api = ctx_api
-        self.event = event
-        self.rules = rules
-        self.default_behaviour = default_behaviour
-        self.expiration = (datetime.datetime.now() + expiration) if expiration else None
-        self.on_drop_behaviour = on_drop_behaviour
+    key: "Identificator"
+    ctx_api: ABCAPI
+    event: asyncio.Event
+    rules: tuple[ABCRule[EventModel], ...]
+    _: dataclasses.KW_ONLY
+    expiration: dataclasses.InitVar[datetime.timedelta | None] = dataclasses.field(default=None)
+    default_behaviour: Behaviour | None = dataclasses.field(default=None)
+    on_drop_behaviour: Behaviour | None = dataclasses.field(default=None)
+    expiration_date: datetime.datetime | None = dataclasses.field(init=False)
+
+    def __post_init__(self, expiration: datetime.timedelta | None = None) -> None:
+        self.expiration_date = (
+            datetime.datetime.now() - expiration
+        ) if expiration is not None else None
 
 
 __all__ = ("ShortState",)

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/rules/text.py

@@ -14,7 +14,7 @@ class TextMessageRule(MessageRule, ABC, requires=[HasText()]):
 
 
 class Text(TextMessageRule):
-    def __init__(self, texts: str | list[str], ignore_case: bool = False):
+    def __init__(self, texts: str | list[str], *, ignore_case: bool = False) -> None:
         if not isinstance(texts, list):
             texts = [texts]
         self.texts = texts if not ignore_case else list(map(str.lower, texts))

telegrinder/bot/scenario/checkbox.py

@@ -45,6 +45,21 @@ 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} "
+            "for chat_id={} with message={!r}>"
+        ).format(
+            self.__class__.__name__,
+            self.random_code,
+            self.choices,
+            self.max_in_row,
+            self.waiter_machine,
+            self.ready,
+            self.chat_id,
+            self.msg,
+        )
 
     def get_markup(self) -> InlineKeyboardMarkup:
         kb = InlineKeyboard()
@@ -70,6 +85,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         name: str,
         default_text: str,
         picked_text: str,
+        *,
         is_picked: bool = False,
     ) -> typing.Self:
         self.choices.append(

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/msgspec_utils.py

@@ -4,9 +4,6 @@ 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:
     from datetime import datetime
 
@@ -18,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)
@@ -26,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]
 
@@ -90,6 +91,32 @@ def variative_dec_hook(tp: type[Variative], obj: typing.Any) -> Variative:
 
 
 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
+
+    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.
+
+    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>}
+    ```
+    """
+
     def __init__(self) -> None:
         self.dec_hooks: dict[typing.Any, DecHook[typing.Any]] = {
             Option: option_dec_hook,
@@ -119,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(
@@ -166,6 +193,21 @@ 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[typing.Any, EncHook[typing.Any]] = {
             fntypes.option.Some: lambda opt: opt.value,
@@ -174,9 +216,10 @@ class Encoder:
             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
     
@@ -194,11 +237,11 @@ class Encoder:
         ...
     
     @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:

telegrinder/node/base.py

@@ -6,7 +6,7 @@ ComposeResult: typing.TypeAlias = typing.Coroutine[typing.Any, typing.Any, typin
 
 
 class ComposeError(BaseException):
-    pass
+    ...
 
 
 class Node(abc.ABC):

telegrinder/node/composer.py

@@ -27,7 +27,7 @@ class NodeSession:
             self.generator = None
 
     def __repr__(self) -> str:
-        return f"<NodeSession {self.value}" + ("ACTIVE>" if self.generator else ">")
+        return f"<NodeSession: {self.value}" + ("ACTIVE>" if self.generator else ">")
 
 
 class NodeCollection:

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/error_handler/abc.py

@@ -13,12 +13,12 @@ Handler = typing.Callable[typing.Concatenate[EventT, ...], typing.Awaitable[typi
 
 class ABCErrorHandler(ABC, typing.Generic[EventT]):
     @abstractmethod
-    def register_catcher(
+    def __call__(
         self,
         *args: typing.Any,
         **kwargs: typing.Any,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]]:
-        ...
+        """Decorator for registering callback as an error handler."""
 
     @abstractmethod
     async def run(
@@ -28,7 +28,7 @@ class ABCErrorHandler(ABC, typing.Generic[EventT]):
         api: ABCAPI,
         ctx: Context,
     ) -> Result[typing.Any, typing.Any]:
-        ...
+        """Run error handler."""
 
 
 __all__ = ("ABCErrorHandler",)

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
 
@@ -97,27 +97,8 @@ class ErrorHandler(ABCErrorHandler[EventT]):
             if self.catcher is not None
             else "<ErrorHandler: No catcher>"
         )
-    
-    async def __call__(
-        self,
-        handler: Handler[EventT],
-        event: EventT,
-        api: ABCAPI,
-        ctx: Context,
-    ) -> Result[typing.Any, BaseException]:
-        assert self.catcher is not None
 
-        try:
-            return await self.catcher(handler, event, api, ctx)
-        except BaseException as exc:
-            return Error(CatcherError(
-                exc,
-                "Exception {!r} was occurred during the running catcher {!r}.".format(
-                    repr(exc), self.catcher.func.__name__
-                )
-            ))
-    
-    def register_catcher(
+    def __call__(
         self,
         *exceptions: type[BaseException] | BaseException,
         logging: bool = False,
@@ -142,6 +123,25 @@ class ErrorHandler(ABCErrorHandler[EventT]):
             return func
         return decorator
     
+    async def process(
+        self,
+        handler: Handler[EventT],
+        event: EventT,
+        api: ABCAPI,
+        ctx: Context,
+    ) -> Result[typing.Any, BaseException]:
+        assert self.catcher is not None
+
+        try:
+            return await self.catcher(handler, event, api, ctx)
+        except BaseException as exc:
+            return Error(CatcherError(
+                exc,
+                "Exception {!r} was occurred during the running catcher {!r}.".format(
+                    repr(exc), self.catcher.func.__name__
+                )
+            ))
+        
     def process_catcher_error(self, error: CatcherError) -> Result[None, str]:
         assert self.catcher is not None
         
@@ -164,7 +164,7 @@ class ErrorHandler(ABCErrorHandler[EventT]):
         if not self.catcher:
             return Ok(await handler(event, **magic_bundle(handler, ctx)))  # type: ignore
         
-        match await self(handler, event, api, ctx):
+        match await self.process(handler, event, api, ctx):
             case Ok(_) as ok:
                 return ok
             case Error(exc) as err:

telegrinder/tools/global_context/global_context.py

@@ -23,11 +23,13 @@ else:
 
 
 def type_check(value: object, value_type: type[T]) -> typing.TypeGuard[T]:
-    return (
-        True
-        if value_type in (typing.Any, object)
-        else bool(msgspec_convert(value, value_type))
-    )
+    if value_type in (typing.Any, object):
+        return True
+    match msgspec_convert(value, value_type):
+        case Ok(v):
+            return type(value) is type(v)
+        case Error(_):
+            return False
 
 
 def is_dunder(name: str) -> bool:

telegrinder/tools/magic.py

@@ -9,7 +9,7 @@ if typing.TYPE_CHECKING:
     T = typing.TypeVar("T", bound=ABCRule)
 
 FuncType: typing.TypeAlias = types.FunctionType | typing.Callable[..., typing.Any]
-TRANSLATIONS_KEY = "_translations"
+TRANSLATIONS_KEY: typing.Final[str] = "_translations"
 
 
 def resolve_arg_names(func: FuncType, start_idx: int = 1) -> tuple[str, ...]:

telegrinder/types/objects.py

@@ -2864,6 +2864,23 @@ class Birthdate(Model):
     year: Option[int] = Nothing
     """Optional. Year of the user's birth."""
 
+    @property
+    def is_birthday(self) -> bool:
+        """True, if today is a user's birthday."""
+
+        now = datetime.now()
+        return now.month == self.month and now.day == self.day
+
+    @property
+    def age(self) -> Option[int]:
+        """Optional. Contains the user's age, if the user has a birth year specified."""
+
+        return self.year.map(
+            lambda year: (
+                (datetime.now() - datetime(year, self.month, self.day)) // 365
+            ).days
+        )
+
 
 class BusinessIntro(Model):
     """Object `BusinessIntro`, see the [documentation](https://core.telegram.org/bots/api#businessintro).
@@ -2902,11 +2919,11 @@ class BusinessOpeningHoursInterval(Model):
 
     opening_minute: int
     """The minute's sequence number in a week, starting on Monday, marking the 
-    start of the time interval during which the business is open; 0 - 7 24 60."""
+    start of the time interval during which the business is open; 0 - 7 * 24 * 60."""
 
     closing_minute: int
     """The minute's sequence number in a week, starting on Monday, marking the 
-    end of the time interval during which the business is open; 0 - 8 24 60."""
+    end of the time interval during which the business is open; 0 - 8 * 24 * 60."""
 
 
 class BusinessOpeningHours(Model):

{telegrinder-0.1.dev162.dist-info → telegrinder-0.1.dev164.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telegrinder
-Version: 0.1.dev162
+Version: 0.1.dev164
 Summary: Framework for effective and reliable async telegram bot building.
 Home-page: https://github.com/timoniq/telegrinder
 License: MIT