telegrinder 0.1.dev167__tar.gz → 0.1.dev168__tar.gz

{telegrinder-0.1.dev167 → telegrinder-0.1.dev168}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telegrinder
-Version: 0.1.dev167
+Version: 0.1.dev168
 Summary: Framework for effective and reliable async telegram bot building.
 Home-page: https://github.com/timoniq/telegrinder
 License: MIT
@@ -49,23 +49,23 @@ Still in development.
 
 Install using pip:
 
-```
+```console
 pip install telegrinder
 ```
 
 Using poetry:
 
-```
+```console
 poetry add telegrinder
 ```
 
 Install from github:
 
-```
+```console
 pip install -U https://github.com/timoniq/telegrinder/archive/dev.zip
 ```
 
-```
+```console
 poetry add git+https://github.com/timoniq/telegrinder.git#dev
 ```
 

{telegrinder-0.1.dev167 → telegrinder-0.1.dev168}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "telegrinder"
-version = "0.1.dev167"
+version = "0.1.dev168"
 description = "Framework for effective and reliable async telegram bot building."
 authors = ["timoniq <tesseradecades@mail.ru>"]
 maintainers = ["luwqz1 <howluwqz1@gmail.com>"]
@@ -46,6 +46,11 @@ typing-extensions = "^4.10.0"
 fntypes = "^0.1.2.post1"
 
 [tool.poetry.group.dev.dependencies]
+ruff = "^0.4.4"
+basedpyright = "^1.12.1"
+isort = "5.13.2"
+sort-all = "1.2.0"
+black = "^24.4.2"
 pytest = "^8.0.0"
 pytest-asyncio = "^0.23.5"
 pytest-cov = "^4.0.0"
