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

telegrinder/bot/rules/rule_enum.py

@@ -1,72 +1,72 @@
-import dataclasses
-import typing
-
-from telegrinder.bot.dispatch.context import Context
-
-from .abc import ABCRule, Update, check_rule
-from .func import FuncRule
-
-
-@dataclasses.dataclass(slots=True)
-class RuleEnumState:
-    name: str
-    rule: ABCRule
-    cls: type["RuleEnum"]
-
-    def __eq__(self, other: typing.Self) -> bool:
-        return self.cls == other.cls and self.name == other.name
-
-
-class RuleEnum(ABCRule):
-    __enum__: list[RuleEnumState]
-
-    def __init_subclass__(cls, *args: typing.Any, **kwargs: typing.Any) -> None:
-        new_attributes = set(cls.__dict__) - set(RuleEnum.__dict__) - {"__enum__", "__init__"}
-        enum_lst: list[RuleEnumState] = []
-
-        self = cls.__new__(cls)
-        self.__init__()
-
-        for attribute_name in new_attributes:
-            rules = getattr(cls, attribute_name)
-            attribute = RuleEnumState(attribute_name, rules, cls)
-
-            setattr(
-                self,
-                attribute.name,
-                self & FuncRule(lambda _, ctx: self.must_be_state(ctx, attribute)),  # type: ignore
-            )
-            enum_lst.append(attribute)
-
-        setattr(cls, "__enum__", enum_lst)
-
-    @classmethod
-    def save_state(cls, ctx: Context, enum: RuleEnumState) -> None:
-        ctx.update({cls.__class__.__name__ + "_state": enum})
-
-    @classmethod
-    def check_state(cls, ctx: Context) -> RuleEnumState | None:
-        return ctx.get(cls.__class__.__name__ + "_state")
-
-    @classmethod
-    def must_be_state(cls, ctx: Context, state: RuleEnumState) -> bool:
-        real_state = cls.check_state(ctx)
-        if not real_state:
-            return False
-        return real_state == state
-
-    async def check(self, event: Update, ctx: Context) -> bool:
-        if self.check_state(ctx):
-            return True
-
-        for enum in self.__enum__:
-            ctx_copy = ctx.copy()
-            if await check_rule(event.ctx_api, enum.rule, event, ctx_copy):
-                ctx.update(ctx_copy)
-                self.save_state(ctx, enum)
-                return True
-
-        return False
-
-
-__all__ = ("RuleEnum", "RuleEnumState")
+import dataclasses
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+
+from .abc import ABCRule, Update, check_rule
+from .func import FuncRule
+
+
+@dataclasses.dataclass(slots=True)
+class RuleEnumState:
+    name: str
+    rule: ABCRule
+    cls: type["RuleEnum"]
+
+    def __eq__(self, other: typing.Self) -> bool:
+        return self.cls == other.cls and self.name == other.name
+
+
+class RuleEnum(ABCRule):
+    __enum__: list[RuleEnumState]
+
+    def __init_subclass__(cls, *args: typing.Any, **kwargs: typing.Any) -> None:
+        new_attributes = set(cls.__dict__) - set(RuleEnum.__dict__) - {"__enum__", "__init__"}
+        enum_lst: list[RuleEnumState] = []
+
+        self = cls.__new__(cls)
+        self.__init__()
+
+        for attribute_name in new_attributes:
+            rules = getattr(cls, attribute_name)
+            attribute = RuleEnumState(attribute_name, rules, cls)
+
+            setattr(
+                self,
+                attribute.name,
+                self & FuncRule(lambda _, ctx: self.must_be_state(ctx, attribute)),  # type: ignore
+            )
+            enum_lst.append(attribute)
+
+        setattr(cls, "__enum__", enum_lst)
+
+    @classmethod
+    def save_state(cls, ctx: Context, enum: RuleEnumState) -> None:
+        ctx.update({cls.__class__.__name__ + "_state": enum})
+
+    @classmethod
+    def check_state(cls, ctx: Context) -> RuleEnumState | None:
+        return ctx.get(cls.__class__.__name__ + "_state")
+
+    @classmethod
+    def must_be_state(cls, ctx: Context, state: RuleEnumState) -> bool:
+        real_state = cls.check_state(ctx)
+        if not real_state:
+            return False
+        return real_state == state
+
+    async def check(self, event: Update, ctx: Context) -> bool:
+        if self.check_state(ctx):
+            return True
+
+        for enum in self.__enum__:
+            ctx_copy = ctx.copy()
+            if await check_rule(event.ctx_api, enum.rule, event, ctx_copy):
+                ctx.update(ctx_copy)
+                self.save_state(ctx, enum)
+                return True
+
+        return False
+
+
+__all__ = ("RuleEnum", "RuleEnumState")

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,37 @@
-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
+
+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")

telegrinder/bot/rules/text.py

@@ -1,33 +1,33 @@
-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.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")

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,19 @@
-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
+
+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",)