telegrinder 0.1.dev165__py3-none-any.whl → 0.1.dev167__py3-none-any.whl

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -5,21 +5,25 @@ import typing
 from telegrinder.api.abc import ABCAPI
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.tools.limited_dict import LimitedDict
+from telegrinder.types import Update
 
 from .middleware import WaiterMiddleware
 from .short_state import Behaviour, EventModel, ShortState
 
-Identificator: typing.TypeAlias = str | int
-Storage: typing.TypeAlias = dict[str, dict[Identificator, "ShortState"]]
-
 if typing.TYPE_CHECKING:
     from telegrinder.bot.dispatch.view.abc import ABCStateView, BaseStateView
 
+T = typing.TypeVar("T")
+
+Identificator: typing.TypeAlias = str | int
+Storage: typing.TypeAlias = dict[str, LimitedDict[Identificator, ShortState[EventModel]]]
+
 
 class WaiterMachine:
     def __init__(self) -> None:
         self.storage: Storage = {}
-    
+
     def __repr__(self) -> str:
         return "<{}: storage={!r}>".format(
             self.__class__.__name__,
@@ -30,6 +34,7 @@ class WaiterMachine:
         self,
         state_view: "ABCStateView[EventModel]",
         id: Identificator,
+        update: Update,
         **context: typing.Any,
     ) -> None:
         view_name = state_view.__class__.__name__
@@ -37,25 +42,25 @@ class WaiterMachine:
             raise LookupError("No record of view {!r} found".format(view_name))
 
         short_state = self.storage[view_name].pop(id, None)
-        if not short_state:
+        if short_state is None:
             raise LookupError(
                 "Waiter with identificator {} is not found for view {!r}".format(
-                    id,
-                    view_name,
+                    id, view_name
                 )
             )
 
         waiters = typing.cast(
             typing.Iterable[asyncio.Future[typing.Any]],
-            short_state.event._waiters  # type: ignore
+            short_state.event._waiters,  # type: ignore
         )
         for future in waiters:
             future.cancel()
 
         await self.call_behaviour(
             state_view,
-            short_state.on_drop_behaviour,
             short_state.event,
+            update,
+            behaviour=short_state.on_drop_behaviour,
             **context,
         )
 
@@ -66,21 +71,22 @@ class WaiterMachine:
         *rules: ABCRule[EventModel],
         default: Behaviour = None,
         on_drop: Behaviour = None,
-        expiration: datetime.timedelta | int | float | None = None,
+        expiration: datetime.timedelta | int | None = None,
     ) -> tuple[EventModel, Context]:
         if isinstance(expiration, int | float):
             expiration = datetime.timedelta(seconds=expiration)
 
         api: ABCAPI
         key: Identificator
-        event = asyncio.Event()
-        if isinstance(linked, tuple):
-            api, key = linked
-        else:
-            api, key = linked.ctx_api, state_view.get_state_key(linked)  # type: ignore
-            if not key:
-                raise RuntimeError("Unable to get state key.")
+        api, key = (
+            linked
+            if isinstance(linked, tuple)
+            else (linked.ctx_api, state_view.get_state_key(linked))
+        )  # type: ignore
+        if not key:
+            raise RuntimeError("Unable to get state key.")
 
+        event = asyncio.Event()
         short_state = ShortState(
             key,
             api,
@@ -90,33 +96,42 @@ class WaiterMachine:
             default_behaviour=default,
             on_drop_behaviour=on_drop,
         )
-
         view_name = state_view.__class__.__name__
         if view_name not in self.storage:
             state_view.middlewares.insert(0, WaiterMiddleware(self, state_view))
-            self.storage[view_name] = {}
+            self.storage[view_name] = LimitedDict()
 
         self.storage[view_name][key] = short_state
-
         await event.wait()
 
         e, ctx = getattr(event, "context")
-        self.storage[view_name].pop(key)
-
+        self.storage[view_name].pop(key, None)
         return e, ctx
 
     async def call_behaviour(
         self,
         view: "ABCStateView[EventModel]",
-        behaviour: Behaviour,
         event: asyncio.Event | EventModel,
+        update: Update,
+        behaviour: Behaviour[EventModel] | None = None,
         **context: typing.Any,
     ) -> None:
+        # TODO: support param view as a behaviour
+
+        ctx = Context(**context)
+
+        if isinstance(event, asyncio.Event):
+            event, preset_ctx = typing.cast(
+                tuple[EventModel, Context],
+                getattr(event, "context"),
+            )
+            ctx.update(preset_ctx)
+
         if behaviour is None:
             return
-        # TODO: add behaviour check
-        # TODO: support view as a behaviour
-        await behaviour.run(event, context)  # type: ignore
 
+        if await behaviour.check(event.api, update, ctx):
+            await behaviour.run(event, ctx)
+        
 
 __all__ = ("WaiterMachine",)

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -38,23 +38,24 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         if key is None:
             raise RuntimeError("Unable to get state key.")
 
-        short_state: typing.Optional["ShortState[EventType]"] = self.machine.storage[view_name].get(key)
+        short_state: "ShortState[EventType] | None" = self.machine.storage[view_name].get(key)
         if not short_state:
             return True
-
+        
+        preset_context = Context(short_state=short_state)
         if (
             short_state.expiration_date is not None
             and datetime.datetime.now() >= short_state.expiration_date
         ):
-            await self.machine.drop(self.view, short_state.key)
+            await self.machine.drop(self.view, short_state.key, ctx.raw_update, **preset_context.copy())
             return True
-        
+
         handler = FuncHandler(
             self.pass_runtime,
             list(short_state.rules),
             dataclass=None,
+            preset_context=preset_context,
         )
-        handler.preset_context.set("short_state", short_state)
         result = await handler.check(event.ctx_api, ctx.raw_update, ctx)
 
         if result is True:
@@ -63,14 +64,20 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         elif short_state.default_behaviour is not None:
             await self.machine.call_behaviour(
                 self.view,
-                short_state.default_behaviour,
                 event,
+                ctx.raw_update,
+                behaviour=short_state.default_behaviour,
                 **handler.preset_context,
             )
 
         return False
 
-    async def pass_runtime(self, event: EventType, short_state: "ShortState[EventType]", ctx: Context) -> None:
+    async def pass_runtime(
+        self,
+        event: EventType,
+        short_state: "ShortState[EventType]",
+        ctx: Context,
+    ) -> None:
         setattr(short_state.event, "context", (event, ctx))
         short_state.event.set()
 

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -7,12 +7,15 @@ 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
+from telegrinder.model import Model
 
 if typing.TYPE_CHECKING:
     from .machine import Identificator
 
+T = typing.TypeVar("T", bound=Model)
 EventModel = typing.TypeVar("EventModel", bound=BaseCute)
-Behaviour: typing.TypeAlias = ABCHandler | None
+
+Behaviour: typing.TypeAlias = ABCHandler[T] | None
 
 
 @dataclasses.dataclass
@@ -22,15 +25,15 @@ class ShortState(typing.Generic[EventModel]):
     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: dataclasses.InitVar[datetime.timedelta | None] = dataclasses.field(
+        default=None,
+    )
+    default_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None)
+    on_drop_behaviour: Behaviour[EventModel] | 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
+        self.expiration_date = (datetime.datetime.now() - expiration) if expiration is not None else None
 
 
 __all__ = ("ShortState",)

telegrinder/bot/polling/polling.py

@@ -33,7 +33,7 @@ class Polling(ABCPolling):
         self.max_reconnetions = 10 if max_reconnetions < 0 else max_reconnetions
         self.offset = offset
         self._stop = False