@@ -58,7 +63,7 @@ requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.ruff]
-line-length = 100
+line-length = 110
 target-version = "py311"
 lint.select = ["I", "N", "ANN", "COM", "YTT", "TCH", "SIM"]
 lint.ignore = [
@@ -67,8 +72,8 @@ lint.ignore = [
 ]
 
 [tool.black]
-line-length = 90
-target-version = ["py311"]
+line-length = 110
+target-version = ["py311", "py312"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
@@ -77,4 +82,7 @@ asyncio_mode = "auto"
 "__init__.py" = ["F401", "F403"]
 
 [tool.ruff.lint.flake8-quotes]
-docstring-quotes = "double"
+docstring-quotes = "double"
+
+[tool.basedpyright]
+typeCheckingMode = "basic"

{telegrinder-0.1.dev167 → telegrinder-0.1.dev168}/readme.md

@@ -14,23 +14,23 @@ Still in development.
 
 Install using pip:
 
-```
+```console
 pip install telegrinder
 ```
 
 Using poetry:
 
-```
+```console
 poetry add telegrinder
 ```
 
 Install from github:
 
-```
+```console
 pip install -U https://github.com/timoniq/telegrinder/archive/dev.zip
 ```
 
-```
+```console
 poetry add git+https://github.com/timoniq/telegrinder.git#dev
 ```
 

{telegrinder-0.1.dev167 → telegrinder-0.1.dev168}/telegrinder/bot/cute_types/callback_query.py

@@ -217,7 +217,7 @@ class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True, di
     )
     async def edit_text(
         self,
-        text: str | None,
+        text: str,
         inline_message_id: int | None = None,
         chat_id: int | str | None = None,
         message_id: int | None = None,

{telegrinder-0.1.dev167 → telegrinder-0.1.dev168}/telegrinder/bot/dispatch/dispatch.py

@@ -135,7 +135,9 @@ class Dispatch(
 
     async def feed(self, event: Update, api: ABCAPI) -> bool:
         logger.debug("Processing update (update_id={})", event.update_id)
-        await self.raw_event.process(event, api)
+        loop = asyncio.get_running_loop()
+        loop.create_task(self.raw_event.process(event, api))
+        
         for view in self.get_views().values():
             if await view.check(event):
                 logger.debug(
@@ -143,10 +145,9 @@ class Dispatch(
                     event.update_id,
                     view.__class__.__name__,
                 )
-                await view.process(event, api)
+                loop.create_task(view.process(event, api))
                 return True
 
-        loop = asyncio.get_running_loop()
         ctx = Context()
         found = False
         for handler in self.default_handlers:

{telegrinder-0.1.dev167 → telegrinder-0.1.dev168}/telegrinder/bot/dispatch/handler/func.py

@@ -46,7 +46,7 @@ class FuncHandler(ABCHandler[EventT], typing.Generic[EventT, F, ErrorHandlerT]):
             self.dataclass,
             self.error_handler,
         )
-
+    
     async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
         if self.update_type is not None and self.update_type != event.update_type.unwrap_or_none():
             return False

{telegrinder-0.1.dev167 → telegrinder-0.1.dev168}/telegrinder/bot/dispatch/view/abc.py

@@ -67,13 +67,64 @@ class BaseView(ABCView, typing.Generic[EventType]):
                         return Some(generic_type)
         return Nothing()
 
-    @classmethod
-    def get_raw_event(cls, update: Update) -> Option[Model]:
+    @staticmethod
+    def get_raw_event(update: Update) -> Option[Model]:
         match update.update_type:
             case Some(update_type):
                 return getattr(update, update_type.value)
             case _:
                 return Nothing()
+    
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule[EventType],
+    ) -> typing.Callable[
+        [FuncType[EventType]],
+        FuncHandler[EventType, FuncType[EventType], ErrorHandler[EventType]],
+    ]: ...
+
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule[EventType],
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[
+        [FuncType[EventType]], FuncHandler[EventType, FuncType[EventType], ErrorHandlerT]
+    ]: ...
+
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule[EventType],
+        error_handler: typing.Literal[None] = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[
+        [FuncType[EventType]],
+        FuncHandler[EventType, FuncType[EventType], ErrorHandler[EventType]],
+    ]: ...
+
+    @classmethod
+    def to_handler(  # type: ignore
+        cls,
+        *rules: ABCRule[EventType],
+        error_handler: ABCErrorHandler | None = None,
+        is_blocking: bool = True,
+    ):
+        def wrapper(func: FuncType[EventType]):
+            return FuncHandler(
+                func,
+                list(rules),
+                is_blocking=is_blocking,
+                dataclass=None,
+                error_handler=error_handler or ErrorHandler(),
+            )
+
+        return wrapper
 
     @typing.overload
     def __call__(

{telegrinder-0.1.dev167 → telegrinder-0.1.dev168}/telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -39,7 +39,7 @@ class WaiterMachine:
     ) -> None:
         view_name = state_view.__class__.__name__
         if view_name not in self.storage:
-            raise LookupError("No record of view {!r} found".format(view_name))
+            raise LookupError("No record of view {!r} found.".format(view_name))
 
         short_state = self.storage[view_name].pop(id, None)
         if short_state is None:
@@ -49,13 +49,7 @@ class WaiterMachine:
                 )
             )
 
-        waiters = typing.cast(
-            typing.Iterable[asyncio.Future[typing.Any]],
-            short_state.event._waiters,  # type: ignore
-        )
-        for future in waiters:
-            future.cancel()
-
+        short_state.cancel()
         await self.call_behaviour(
             state_view,
             short_state.event,
@@ -69,9 +63,9 @@ class WaiterMachine:
         state_view: "BaseStateView[EventModel]",
         linked: EventModel | tuple[ABCAPI, Identificator],
         *rules: ABCRule[EventModel],
-        default: Behaviour = None,
-        on_drop: Behaviour = None,
-        expiration: datetime.timedelta | int | None = None,
+        default: Behaviour[EventModel] | None = None,
+        on_drop: Behaviour[EventModel] | None = None,
+        expiration: datetime.timedelta | float | None = None,
     ) -> tuple[EventModel, Context]:
         if isinstance(expiration, int | float):
             expiration = datetime.timedelta(seconds=expiration)
@@ -86,6 +80,7 @@ class WaiterMachine:
         if not key:
             raise RuntimeError("Unable to get state key.")
 
+        view_name = state_view.__class__.__name__
         event = asyncio.Event()
         short_state = ShortState(
             key,
@@ -96,17 +91,17 @@ 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] = LimitedDict()
 
-        self.storage[view_name][key] = short_state
+        if (deleted_short_state := self.storage[view_name].set(key, short_state)) is not None:
+            deleted_short_state.cancel()
+        
         await event.wait()
