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

telegrinder/bot/rules/start.py

@@ -1,42 +1,42 @@
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.types.enums import MessageEntityType
-
-from .is_from import IsPrivate
-from .markup import Markup
-from .message import MessageRule
-from .message_entities import MessageEntities
-
-
-class StartCommand(
-    MessageRule,
-    requires=[
-        IsPrivate(),
-        MessageEntities(MessageEntityType.BOT_COMMAND),
-        Markup(["/start <param>", "/start"]),
-    ],
-):
-    def __init__(
-        self,
-        validator: typing.Callable[[str], typing.Any | None] | None = None,
-        *,
-        param_required: bool = False,
-        alias: str | None = None,
-    ) -> None:
-        self.param_required = param_required
-        self.validator = validator
-        self.alias = alias
-
-    def check(self, ctx: Context) -> bool:
-        param: str | None = ctx.pop("param", None)
-        validated_param = self.validator(param) if self.validator and param is not None else param
-
-        if self.param_required and validated_param is None:
-            return False
-
-        ctx.set(self.alias or "param", validated_param)
-        return True
-
-
-__all__ = ("StartCommand",)
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.types.enums import MessageEntityType
+
+from .is_from import IsPrivate
+from .markup import Markup
+from .message import MessageRule
+from .message_entities import MessageEntities
+
+
+class StartCommand(
+    MessageRule,
+    requires=[
+        IsPrivate(),
+        MessageEntities(MessageEntityType.BOT_COMMAND),
+        Markup(["/start <param>", "/start"]),
+    ],
+):
+    def __init__(
+        self,
+        validator: typing.Callable[[str], typing.Any | None] | None = None,
+        *,
+        param_required: bool = False,
+        alias: str | None = None,
+    ) -> None:
+        self.param_required = param_required
+        self.validator = validator
+        self.alias = alias
+
+    def check(self, ctx: Context) -> bool:
+        param: str | None = ctx.pop("param", None)
+        validated_param = self.validator(param) if self.validator and param is not None else param
+
+        if self.param_required and validated_param is None:
+            return False
+
+        ctx.set(self.alias or "param", validated_param)
+        return True
+
+
+__all__ = ("StartCommand",)

telegrinder/bot/rules/state.py

@@ -1,37 +1,35 @@
-import dataclasses
-import enum
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.node.source import Source
-
-if typing.TYPE_CHECKING:
-    from telegrinder.tools.state_storage.abc import ABCStateStorage
-
-Payload = typing.TypeVar("Payload")
-
-
-class StateMeta(enum.Enum):
-    NO_STATE = enum.auto()
-    ANY = enum.auto()
-
-
-@dataclasses.dataclass(frozen=True, slots=True, repr=False)
-class State(ABCRule, typing.Generic[Payload]):
-    storage: "ABCStateStorage[Payload]"
-    key: str | StateMeta | enum.Enum
-
-    async def check(self, source: Source, ctx: Context) -> bool:
-        state = await self.storage.get(source.from_user.id)
-        if not state:
-            return self.key == StateMeta.NO_STATE
-
-        if self.key != StateMeta.ANY and self.key != state.unwrap().key:
-            return False
-
-        ctx["state"] = state.unwrap()
-        return True
-
-
-__all__ = ("State", "StateMeta")
+import dataclasses
+import enum
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.node.source import Source
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.state_storage.abc import ABCStateStorage
+
+
+class StateMeta(enum.Enum):
+    NO_STATE = enum.auto()
+    ANY = enum.auto()
+
+
+@dataclasses.dataclass(frozen=True, slots=True, repr=False)
+class State[Payload](ABCRule):
+    storage: "ABCStateStorage[Payload]"
+    key: str | StateMeta | enum.Enum
+
+    async def check(self, source: Source, ctx: Context) -> bool:
+        state = await self.storage.get(source.from_user.id)
+        if not state:
+            return self.key == StateMeta.NO_STATE
+
+        if self.key != StateMeta.ANY and self.key != state.unwrap().key:
+            return False
+
+        ctx["state"] = state.unwrap()
+        return True
+
+
+__all__ = ("State", "StateMeta")

telegrinder/bot/rules/text.py

