telegrinder 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

telegrinder/bot/cute_types/update.py

@@ -1,5 +1,4 @@
 import typing
-from functools import cached_property
 
 from fntypes.co import Nothing, Some
 
@@ -96,10 +95,6 @@ class UpdateCute(BaseCute[Update], Update, kw_only=True):
     """Optional. A request to join the chat has been sent. The bot must have the can_invite_users
     administrator right in the chat to receive these updates."""
 
-    @cached_property
-    def incoming_update(self) -> Model:
-        return getattr(self, self.update_type.value).unwrap()
-
     def get_event(self, event_model: type[EventModel]) -> Option[EventModel]:
         if isinstance(self.incoming_update, event_model):
             return Some(self.incoming_update)

telegrinder/bot/dispatch/middleware/abc.py

@@ -3,11 +3,17 @@ from abc import ABC
 
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.model import Model
+from telegrinder.types.objects import Update
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.rules.adapter.abc import ABCAdapter
 
 Event = typing.TypeVar("Event", bound=Model)
 
 
 class ABCMiddleware(ABC, typing.Generic[Event]):
+    adapter: "ABCAdapter[Update, Event] | None" = None
+
     async def pre(self, event: Event, ctx: Context) -> bool: ...
 
     async def post(self, event: Event, responses: list[typing.Any], ctx: Context) -> None: ...

telegrinder/bot/dispatch/process.py

@@ -1,5 +1,7 @@
+import inspect
 import typing
 
+from fntypes.option import Nothing, Option, Some
 from fntypes.result import Error, Ok
 
 from telegrinder.api.api import API
@@ -16,10 +18,27 @@ from telegrinder.types.objects import Update
 if typing.TYPE_CHECKING:
     from telegrinder.bot.dispatch.handler.abc import ABCHandler
     from telegrinder.bot.rules.abc import ABCRule
+    from telegrinder.bot.rules.adapter.abc import ABCAdapter
 
+T = typing.TypeVar("T")
 Event = typing.TypeVar("Event", bound=Model)
 
 