-
-        e, ctx = getattr(event, "context")
         self.storage[view_name].pop(key, None)
-        return e, ctx
+        return getattr(event, "context")
 
     async def call_behaviour(
         self,
@@ -118,8 +113,10 @@ class WaiterMachine:
     ) -> None:
         # TODO: support param view as a behaviour
 
-        ctx = Context(**context)
+        if behaviour is None:
+            return
 
+        ctx = Context(**context)
         if isinstance(event, asyncio.Event):
             event, preset_ctx = typing.cast(
                 tuple[EventModel, Context],
@@ -127,9 +124,6 @@ class WaiterMachine:
             )
             ctx.update(preset_ctx)
 
-        if behaviour is None:
-            return
-
         if await behaviour.check(event.api, update, ctx):
             await behaviour.run(event, ctx)
         

{telegrinder-0.1.dev167 → telegrinder-0.1.dev168}/telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -34,6 +34,16 @@ class ShortState(typing.Generic[EventModel]):
 
     def __post_init__(self, expiration: datetime.timedelta | None = None) -> None:
         self.expiration_date = (datetime.datetime.now() - expiration) if expiration is not None else None
+    
+    def cancel(self) -> None:
+        """Cancel schedule waiters."""
+
+        waiters = typing.cast(
+            typing.Iterable[asyncio.Future[typing.Any]],
+            self.event._waiters,  # type: ignore
+        )
+        for future in waiters:
+            future.cancel()
 
 
 __all__ = ("ShortState",)

{telegrinder-0.1.dev167 → telegrinder-0.1.dev168}/telegrinder/bot/rules/callback_data.py

@@ -16,10 +16,8 @@ from .markup import Markup, PatternLike, check_string
 
 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[MapDict] | MapDict"
-]
-CallbackMap: typing.TypeAlias = list[tuple[str, "typing.Any | type | Validator | CallbackMap"]]
+MapDict: typing.TypeAlias = dict[str, "typing.Any | type[typing.Any] | Validator | list[MapDict] | MapDict"]
+CallbackMap: typing.TypeAlias = list[tuple[str, "typing.Any | type[typing.Any] | Validator | CallbackMap"]]
 CallbackMapStrict: typing.TypeAlias = list[tuple[str, "Validator | CallbackMapStrict"]]
 
 
@@ -41,7 +39,7 @@ class CallbackQueryDataRule(CallbackQueryRule, abc.ABC, requires=[HasData()]):
 
 
 class CallbackDataMap(CallbackQueryDataRule):
-    def __init__(self, mapping: MapDict) -> None:
+    def __init__(self, mapping: MapDict, /) -> None:
         self.mapping = self.transform_to_callbacks(
             self.transform_to_map(mapping),
         )
@@ -86,12 +84,12 @@ class CallbackDataMap(CallbackQueryDataRule):
             result = validator(value)
             if inspect.isawaitable(result):
                 result = await result
-            return result  # type: ignore
+            return result
 
         return False
 
     @classmethod
-    async def match(cls, callback_data: dict, callback_map: CallbackMapStrict) -> bool:
+    async def match(cls, callback_data: dict[str, typing.Any], callback_map: CallbackMapStrict) -> bool:
         """Matches callback_data with callback_map recursively."""
 
         for key, validator in callback_map:
@@ -121,7 +119,7 @@ class CallbackDataMap(CallbackQueryDataRule):
 
 
 class CallbackDataEq(CallbackQueryDataRule):
-    def __init__(self, value: str):
+    def __init__(self, value: str, /) -> None:
         self.value = value
 
     async def check(self, event: CallbackQuery, ctx: Context) -> bool:
@@ -129,7 +127,7 @@ class CallbackDataEq(CallbackQueryDataRule):
 
 
 class CallbackDataJsonEq(CallbackQueryDataRule):
-    def __init__(self, d: dict[str, typing.Any]):
+    def __init__(self, d: dict[str, typing.Any], /) -> None:
         self.d = d
 
     async def check(self, event: CallbackQuery, ctx: Context) -> bool:
@@ -137,7 +135,7 @@ class CallbackDataJsonEq(CallbackQueryDataRule):
 
 
 class CallbackDataJsonModel(CallbackQueryDataRule):