@@ -1,33 +1,38 @@
-import typing
-
-from telegrinder import node
-from telegrinder.tools.i18n.abc import ABCTranslator
-
-from .abc import ABCRule, with_caching_translations
-from .node import NodeRule
-
-
-class HasText(NodeRule):
-    def __init__(self) -> None:
-        super().__init__(node.text.Text)
-
-
-class Text(ABCRule):
-    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))
-        self.ignore_case = ignore_case
-
-    def check(self, text: node.text.Text) -> bool:
-        return (text if not self.ignore_case else text.lower()) in self.texts
-
-    @with_caching_translations
-    async def translate(self, translator: ABCTranslator) -> typing.Self:
-        return self.__class__(
-            texts=[translator.get(text) for text in self.texts],
-            ignore_case=self.ignore_case,
-        )
-
-
-__all__ = ("HasText", "Text")
+import typing
+
+from telegrinder import node
+from telegrinder.tools.i18n.abc import ABCTranslator
+
+from .abc import ABCRule, with_caching_translations
+from .node import NodeRule
+
+
+class HasText(NodeRule):
+    def __init__(self) -> None:
+        super().__init__(node.as_node(node.text.Text))
+
+
+class HasCaption(NodeRule):
+    def __init__(self) -> None:
+        super().__init__(node.as_node(node.text.Caption))
+
+
+class Text(ABCRule):
+    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))
+        self.ignore_case = ignore_case
+
+    def check(self, text: node.either.Either[node.text.Text, node.text.Caption]) -> bool:
+        return (text if not self.ignore_case else text.lower()) in self.texts
+
+    @with_caching_translations
+    async def translate(self, translator: ABCTranslator) -> typing.Self:
+        return self.__class__(
+            [translator.get(text) for text in self.texts],
+            ignore_case=self.ignore_case,
+        )
+
+
+__all__ = ("HasCaption", "HasText", "Text")

telegrinder/bot/rules/update.py

@@ -1,15 +1,15 @@
-from telegrinder.bot.cute_types.update import UpdateCute
-from telegrinder.types.enums import UpdateType
-
-from .abc import ABCRule
-
-
-class IsUpdateType(ABCRule):
-    def __init__(self, update_type: UpdateType, /) -> None:
-        self.update_type = update_type
-
-    def check(self, event: UpdateCute) -> bool:
-        return event.update_type == self.update_type
-
-
-__all__ = ("IsUpdateType",)
+from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.types.enums import UpdateType
+
+from .abc import ABCRule
+
+
+class IsUpdateType(ABCRule):
+    def __init__(self, update_type: UpdateType, /) -> None:
+        self.update_type = update_type
+
+    def check(self, event: UpdateCute) -> bool:
+        return event.update_type == self.update_type
+
+
+__all__ = ("IsUpdateType",)

telegrinder/bot/scenario/__init__.py

@@ -1,5 +1,5 @@
-from .abc import ABCScenario
-from .checkbox import Checkbox
-from .choice import Choice
-
-__all__ = ("ABCScenario", "Checkbox", "Choice")
+from .abc import ABCScenario
+from .checkbox import Checkbox
+from .choice import Choice
+
+__all__ = ("ABCScenario", "Checkbox", "Choice")

telegrinder/bot/scenario/abc.py

@@ -1,19 +1,17 @@
-import typing
-from abc import ABC, abstractmethod
-
-from telegrinder.bot.cute_types.base import BaseCute
-
-if typing.TYPE_CHECKING:
-    from telegrinder.api import API
-    from telegrinder.bot.dispatch.view.abc import ABCStateView
-
-EventT = typing.TypeVar("EventT", bound=BaseCute)
-
-
-class ABCScenario(ABC, typing.Generic[EventT]):
-    @abstractmethod
-    def wait(self, api: "API", view: "ABCStateView[EventT]") -> typing.Any:
-        pass
-
-
-__all__ = ("ABCScenario",)
+import typing
+from abc import ABC, abstractmethod
+
+from telegrinder.bot.cute_types.base import BaseCute
+
+if typing.TYPE_CHECKING:
+    from telegrinder.api import API
+    from telegrinder.bot.dispatch.view.abc import ABCStateView
+
+
+class ABCScenario[Event: BaseCute](ABC):
+    @abstractmethod
+    def wait(self, api: "API", view: "ABCStateView[Event]") -> typing.Any:
+        pass
+
+
+__all__ = ("ABCScenario",)