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

telegrinder/tools/magic.py

@@ -1,158 +1,158 @@
-import enum
-import types
-import typing
-from functools import wraps
-
-if typing.TYPE_CHECKING:
-    from telegrinder.bot.rules.abc import ABCRule
-    from telegrinder.node.polymorphic import Polymorphic
-
-    T = typing.TypeVar("T", bound=ABCRule)
-    F = typing.TypeVar(
-        "F",
-        bound=typing.Callable[typing.Concatenate[typing.Callable[..., typing.Any], ...], typing.Any],
-    )
-
-Impl: typing.TypeAlias = type[classmethod]
-FuncType: typing.TypeAlias = types.FunctionType | typing.Callable[..., typing.Any]
-
-TRANSLATIONS_KEY: typing.Final[str] = "_translations"
-IMPL_MARK: typing.Final[str] = "_is_impl"
-
-
-def cache_magic_value(mark_key: str, /):
-    def inner(func: "F") -> "F":
-        @wraps(func)
-        def wrapper(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:
-            if mark_key not in args[0].__dict__:
-                args[0].__dict__[mark_key] = func(*args, **kwargs)
-            return args[0].__dict__[mark_key]
-
-        return wrapper  # type: ignore
-
-    return inner
-
-
-def resolve_arg_names(func: FuncType, start_idx: int = 1) -> tuple[str, ...]:
-    return func.__code__.co_varnames[start_idx : func.__code__.co_argcount]
-
-
-@cache_magic_value("__default_args__")
-def get_default_args(func: FuncType) -> dict[str, typing.Any]:
-    kwdefaults = func.__kwdefaults__
-    if kwdefaults:
-        return kwdefaults
-
-    defaults = func.__defaults__
-    if not defaults:
-        return {}
-
-    return {k: defaults[i] for i, k in enumerate(resolve_arg_names(func, start_idx=0)[-len(defaults) :])}
-
-
-def get_annotations(func: FuncType, *, return_type: bool = False) -> dict[str, typing.Any]:
-    annotations = func.__annotations__
-    if not return_type and "return" in func.__annotations__:
-        annotations.pop("return")
-    return annotations
-
-
-def to_str(s: str | enum.Enum) -> str:
-    if isinstance(s, enum.Enum):
-        return str(s.value)
-    return s
-
-
-@typing.overload
-def magic_bundle(handler: FuncType, kw: dict[str, typing.Any]) -> dict[str, typing.Any]: ...
-
-
-@typing.overload
-def magic_bundle(handler: FuncType, kw: dict[enum.Enum, typing.Any]) -> dict[str, typing.Any]: ...
-
-
-@typing.overload
-def magic_bundle(
-    handler: FuncType,
-    kw: dict[str, typing.Any],
-    *,
-    start_idx: int = 1,
-    bundle_ctx: bool = True,
-) -> dict[str, typing.Any]: ...
-
-
-@typing.overload
-def magic_bundle(
-    handler: FuncType,
-    kw: dict[enum.Enum, typing.Any],
-    *,
-    start_idx: int = 1,
-    bundle_ctx: bool = True,
-) -> dict[str, typing.Any]: ...
-
-
-@typing.overload
-def magic_bundle(
-    handler: FuncType,
-    kw: dict[type, typing.Any],
-    *,
-    typebundle: typing.Literal[True] = True,
-) -> dict[str, typing.Any]: ...
-
-
-def magic_bundle(
-    handler: FuncType,
-    kw: dict[typing.Any, typing.Any],
-    *,
-    start_idx: int = 1,
-    bundle_ctx: bool = True,
-    typebundle: bool = False,
-) -> dict[str, typing.Any]:
-    if typebundle:
-        types = get_annotations(handler, return_type=False)
-        bundle: dict[str, typing.Any] = {}
-        for name, type in types.items():
-            bundle[name] = kw[type]
-        return bundle
-
-    names = resolve_arg_names(handler, start_idx=start_idx)
-    args = get_default_args(handler)
-    args.update({to_str(k): v for k, v in kw.items() if to_str(k) in names})
-    if "ctx" in names and bundle_ctx:
-        args["ctx"] = kw
-    return args
-
-
-def get_cached_translation(rule: "T", locale: str) -> "T | None":
-    return getattr(rule, TRANSLATIONS_KEY, {}).get(locale)
-
-
-def cache_translation(base_rule: "T", locale: str, translated_rule: "T") -> None:
-    translations = getattr(base_rule, TRANSLATIONS_KEY, {})
-    translations[locale] = translated_rule
-    setattr(base_rule, TRANSLATIONS_KEY, translations)
-
-
-@typing.cast(typing.Callable[..., Impl], lambda f: f)
-def impl(method: typing.Callable[..., typing.Any]):
-    setattr(method, IMPL_MARK, True)
-    return classmethod(method)
-
-
-def get_impls(cls: type["Polymorphic"]) -> list[typing.Callable[..., typing.Any]]:
-    moprh_impls = getattr(cls, "__morph_impls__", None)
-    if moprh_impls is not None:
-        return moprh_impls
-    impls = [
-        func.__func__
-        for func in vars(cls).values()
-        if isinstance(func, classmethod) and getattr(func.__func__, IMPL_MARK, False)
-    ]
-    setattr(cls, "__morph_impls__", impls)
-    return impls
-
-
-__all__ = (
+import enum
+import types
+import typing
+from functools import wraps
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.rules.abc import ABCRule
+    from telegrinder.node.polymorphic import Polymorphic
+
+    T = typing.TypeVar("T", bound=ABCRule)
+    F = typing.TypeVar(
+        "F",
+        bound=typing.Callable[typing.Concatenate[typing.Callable[..., typing.Any], ...], typing.Any],
+    )
+
+Impl: typing.TypeAlias = type[classmethod]
+FuncType: typing.TypeAlias = types.FunctionType | typing.Callable[..., typing.Any]
+
+TRANSLATIONS_KEY: typing.Final[str] = "_translations"
+IMPL_MARK: typing.Final[str] = "_is_impl"
+
+
+def cache_magic_value(mark_key: str, /):
+    def inner(func: "F") -> "F":
+        @wraps(func)
+        def wrapper(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+            if mark_key not in args[0].__dict__:
+                args[0].__dict__[mark_key] = func(*args, **kwargs)
+            return args[0].__dict__[mark_key]
+
+        return wrapper  # type: ignore
+
+    return inner
+
+
+def resolve_arg_names(func: FuncType, start_idx: int = 1) -> tuple[str, ...]:
+    return func.__code__.co_varnames[start_idx : func.__code__.co_argcount]
+
+
+@cache_magic_value("__default_args__")
+def get_default_args(func: FuncType) -> dict[str, typing.Any]:
+    kwdefaults = func.__kwdefaults__
+    if kwdefaults:
+        return kwdefaults
+
+    defaults = func.__defaults__
+    if not defaults:
+        return {}
+
+    return {k: defaults[i] for i, k in enumerate(resolve_arg_names(func, start_idx=0)[-len(defaults) :])}
+
+
+def get_annotations(func: FuncType, *, return_type: bool = False) -> dict[str, typing.Any]:
+    annotations = func.__annotations__
+    if not return_type and "return" in func.__annotations__:
+        annotations.pop("return")
+    return annotations
+
+
+def to_str(s: str | enum.Enum) -> str:
+    if isinstance(s, enum.Enum):
+        return str(s.value)
+    return s
+
+
+@typing.overload
+def magic_bundle(handler: FuncType, kw: dict[str, typing.Any]) -> dict[str, typing.Any]: ...
+
+
+@typing.overload
+def magic_bundle(handler: FuncType, kw: dict[enum.Enum, typing.Any]) -> dict[str, typing.Any]: ...
+
+
+@typing.overload
+def magic_bundle(
+    handler: FuncType,
+    kw: dict[str, typing.Any],
+    *,
+    start_idx: int = 1,
+    bundle_ctx: bool = True,
+) -> dict[str, typing.Any]: ...
+
+
+@typing.overload
+def magic_bundle(
+    handler: FuncType,
+    kw: dict[enum.Enum, typing.Any],
+    *,
+    start_idx: int = 1,
+    bundle_ctx: bool = True,
+) -> dict[str, typing.Any]: ...
+
+
+@typing.overload
+def magic_bundle(
+    handler: FuncType,
+    kw: dict[type, typing.Any],
+    *,
+    typebundle: typing.Literal[True] = True,
+) -> dict[str, typing.Any]: ...
+
+
+def magic_bundle(
+    handler: FuncType,
+    kw: dict[typing.Any, typing.Any],
+    *,
+    start_idx: int = 1,
+    bundle_ctx: bool = True,
+    typebundle: bool = False,
+) -> dict[str, typing.Any]:
+    if typebundle:
+        types = get_annotations(handler, return_type=False)
+        bundle: dict[str, typing.Any] = {}
+        for name, type in types.items():
+            bundle[name] = kw[type]
+        return bundle
+
+    names = resolve_arg_names(handler, start_idx=start_idx)
+    args = get_default_args(handler)
+    args.update({to_str(k): v for k, v in kw.items() if to_str(k) in names})
+    if "ctx" in names and bundle_ctx:
+        args["ctx"] = kw
+    return args
+
+
+def get_cached_translation(rule: "T", locale: str) -> "T | None":
+    return getattr(rule, TRANSLATIONS_KEY, {}).get(locale)
+
+
+def cache_translation(base_rule: "T", locale: str, translated_rule: "T") -> None:
+    translations = getattr(base_rule, TRANSLATIONS_KEY, {})
+    translations[locale] = translated_rule
+    setattr(base_rule, TRANSLATIONS_KEY, translations)
+
+
+@typing.cast(typing.Callable[..., Impl], lambda f: f)
+def impl(method: typing.Callable[..., typing.Any]):
+    setattr(method, IMPL_MARK, True)
+    return classmethod(method)
+
+
+def get_impls(cls: type["Polymorphic"]) -> list[typing.Callable[..., typing.Any]]:
+    moprh_impls = getattr(cls, "__morph_impls__", None)
+    if moprh_impls is not None:
+        return moprh_impls
+    impls = [
+        func.__func__
+        for func in vars(cls).values()
+        if isinstance(func, classmethod) and getattr(func.__func__, IMPL_MARK, False)
+    ]
+    setattr(cls, "__morph_impls__", impls)
+    return impls
+
+
+__all__ = (
     "TRANSLATIONS_KEY",
     "cache_magic_value",
     "cache_translation",
@@ -164,5 +164,5 @@ __all__ = (
     "impl",
     "magic_bundle",
     "resolve_arg_names",
-    "to_str",
-)
+    "to_str",
+)

telegrinder/tools/parse_mode.py

@@ -1,6 +1,6 @@
-class ParseMode:
-    MARKDOWNV2 = "MarkdownV2"
-    HTML = "HTML"
-
-
-__all__ = ("ParseMode",)
+class ParseMode:
+    MARKDOWNV2 = "MarkdownV2"
+    HTML = "HTML"
+
+
+__all__ = ("ParseMode",)

telegrinder/tools/state_storage/__init__.py

@@ -1,4 +1,4 @@
-from telegrinder.tools.state_storage.abc import ABCStateStorage, StateData
-from telegrinder.tools.state_storage.memory import MemoryStateStorage
-
-__all__ = ("ABCStateStorage", "MemoryStateStorage", "StateData")
+from telegrinder.tools.state_storage.abc import ABCStateStorage, StateData
+from telegrinder.tools.state_storage.memory import MemoryStateStorage
+
+__all__ = ("ABCStateStorage", "MemoryStateStorage", "StateData")

telegrinder/tools/state_storage/abc.py

@@ -1,35 +1,35 @@
-import abc
-import enum
-import typing
-from dataclasses import dataclass
-
-from fntypes import Option
-
-from telegrinder.bot.rules.state import State, StateMeta
-
-Payload = typing.TypeVar("Payload")
-
-
-@dataclass(frozen=True, slots=True)
-class StateData(typing.Generic[Payload]):
-    key: str | enum.Enum
-    payload: Payload
-
-
-class ABCStateStorage(abc.ABC, typing.Generic[Payload]):
-    @abc.abstractmethod
-    async def get(self, user_id: int) -> Option[StateData[Payload]]: ...
-
-    @abc.abstractmethod
-    async def delete(self, user_id: int) -> None: ...
-
-    @abc.abstractmethod
-    async def set(self, user_id: int, key: str | enum.Enum, payload: Payload) -> None: ...
-
-    def State(self, key: str | StateMeta | enum.Enum = StateMeta.ANY, /) -> State[Payload]:  # noqa: N802
-        """Can be used as a shortcut to get a state rule dependant on current storage."""
-
-        return State(storage=self, key=key)
-
-
-__all__ = ("ABCStateStorage", "StateData")
+import abc
+import enum
+import typing
+from dataclasses import dataclass
+
+from fntypes import Option
+
+from telegrinder.bot.rules.state import State, StateMeta
+
+Payload = typing.TypeVar("Payload")
+
+
+@dataclass(frozen=True, slots=True)
+class StateData(typing.Generic[Payload]):
+    key: str | enum.Enum
+    payload: Payload
+
+
+class ABCStateStorage(abc.ABC, typing.Generic[Payload]):
+    @abc.abstractmethod
+    async def get(self, user_id: int) -> Option[StateData[Payload]]: ...
+
+    @abc.abstractmethod
+    async def delete(self, user_id: int) -> None: ...
+
+    @abc.abstractmethod
+    async def set(self, user_id: int, key: str | enum.Enum, payload: Payload) -> None: ...
+
+    def State(self, key: str | StateMeta | enum.Enum = StateMeta.ANY, /) -> State[Payload]:  # noqa: N802
+        """Can be used as a shortcut to get a state rule dependant on current storage."""
+
+        return State(storage=self, key=key)
+
+
+__all__ = ("ABCStateStorage", "StateData")

telegrinder/tools/state_storage/memory.py

@@ -1,25 +1,25 @@
-import typing
-
-from fntypes.option import Option
-
-from telegrinder.tools.functional import from_optional
-from telegrinder.tools.state_storage.abc import ABCStateStorage, StateData
-
-Payload: typing.TypeAlias = dict[str, typing.Any]
-
-
-class MemoryStateStorage(ABCStateStorage[Payload]):
-    def __init__(self) -> None:
-        self.storage: dict[int, StateData[Payload]] = {}
-
-    async def get(self, user_id: int) -> Option[StateData[Payload]]:
-        return from_optional(self.storage.get(user_id))
-
-    async def set(self, user_id: int, key: str, payload: Payload) -> None:
-        self.storage[user_id] = StateData(key, payload)
-
-    async def delete(self, user_id: int) -> None:
-        self.storage.pop(user_id)
-
-
-__all__ = ("MemoryStateStorage",)
+import typing
+
+from fntypes.option import Option
+
+from telegrinder.tools.functional import from_optional
+from telegrinder.tools.state_storage.abc import ABCStateStorage, StateData
+
+Payload: typing.TypeAlias = dict[str, typing.Any]
+
+
+class MemoryStateStorage(ABCStateStorage[Payload]):
+    def __init__(self) -> None:
+        self.storage: dict[int, StateData[Payload]] = {}
+
+    async def get(self, user_id: int) -> Option[StateData[Payload]]:
+        return from_optional(self.storage.get(user_id))
+
+    async def set(self, user_id: int, key: str, payload: Payload) -> None:
+        self.storage[user_id] = StateData(key, payload)
+
+    async def delete(self, user_id: int) -> None:
+        self.storage.pop(user_id)
+
+
+__all__ = ("MemoryStateStorage",)