-    def __init__(self, model: type[msgspec.Struct] | type[DataclassInstance]):
+    def __init__(self, model: type[msgspec.Struct] | type[DataclassInstance], /) -> None:
         self.model = model
 
     async def check(self, event: CallbackQuery, ctx: Context) -> bool:
@@ -148,7 +146,7 @@ class CallbackDataJsonModel(CallbackQueryDataRule):
 
 
 class CallbackDataMarkup(CallbackQueryDataRule):
-    def __init__(self, patterns: PatternLike | list[PatternLike]):
+    def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
         self.patterns = Markup(patterns).patterns
 
     async def check(self, event: CallbackQuery, ctx: Context) -> bool:

{telegrinder-0.1.dev167 → telegrinder-0.1.dev168}/telegrinder/bot/scenario/checkbox.py

@@ -33,13 +33,13 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         self,
         waiter_machine: WaiterMachine,
         chat_id: int,
-        msg: str,
+        message: str,
         *,
         ready_text: str = "Ready",
         max_in_row: int = 3,
     ) -> None:
         self.chat_id = chat_id
-        self.msg = msg
+        self.message = message
         self.choices: list[Choice] = []
         self.ready = ready_text
         self.max_in_row = max_in_row
@@ -58,7 +58,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
             self.waiter_machine,
             self.ready,
             self.chat_id,
-            self.msg,
+            self.message,
         )
 
     def get_markup(self) -> InlineKeyboardMarkup:
@@ -101,7 +101,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
                 # Toggle choice
                 self.choices[i].is_picked = not self.choices[i].is_picked
                 await cb.edit_text(
-                    text=self.msg,
+                    text=self.message,
                     parse_mode=self.PARSE_MODE,
                     reply_markup=self.get_markup(),
                 )
@@ -118,7 +118,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         message = (
             await api.send_message(
                 chat_id=self.chat_id,
-                text=self.msg,
+                text=self.message,
                 parse_mode=self.PARSE_MODE,
                 reply_markup=self.get_markup(),
             )

{telegrinder-0.1.dev167 → telegrinder-0.1.dev168}/telegrinder/bot/scenario/choice.py

@@ -1,6 +1,7 @@
 import typing
 
 from telegrinder.bot.cute_types import CallbackQueryCute
+from telegrinder.bot.dispatch.waiter_machine import WaiterMachine
 
 from .checkbox import Checkbox
 
@@ -22,9 +23,9 @@ class SingleChoice(Checkbox):
             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,
-                    text=self.msg,
                     parse_mode=self.PARSE_MODE,
                     reply_markup=self.get_markup(),
                 )
@@ -36,10 +37,10 @@ class SingleChoice(Checkbox):
         api: "API",
         view: "BaseStateView[CallbackQueryCute]",
     ) -> tuple[str, int]:
-        if len([choice for choice in self.choices if choice.is_picked]) != 1:
+        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(api, view)
-        return list(choices.keys())[list(choices.values()).index(True)], m_id
+        return tuple(choices.keys())[tuple(choices.values()).index(True)], m_id
 
 
 __all__ = ("SingleChoice",)

{telegrinder-0.1.dev167 → telegrinder-0.1.dev168}/telegrinder/tools/limited_dict.py

@@ -11,12 +11,22 @@ class LimitedDict(UserDict[KT, VT]):
         self.maxlimit = maxlimit
         self.queue: deque[KT] = deque(maxlen=maxlimit)
 
-    def __setitem__(self, key: KT, value: VT, /) -> None:
+    def set(self, key: KT, value: VT, /) -> VT | None:
+        """Set item in the dictionary.
+        Returns a value that was deleted when the limit in the dictionary
+        was reached, otherwise None.
+        """
+
+        deleted_item = None
         if len(self.queue) >= self.maxlimit:
-            self.pop(self.queue.popleft(), None)
+            deleted_item = self.pop(self.queue.popleft(), None)
         if key not in self.queue:
             self.queue.append(key)
         super().__setitem__(key, value)
+        return deleted_item
+
+    def __setitem__(self, key: KT, value: VT, /) -> None:
+        self.set(key, value)
     
     def __delitem__(self, key: KT) -> None:
         if key in self.queue: