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

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -1,6 +1,7 @@
 import asyncio
 import datetime
 import typing
+from collections import deque
 
 from telegrinder.api.abc import ABCAPI
 from telegrinder.bot.dispatch.context import Context
@@ -9,17 +10,76 @@ from telegrinder.bot.rules.abc import ABCRule
 from .middleware import WaiterMiddleware
 from .short_state import Behaviour, EventModel, ShortState
 
+T = typing.TypeVar("T")
+
+Storage: typing.TypeAlias = dict[str, "ShortStateStorage"]
 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
 
 
+class ShortStateStorage(dict[Identificator, ShortState[EventModel]]):
+    def __init__(self, *, maxlimit: int = 1000) -> None:
+        super().__init__()
+        self.maxlimit = maxlimit
+        self.queue: deque[Identificator] = deque(maxlen=maxlimit)
+    
+    def __repr__(self) -> str:
+        return "<{}: {}, (current={} | maxlimit={})>".format(
+            self.__class__.__name__,
+            super().__repr__(),
+            len(self.queue),
+            self.maxlimit,
+        )
+    
+    def __setitem__(self, key: Identificator, value: ShortState[EventModel], /) -> None:
+        self.add(key, value)
+    
+    def __delitem__(self, key: Identificator, /) -> None:
+        self.pop(key, None)
+
+    def add(self, id: Identificator, short_state: ShortState[EventModel]) -> None:
+        if len(self.queue) >= self.maxlimit:
+            self.pop(self.queue.popleft(), None)
+        if id not in self.queue:
+            self.queue.append(id)
+        super().__setitem__(id, short_state)
+
+    def clear(self) -> None:
+        self.queue.clear()
+        super().clear()
+    
+    def setdefault(self, id: Identificator, default: ShortState[EventModel]) -> ShortState[EventModel]:
+        if id in self:
+            return self[id]
+        self.add(id, default)
+        return default
+    
+    def pop(self, id: Identificator, default: T):  # type: ignore
+        if id in self.queue:
+            self.queue.remove(id)
+        return super().pop(id, default)
+    
+    def popitem(self) -> tuple[Identificator, ShortState[EventModel]]:
+        item = super().popitem()
+        self.queue.remove(item[0])
+        return item
+    
+    def update(
+        self,
+        mapping: typing.Mapping[Identificator, ShortState[EventModel]] | None = None,
+        /,
+        **kwargs: ShortState[EventModel],
+    ) -> None:
+        for key, value in (mapping if mapping is not None else kwargs).items():
+            self.add(key, value)
+
+
 class WaiterMachine:
     def __init__(self) -> None:
         self.storage: Storage = {}
-    
+
     def __repr__(self) -> str:
         return "<{}: storage={!r}>".format(
             self.__class__.__name__,
@@ -37,7 +97,7 @@ 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,
@@ -47,7 +107,7 @@ class WaiterMachine:
 
         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()
@@ -67,20 +127,17 @@ class WaiterMachine:
         default: Behaviour = None,
         on_drop: Behaviour = None,
         expiration: datetime.timedelta | int | float | None = None,
+        short_state_storage: ShortStateStorage[EventModel] | 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: ABCAPI; key: Identificator
+        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,19 +147,16 @@ 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][key] = short_state
+            self.storage[view_name] = short_state_storage or ShortStateStorage()
 
+        self.storage[view_name].add(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(

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -38,7 +38,7 @@ 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
 
@@ -48,13 +48,13 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         ):
             await self.machine.drop(self.view, short_state.key)
             return True
-        
+
         handler = FuncHandler(
             self.pass_runtime,
             list(short_state.rules),
             dataclass=None,
+            preset_context=Context(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:

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -12,6 +12,7 @@ if typing.TYPE_CHECKING:
     from .machine import Identificator
 
 EventModel = typing.TypeVar("EventModel", bound=BaseCute)
+
 Behaviour: typing.TypeAlias = ABCHandler | None
 
 
@@ -22,15 +23,17 @@ 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)
+    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
+            (datetime.datetime.now() - expiration) if expiration is not None else None
+        )
 
 
 __all__ = ("ShortState",)

telegrinder/bot/polling/polling.py

@@ -29,11 +29,27 @@ class Polling(ABCPolling):
             include_updates=include_updates,
             exclude_updates=exclude_updates,
         )
-        self.reconnection_timeout = 5 if reconnection_timeout < 0 else reconnection_timeout
+        self.reconnection_timeout = (
+            5 if reconnection_timeout < 0 else reconnection_timeout
+        )
         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}, "
+            "max_reconnetions={}, reconnection_timeout={}>"
+        ).format(
+            self.__class__.__name__,
+            self.api,
+            self._stop,
+            self.offset,
+            self.allowed_updates,
+            self.max_reconnetions,
+            self.reconnection_timeout,
+        )
+
     def get_allowed_updates(
         self,
         *,

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,50 @@ 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,11 @@ 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"]
-]
-CallbackMap: typing.TypeAlias = list[tuple[str, typing.Any | type | Validator | Ref["CallbackMap"]]]
-CallbackMapStrict: typing.TypeAlias = list[tuple[str, Validator | Ref["CallbackMapStrict"]]]
+MapDict: typing.TypeAlias = dict[str, "typing.Any | type[typing.Any] | Validator | list[MapDict] | MapDict"]
+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 +47,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 +73,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 +95,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 +137,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/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",
 )