-    
+
     def __repr__(self) -> str:
         return (
             "<{}: with api={!r}, stopped={}, offset={}, allowed_updates={!r}, "
@@ -60,9 +60,7 @@ class Polling(ABCPolling):
 
         if include_updates and exclude_updates:
             allowed_updates = [
-                x
-                for x in allowed_updates
-                if x in include_updates and x not in exclude_updates
+                x for x in allowed_updates if x in include_updates and x not in exclude_updates
             ]
         elif exclude_updates:
             allowed_updates = [x for x in allowed_updates if x not in exclude_updates]

telegrinder/bot/rules/__init__.py

@@ -1,4 +1,4 @@
-from .abc import ABCRule, AndRule, MessageRule, OrRule
+from .abc import ABCRule, AndRule, NotRule, OrRule
 from .callback_data import (
     CallbackDataEq,
     CallbackDataJsonEq,
@@ -9,6 +9,12 @@ from .callback_data import (
     CallbackQueryRule,
     HasData,
 )
+from .chat_join import (
+    ChatJoinRequestRule,
+    HasInviteLink,
+    InviteLinkByCreator,
+    InviteLinkName,
+)
 from .command import Argument, Command
 from .enum_text import EnumTextRule
 from .func import FuncRule
@@ -22,13 +28,10 @@ from .inline import (
 )
 from .integer import Integer, IntegerInRange
 from .is_from import (
-    IsBasketballDice,
     IsBot,
-    IsBowlingDice,
     IsChat,
     IsChatId,
-    IsDartDice,
-    IsDice,
+    IsDiceEmoji,
     IsForum,
     IsForward,
     IsForwardType,
@@ -43,11 +46,13 @@ from .is_from import (
 )
 from .markup import Markup
 from .mention import HasMention
+from .message import MessageRule
 from .message_entities import HasEntities, MessageEntities
 from .regex import Regex
 from .rule_enum import RuleEnum
 from .start import StartCommand
 from .text import HasText, Text, TextMessageRule
+from .update import IsUpdate
 
 __all__ = (
     "ABCRule",
@@ -60,25 +65,29 @@ __all__ = (
     "CallbackDataMarkup",
     "CallbackQueryDataRule",
     "CallbackQueryRule",
+    "ChatJoinRequestRule",
     "Command",
     "EnumTextRule",
     "FuncRule",
     "FuzzyText",
     "HasData",
     "HasEntities",
+    "HasInviteLink",
+    "HasLocation",
     "HasMention",
     "HasText",
+    "InlineQueryChatType",
+    "InlineQueryMarkup",
     "InlineQueryRule",
     "InlineQueryText",
     "Integer",
     "IntegerInRange",
-    "IsBasketballDice",
+    "InviteLinkByCreator",
+    "InviteLinkName",
     "IsBot",
-    "IsBowlingDice",
     "IsChat",
     "IsChatId",
-    "IsDartDice",
-    "IsDice",
+    "IsDiceEmoji",
     "IsForum",
     "IsForward",
     "IsForwardType",
@@ -88,14 +97,13 @@ __all__ = (
     "IsPrivate",
     "IsReply",
     "IsSuperGroup",
+    "IsUpdate",
     "IsUser",
     "IsUserId",
-    "HasLocation",
-    "InlineQueryChatType",
-    "InlineQueryMarkup",
     "Markup",
     "MessageEntities",
     "MessageRule",
+    "NotRule",
     "OrRule",
     "Regex",
     "RuleEnum",

telegrinder/bot/rules/abc.py

@@ -102,18 +102,9 @@ class NotRule(ABCRule[T]):
         return not await check_rule(event.ctx_api, self.rule, event, ctx_copy)
 
 
-class MessageRule(ABCRule[Message], ABC, requires=[]):
-    adapter = EventAdapter("message", Message)
-
-    @abstractmethod
-    async def check(self, message: Message, ctx: Context) -> bool:
-        ...
-
-
 __all__ = (
     "ABCRule",
     "AndRule",
-    "MessageRule",
     "NotRule",
     "OrRule",
     "with_caching_translations",

telegrinder/bot/rules/adapter/event.py

@@ -9,41 +9,48 @@ from telegrinder.bot.rules.adapter.errors import AdapterError
 from telegrinder.msgspec_utils import Nothing
 from telegrinder.types.objects import Model, Update
 
-EventT = typing.TypeVar("EventT", bound=Model)
 CuteT = typing.TypeVar("CuteT", bound=BaseCute)
 
 
 class EventAdapter(ABCAdapter[Update, CuteT]):
-    def __init__(self, event_name: str, model: type[CuteT]) -> None:
-        self.event_name = event_name
-        self.model = model
-    
+    def __init__(self, event: str | type[Model], cute_model: type[CuteT]) -> None:
+        self.event = event
+        self.cute_model = cute_model
+
     def __repr__(self) -> str:
-        raw_update_type = Update.__annotations__.get(self.event_name, "Unknown")
-        raw_update_type = (
-            typing.get_args(raw_update_type)[0].__forward_arg__
-            if typing.get_args(raw_update_type)
-            else raw_update_type
-        )
+        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 {} -> {}>".format(
             self.__class__.__name__,
             raw_update_type,
-            self.model.__name__,
+            self.cute_model.__name__,
         )
 
     async def adapt(self, api: ABCAPI, update: Update) -> Result[CuteT, AdapterError]:
         update_dct = update.to_dict()
-        if self.event_name not in update_dct:
-            return Error(
-                AdapterError(f"Update is not of event type {self.event_name!r}."),
+        if isinstance(self.event, str):
+            if self.event not in update_dct:
+                return Error(
+                    AdapterError(f"Update is not of event type {self.event!r}."),
+                )
+            if update_dct[self.event] is Nothing:
+                return Error(
+                    AdapterError(f"Update is not an {self.event!r}."),
+                )
+            return Ok(
+                self.cute_model.from_update(update_dct[self.event].unwrap(), bound_api=api),
             )
-        if update_dct[self.event_name] is Nothing:
-            return Error(
-                AdapterError(f"Update is not an {self.event_name!r}."),
-            )
-        return Ok(
-            self.model.from_update(update_dct[self.event_name].unwrap(), bound_api=api),
-        )
+        event = update_dct[update.update_type.unwrap()].unwrap()
+        if not update.update_type or not issubclass(event.__class__, self.event):
+            return Error(AdapterError(f"Update is not an {self.event.__name__!r}."))
+        return Ok(self.cute_model.from_update(event, bound_api=api))
 
 
 __all__ = ("EventAdapter",)

telegrinder/bot/rules/callback_data.py

@@ -14,16 +14,13 @@ from telegrinder.tools.buttons import DataclassInstance
 from .abc import ABCRule
 from .markup import Markup, PatternLike, check_string
 
-T = typing.TypeVar("T")
-
-Ref: typing.TypeAlias = typing.Annotated[T, ...]
 CallbackQuery: typing.TypeAlias = CallbackQueryCute
 Validator: typing.TypeAlias = typing.Callable[[typing.Any], bool | typing.Awaitable[bool]]
 MapDict: typing.TypeAlias = dict[
-    str, typing.Any | type[typing.Any] | Validator | list[Ref["MapDict"]] | Ref["MapDict"]
+    str, "typing.Any | type[typing.Any] | Validator | list[MapDict] | MapDict"
 ]
-CallbackMap: typing.TypeAlias = list[tuple[str, typing.Any | type | Validator | Ref["CallbackMap"]]]
-CallbackMapStrict: typing.TypeAlias = list[tuple[str, Validator | Ref["CallbackMapStrict"]]]
+CallbackMap: typing.TypeAlias = list[tuple[str, "typing.Any | type | Validator | CallbackMap"]]
+CallbackMapStrict: typing.TypeAlias = list[tuple[str, "Validator | CallbackMapStrict"]]
 
 
 class CallbackQueryRule(ABCRule[CallbackQuery], abc.ABC):
@@ -52,20 +49,20 @@ class CallbackDataMap(CallbackQueryDataRule):
     @classmethod
     def transform_to_map(cls, mapping: MapDict) -> CallbackMap:
         """Transforms MapDict to CallbackMap."""
-        
+
         callback_map = []
-        
+
         for k, v in mapping.items():
             if isinstance(v, dict):
                 v = cls.transform_to_map(v)
             callback_map.append((k, v))
-        
+
         return callback_map
 
     @classmethod
     def transform_to_callbacks(cls, callback_map: CallbackMap) -> CallbackMapStrict:
         """Transforms `CallbackMap` to `CallbackMapStrict`."""
-        
+
         callback_map_result = []
 
         for key, value in callback_map:
@@ -78,21 +75,21 @@ class CallbackDataMap(CallbackQueryDataRule):
             else:
                 validator = value
             callback_map_result.append((key, validator))
-        
+
         return callback_map_result
 
     @staticmethod
     async def run_validator(value: typing.Any, validator: Validator) -> bool:
         """Run async or sync validator."""
-        
+
         with suppress(BaseException):
             result = validator(value)
             if inspect.isawaitable(result):
                 result = await result
             return result  # type: ignore
-        
+
         return False
-        
+
     @classmethod
     async def match(cls, callback_data: dict, callback_map: CallbackMapStrict) -> bool:
         """Matches callback_data with callback_map recursively."""
@@ -100,19 +97,19 @@ class CallbackDataMap(CallbackQueryDataRule):
         for key, validator in callback_map:
             if key not in callback_data:
                 return False
-            
+
             if isinstance(validator, list):
                 if not (
                     isinstance(callback_data[key], dict)
                     and await cls.match(callback_data[key], validator)
                 ):
                     return False
-            
+
             elif not await cls.run_validator(callback_data[key], validator):
                 return False
 
         return True
-    
+
     async def check(self, event: CallbackQuery, ctx: Context) -> bool:
         callback_data = event.decode_callback_data().unwrap_or_none()
         if callback_data is None:
@@ -142,7 +139,7 @@ class CallbackDataJsonEq(CallbackQueryDataRule):
 class CallbackDataJsonModel(CallbackQueryDataRule):
     def __init__(self, model: type[msgspec.Struct] | type[DataclassInstance]):
         self.model = model
-        
+
     async def check(self, event: CallbackQuery, ctx: Context) -> bool:
         with suppress(BaseException):
             ctx.data = decoder.decode(event.data.unwrap().encode(), type=self.model)

telegrinder/bot/rules/chat_join.py

@@ -0,0 +1,47 @@
+import abc
+import typing
+
+from telegrinder.bot.cute_types import ChatJoinRequestCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.adapter import EventAdapter
+
+from .abc import ABCRule
+
+ChatJoinRequest: typing.TypeAlias = ChatJoinRequestCute
+
+
+class ChatJoinRequestRule(ABCRule[ChatJoinRequestCute], requires=[]):
+    adapter = EventAdapter("chat_join_request", ChatJoinRequest)
+
+    @abc.abstractmethod
+    async def check(self, event: ChatJoinRequest, ctx: Context) -> bool:
+        pass
+
+
+class HasInviteLink(ChatJoinRequestRule):
+    async def check(self, event: ChatJoinRequest, ctx: Context) -> bool:
+        return bool(event.invite_link)
+
+
+class InviteLinkName(ChatJoinRequestRule, requires=[HasInviteLink()]):
+    def __init__(self, name: str, /) -> None:
+        self.name = name
+
+    async def check(self, event: ChatJoinRequest, ctx: Context) -> bool:
+        return event.invite_link.unwrap().name.unwrap_or_none() == self.name
+
+
+class InviteLinkByCreator(ChatJoinRequestRule, requires=[HasInviteLink()]):
+    def __init__(self, creator_id: int, /) -> None:
+        self.creator_id = creator_id
+
+    async def check(self, event: ChatJoinRequest, ctx: Context) -> bool:
+        return event.invite_link.unwrap().creator.id == self.creator_id
+
+
+__all__ = (
+    "ChatJoinRequestRule",
+    "HasInviteLink",
+    "InviteLinkByCreator",
+    "InviteLinkName",
+)

telegrinder/bot/rules/enum_text.py

@@ -6,13 +6,18 @@ from telegrinder.bot.dispatch.context import Context
 from .abc import Message
 from .text import TextMessageRule
 
-T = typing.TypeVar("T", bound=enum.Enum, covariant=True)
+T = typing.TypeVar("T", bound=enum.Enum)
 
 
 class EnumTextRule(TextMessageRule, typing.Generic[T]):
     def __init__(self, enum_t: type[T], *, lower_case: bool = True) -> None:
         self.enum_t = enum_t
-        self.texts = list(map(lambda x: x.value.lower() if lower_case else x.value, self.enum_t))
+        self.texts = list(
+            map(
+                lambda x: x.value.lower() if lower_case else x.value,
+                self.enum_t,
+            )
+        )
 
     def find(self, s: str) -> T:
         for enumeration in self.enum_t:

telegrinder/bot/rules/fuzzy.py

@@ -15,8 +15,7 @@ class FuzzyText(TextMessageRule):
 
     async def check(self, message: Message, ctx: Context) -> bool:
         match = max(
-            difflib.SequenceMatcher(a=message.text.unwrap(), b=text).ratio()
-            for text in self.texts
+            difflib.SequenceMatcher(a=message.text.unwrap(), b=text).ratio() for text in self.texts
         )
         if match < self.min_ratio:
             return False

telegrinder/bot/rules/inline.py

@@ -48,15 +48,15 @@ class InlineQueryText(InlineQueryRule):
 class InlineQueryMarkup(InlineQueryRule):
     def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
         self.patterns = Markup(patterns).patterns
-    
+
     async def check(self, query: InlineQuery, ctx: Context) -> bool:
         return check_string(self.patterns, query.query, ctx)
 
 
 __all__ = (
     "HasLocation",
+    "InlineQueryChatType",
+    "InlineQueryMarkup",
     "InlineQueryRule",
     "InlineQueryText",
-    "InlineQueryMarkup",
-    "InlineQueryChatType",
 )