+async def run_adapter(
+    adapter: "ABCAdapter[Update, T]",
+    api: API,
+    update: Update,
+    context: Context,
+) -> Option[T]:
+    adapt_result = adapter.adapt(api, update, context)
+    match await adapt_result if inspect.isawaitable(adapt_result) else adapt_result:
+        case Ok(value):
+            return Some(value)
+        case Error(err):
+            logger.debug("Adapter failed with error message: {!r}", str(err))
+            return Nothing()
+
+
 async def process_inner(
     api: API,
     event: Event,
@@ -34,6 +53,13 @@ async def process_inner(
 
     logger.debug("Run pre middlewares...")
     for middleware in middlewares:
+        if middleware.adapter is not None:
+            match await run_adapter(middleware.adapter, api, raw_event, ctx):
+                case Some(val):
+                    event = val
+                case Nothing():
+                    return False
+
         middleware_result = await middleware.pre(event, ctx)
         logger.debug("Middleware {!r} returned: {!r}", middleware.__class__.__qualname__, middleware_result)
         if middleware_result is False:
@@ -83,11 +109,10 @@ async def check_rule(
     Returns check result."""
 
     # Running adapter
-    match await rule.adapter.adapt(api, update, ctx):
-        case Ok(value):
-            adapted_value = value
-        case Error(err):
-            logger.debug("Adapter failed with error message: {!r}", str(err))
+    match await run_adapter(rule.adapter, api, update, ctx):
+        case Some(val):
+            adapted_value = val
+        case Nothing():
             return False
 
     # Preparing update

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -45,10 +45,15 @@ class WaiterMachine:
             self.base_state_lifetime,
         )
 
+    def create_middleware(self, view: BaseStateView[EventModel]) -> WaiterMiddleware[EventModel]:
+        hasher = StateViewHasher(view)
+        self.storage[hasher] = LimitedDict(maxlimit=self.max_storage_size)
+        return WaiterMiddleware(self, hasher)
+
     async def drop_all(self) -> None:
         """Drops all waiters in storage."""
 
-        for hasher in self.storage:
+        for hasher in self.storage.copy():
             for ident, short_state in self.storage[hasher].items():
                 if short_state.context:
                     await self.drop(hasher, ident)

telegrinder/bot/rules/abc.py

@@ -202,12 +202,12 @@ class Always(ABCRule):
 
 
 __all__ = (
-    "ABCRule",
-    "Always",
-    "AndRule",
-    "CheckResult",
-    "Never",
-    "NotRule",
-    "OrRule",
+    "ABCRule",
+    "Always",
+    "AndRule",
+    "CheckResult",
+    "Never",
+    "NotRule",
+    "OrRule",
     "with_caching_translations",
 )

telegrinder/bot/rules/adapter/__init__.py

@@ -1,14 +1,17 @@
-from telegrinder.bot.rules.adapter.abc import ABCAdapter, Event
+from telegrinder.bot.rules.adapter.abc import ABCAdapter, AdaptResult, Event
 from telegrinder.bot.rules.adapter.errors import AdapterError
 from telegrinder.bot.rules.adapter.event import EventAdapter
 from telegrinder.bot.rules.adapter.node import NodeAdapter
+from telegrinder.bot.rules.adapter.raw_event import RawEventAdapter
 from telegrinder.bot.rules.adapter.raw_update import RawUpdateAdapter
 
 __all__ = (
-    "ABCAdapter",
-    "AdapterError",
-    "Event",
-    "EventAdapter",
-    "NodeAdapter",
+    "ABCAdapter",
+    "AdaptResult",
+    "AdapterError",
+    "Event",
+    "EventAdapter",
+    "NodeAdapter",
+    "RawEventAdapter",
     "RawUpdateAdapter",
 )

telegrinder/bot/rules/adapter/abc.py

@@ -12,12 +12,14 @@ from telegrinder.model import Model
 From = typing.TypeVar("From", bound=Model)
 To = typing.TypeVar("To")
 
+AdaptResult: typing.TypeAlias = Result[To, AdapterError] | typing.Awaitable[Result[To, AdapterError]]
+
 
 class ABCAdapter(abc.ABC, typing.Generic[From, To]):
     ADAPTED_VALUE_KEY: str | None = None
 
     @abc.abstractmethod
-    async def adapt(self, api: API, update: From, context: Context) -> Result[To, AdapterError]:
+    def adapt(self, api: API, update: From, context: Context) -> AdaptResult[To]:
         pass
 
 
@@ -26,4 +28,4 @@ class Event(typing.Generic[To]):
     obj: To
 
 
-__all__ = ("ABCAdapter", "Event")
+__all__ = ("ABCAdapter", "AdaptResult", "Event")

telegrinder/bot/rules/adapter/event.py

@@ -4,6 +4,7 @@ from fntypes.result import Error, Ok, Result
 
 from telegrinder.api.api import API
 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.bot.rules.adapter.abc import ABCAdapter
 from telegrinder.bot.rules.adapter.errors import AdapterError
@@ -22,46 +23,43 @@ class EventAdapter(ABCAdapter[Update, ToCute]):
         self.cute_model = cute_model
 
     def __repr__(self) -> str:
-        if isinstance(self.event, str):
-            raw_update_type = Update.__annotations__.get(self.event, "Unknown")
-            raw_update_type = (
-                typing.get_args(raw_update_type)[0].__forward_arg__
-                if typing.get_args(raw_update_type)
-                else raw_update_type
-            )
-        else:
-            raw_update_type = self.event.__name__
-
-        return "<{}: adapt Update -> {} -> {}>".format(
+        raw_update_type = (
+            f"Update -> {self.event.__name__}"
+            if isinstance(self.event, type)
+            else f"Update.{self.event.value}"
+        )
+        return "<{}: adapt {} -> {}>".format(
             self.__class__.__name__,
             raw_update_type,
             self.cute_model.__name__,
         )
 
-    async def adapt(self, api: API, update: Update, context: Context) -> Result[ToCute, AdapterError]:
-        if self.ADAPTED_VALUE_KEY in context:
-            return Ok(context[self.ADAPTED_VALUE_KEY])
+    def get_event(self, update: UpdateCute) -> Model | None:
+        if isinstance(self.event, UpdateType) and self.event == update.update_type:
+            return update.incoming_update
 
-        match await RawUpdateAdapter().adapt(api, update, context):
-            case Ok(update_cute):
-                incoming_update = None
-                if isinstance(self.event, UpdateType) and self.event == update_cute.update_type:
-                    incoming_update = update_cute.incoming_update
-                if not isinstance(self.event, UpdateType) and (event := update_cute.get_event(self.event)):
-                    incoming_update = update_cute.get_event(self.event).unwrap_or_none()
+        if not isinstance(self.event, UpdateType) and (event := update.get_event(self.event)):
+            return event.unwrap()
 
-                if incoming_update is not None:
-                    adapted = (
-                        typing.cast(ToCute, incoming_update)
-                        if isinstance(incoming_update, BaseCute)
-                        else self.cute_model.from_update(incoming_update, bound_api=api)
-                    )
-                    context[self.ADAPTED_VALUE_KEY] = adapted
-                    return Ok(adapted)
+        return None
 
-                return Error(AdapterError(f"Update is not an {self.event!r}."))
+    def adapt(self, api: API, update: Update, context: Context) -> Result[ToCute, AdapterError]:
+        match RawUpdateAdapter().adapt(api, update, context):
+            case Ok(update_cute) if event := self.get_event(update_cute):
+                if self.ADAPTED_VALUE_KEY in context:
+                    return Ok(context[self.ADAPTED_VALUE_KEY])
+
+                adapted = (
+                    typing.cast(ToCute, event)
+                    if isinstance(event, BaseCute)
+                    else self.cute_model.from_update(event, bound_api=api)
+                )
+                context[self.ADAPTED_VALUE_KEY] = adapted
+                return Ok(adapted)
             case Error(_) as err:
                 return err
+            case _:
+                return Error(AdapterError(f"Update is not an {self.event!r}."))
 
 
 __all__ = ("EventAdapter",)

telegrinder/bot/rules/adapter/raw_event.py

@@ -0,0 +1,27 @@
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.adapter.abc import ABCAdapter
+from telegrinder.bot.rules.adapter.errors import AdapterError
+from telegrinder.model import Model
+from telegrinder.types.objects import Update
+
+
+class RawEventAdapter(ABCAdapter[Update, Model]):
+    def __init__(self, event_model: type[Model], /) -> None:
+        self.event_model = event_model
+
+    def __repr__(self) -> str:
+        return "<{}: adapt Update -> {}>".format(
+            self.__class__.__name__,
+            self.event_model.__name__,
+        )
+
+    def adapt(self, api: API, update: Update, context: Context) -> Result[Model, AdapterError]:
+        if isinstance(update.incoming_update, self.event_model):
+            return Ok(update.incoming_update)
+        return Error(AdapterError(f"Update is not an {self.event_model.__name__!r}."))
+
+
+__all__ = ("RawEventAdapter",)

telegrinder/bot/rules/adapter/raw_update.py

@@ -14,7 +14,7 @@ class RawUpdateAdapter(ABCAdapter[Update, UpdateCute]):
     def __repr__(self) -> str:
         return f"<{self.__class__.__name__}: adapt Update -> UpdateCute>"
 
-    async def adapt(
+    def adapt(
         self,
         api: API,
         update: Update,

telegrinder/bot/rules/callback_data.py

@@ -159,12 +159,12 @@ class CallbackDataMarkup(CallbackQueryDataRule):
 
 
 __all__ = (
-    "CallbackDataEq",
-    "CallbackDataJsonEq",
-    "CallbackDataJsonModel",
-    "CallbackDataMap",
-    "CallbackDataMarkup",
-    "CallbackQueryDataRule",
-    "CallbackQueryRule",
+    "CallbackDataEq",
+    "CallbackDataJsonEq",
+    "CallbackDataJsonModel",
+    "CallbackDataMap",
+    "CallbackDataMarkup",
+    "CallbackQueryDataRule",
+    "CallbackQueryRule",
     "HasData",
 )

telegrinder/bot/rules/chat_join.py

@@ -39,8 +39,8 @@ class InviteLinkByCreator(ChatJoinRequestRule, requires=[HasInviteLink()]):
 
 
 __all__ = (
-    "ChatJoinRequestRule",
-    "HasInviteLink",
-    "InviteLinkByCreator",
+    "ChatJoinRequestRule",
+    "HasInviteLink",
+    "InviteLinkByCreator",
     "InviteLinkName",
 )

telegrinder/bot/rules/inline.py

@@ -52,9 +52,9 @@ class InlineQueryMarkup(InlineQueryRule):
 
 
 __all__ = (
-    "HasLocation",
-    "InlineQueryChatType",
-    "InlineQueryMarkup",
-    "InlineQueryRule",
+    "HasLocation",
+    "InlineQueryChatType",
+    "InlineQueryMarkup",
+    "InlineQueryRule",
     "InlineQueryText",
 )

telegrinder/bot/scenario/checkbox.py

@@ -1,4 +1,5 @@
 import dataclasses
+import enum
 import secrets
 import typing
 
@@ -17,6 +18,11 @@ if typing.TYPE_CHECKING:
 Key = typing.TypeVar("Key", bound=typing.Hashable)
 
 
+class ChoiceCode(enum.StrEnum):
+    READY = "ready"
+    CANCEL = "cancel"
+
+
 @dataclasses.dataclass(slots=True)
 class Choice(typing.Generic[Key]):
     key: Key
@@ -79,10 +85,11 @@ class _Checkbox(ABCScenario[CallbackQueryCute]):
                 )
             kb.row()
 
-        kb.add(InlineButton(self.ready, callback_data=self.random_code + "/ready"))
+        kb.add(InlineButton(self.ready, callback_data=self.random_code + "/" + ChoiceCode.READY))
         if self.cancel_text is not None:
             kb.row()
-            kb.add(InlineButton(self.cancel_text, callback_data=self.random_code + "/cancel"))
+            kb.add(InlineButton(self.cancel_text, callback_data=self.random_code + "/" + ChoiceCode.CANCEL))
+
         return kb.get_markup()
 
     def add_option(
@@ -100,11 +107,13 @@ class _Checkbox(ABCScenario[CallbackQueryCute]):
 
     async def handle(self, cb: CallbackQueryCute) -> bool:
         code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
-        if code == "ready":
-            return False
-        elif code == "cancel":
-            self.choices = []
-            return False
+
+        match code:
+            case ChoiceCode.READY:
+                return False
+            case ChoiceCode.CANCEL:
+                self.choices = []
+                return False
 
         for i, choice in enumerate(self.choices):
             if choice.code == code:

telegrinder/bot/scenario/choice.py

@@ -2,45 +2,50 @@ import typing
 
 from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
 from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import Hasher
-from telegrinder.bot.scenario.checkbox import Checkbox
+from telegrinder.bot.scenario.checkbox import Checkbox, ChoiceCode
 
 if typing.TYPE_CHECKING:
-    from telegrinder.api import API
+    from telegrinder.api.api import API
     from telegrinder.bot.dispatch.view.base import BaseStateView
-
-
-class Choice(Checkbox):
-    async def handle(self, cb: CallbackQueryCute) -> bool:
-        code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
-        if code == "ready":
-            return False
-
-        for choice in self.choices:
-            choice.is_picked = False
-
-        for i, choice in enumerate(self.choices):
-            if choice.code == code:
-                self.choices[i].is_picked = True
-                await cb.ctx_api.edit_message_text(
-                    text=self.message,
-                    chat_id=cb.message.unwrap().v.chat.id,
-                    message_id=cb.message.unwrap().v.message_id,
-                    parse_mode=self.PARSE_MODE,
-                    reply_markup=self.get_markup(),
-                )
-
-        return True
-
-    async def wait(
-        self,
-        hasher: Hasher[CallbackQueryCute, int],
-        api: "API",
-        view: "BaseStateView[CallbackQueryCute]",
-    ) -> tuple[str, int]:
-        if len(tuple(choice for choice in self.choices if choice.is_picked)) != 1:
-            raise ValueError("Exactly one choice must be picked")
-        choices, m_id = await super().wait(hasher, api, view)
-        return tuple(choices.keys())[tuple(choices.values()).index(True)], m_id
+    from telegrinder.bot.scenario.checkbox import Key
+
+    class Choice(Checkbox[Key], typing.Generic[Key]):
+        async def wait(
+            self,
+            hasher: Hasher[CallbackQueryCute, int],
+            api: API,
+            view: BaseStateView[CallbackQueryCute],
+        ) -> tuple[Key, int]: ...
+
+else:
+
+    class Choice(Checkbox):
+        async def handle(self, cb):
+            code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
+            if code == ChoiceCode.READY:
+                return False
+
+            for choice in self.choices:
+                choice.is_picked = False
+
+            for i, choice in enumerate(self.choices):
+                if choice.code == code:
+                    self.choices[i].is_picked = True
+                    await cb.ctx_api.edit_message_text(
+                        text=self.message,
+                        chat_id=cb.message.unwrap().v.chat.id,
+                        message_id=cb.message.unwrap().v.message_id,
+                        parse_mode=self.PARSE_MODE,
+                        reply_markup=self.get_markup(),
+                    )
+
+            return True
+
+        async def wait(self, hasher, api, view):
+            if len(tuple(choice for choice in self.choices if choice.is_picked)) != 1:
+                raise ValueError("Exactly one choice must be picked")
+            choices, m_id = await super().wait(hasher, api, view)
+            return tuple(choices.keys())[tuple(choices.values()).index(True)], m_id
 
 
 __all__ = ("Choice",)

telegrinder/model.py

@@ -1,6 +1,8 @@
+import base64
 import dataclasses
 import enum
 import keyword
+import os
 import secrets
 import typing
 from datetime import datetime
@@ -15,6 +17,7 @@ if typing.TYPE_CHECKING:
     from telegrinder.api.error import APIError
 
 T = typing.TypeVar("T")
+P = typing.ParamSpec("P")
 
 UnionType: typing.TypeAlias = typing.Annotated[tuple[T, ...], ...]
 
@@ -46,6 +49,15 @@ def full_result(
     return result.map(lambda v: decoder.decode(v, type=full_t))
 
 
+def generate_random_id(length_bytes: int) -> str:
+    if length_bytes < 1 or length_bytes > 64:
+        raise ValueError("Length of bytes must be between 1 and 64.")
+
+    random_bytes = os.urandom(length_bytes)
+    random_id = base64.urlsafe_b64encode(random_bytes).rstrip(b"=").decode("utf-8")
+    return random_id
+
+
 def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
     validated_params = {}
     for k, v in (
@@ -60,10 +72,6 @@ def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
     return validated_params
 
 
-class From(typing.Generic[T]):
-    def __new__(cls, _: T, /) -> typing.Any: ...
-
-
 if typing.TYPE_CHECKING:
 
     @typing.overload
@@ -72,6 +80,13 @@ if typing.TYPE_CHECKING:
     @typing.overload
     def field(*, default: typing.Any, name: str | None = ...) -> typing.Any: ...
 
+    @typing.overload
+    def field(
+        *,
+        default_factory: typing.Callable[[], typing.Any],
+        name: str | None = None,
+    ) -> typing.Any: ...
+
     @typing.overload
     def field(
         *,
@@ -102,9 +117,14 @@ if typing.TYPE_CHECKING:
         name=...,
         converter=...,
     ) -> typing.Any: ...
+
+    class From(typing.Generic[T]):
+        def __new__(cls, _: T, /) -> typing.Any: ...
 else:
     from msgspec import field as _field
 
+    From = typing.Annotated[T, ...]
+
     def field(**kwargs):
         kwargs.pop("converter", None)
         return _field(**kwargs)
@@ -113,12 +133,16 @@ else:
 @typing.dataclass_transform(field_specifiers=(field,))
 class Model(msgspec.Struct, **MODEL_CONFIG):
     @classmethod
-    def from_data(cls, data: dict[str, typing.Any]) -> typing.Self:
-        return decoder.convert(data, type=cls)
+    def from_data(cls: typing.Callable[P, T], *args: P.args, **kwargs: P.kwargs) -> T:
+        return decoder.convert(msgspec.structs.asdict(cls(*args, **kwargs)), type=cls)  # type: ignore
+
+    @classmethod
+    def from_dict(cls, obj: dict[str, typing.Any], /) -> typing.Self:
+        return decoder.convert(obj, type=cls)
 
     @classmethod
-    def from_bytes(cls, data: bytes) -> typing.Self:
-        return decoder.decode(data, type=cls)
+    def from_bytes(cls, obj: bytes, /) -> typing.Self:
+        return decoder.decode(obj, type=cls)
 
     def _to_dict(
         self,
@@ -285,11 +309,12 @@ else:
 
 
 __all__ = (
-    "DataConverter",
-    "MODEL_CONFIG",
-    "Model",
-    "ProxiedDict",
-    "Proxy",
-    "full_result",
+    "DataConverter",
+    "MODEL_CONFIG",
+    "Model",
+    "ProxiedDict",
+    "Proxy",
+    "full_result",
+    "generate_random_id",
     "get_params",
 )

telegrinder/modules.py

@@ -36,8 +36,8 @@ class LoggerModule(typing.Protocol):
 
 logger: LoggerModule
 logging_level = os.getenv("LOGGER_LEVEL", default="DEBUG").upper()
-logging_module = choice_in_order(["loguru"], default="logging")
-asyncio_module = choice_in_order(["uvloop"], default="asyncio")
+logging_module = choice_in_order(["loguru"], default="logging", do_import=False)
+asyncio_module = choice_in_order(["uvloop"], default="asyncio", do_import=False)
 
 if logging_module == "loguru":
     import os

telegrinder/msgspec_utils.py

@@ -96,7 +96,7 @@ def msgspec_to_builtins(
 
 
 def option_dec_hook(tp: type[Option[typing.Any]], obj: typing.Any) -> Option[typing.Any]:
-    if obj is None:
+    if obj is None or isinstance(obj, fntypes.Nothing):
         return Nothing
 
     (value_type,) = typing.get_args(tp) or (typing.Any,)