telegrinder 0.1.dev169__py3-none-any.whl → 0.1.dev171__py3-none-any.whl

telegrinder/bot/dispatch/view/raw.py

@@ -103,7 +103,10 @@ class RawEventView(BaseView[UpdateCute]):
         return False
 
     async def process(self, event: Update, api: ABCAPI) -> bool:
+        if not self.handlers or not self.middlewares:
+            return False
         return await process_inner(
+            api,
             UpdateCute.from_update(event, bound_api=api),
             event,
             self.middlewares,

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -123,7 +123,7 @@ class WaiterMachine:
 
         ctx = Context(**context)
         if await behaviour.check(event.api, update, ctx):
-            await behaviour.run(event, ctx)
+            await behaviour.run(event.api, event, ctx)
             return True
 
         return False
@@ -132,7 +132,7 @@ class WaiterMachine:
         self,
         views: typing.Iterable[ABCStateView[EventModel]],
         absolutely_dead_time: datetime.timedelta = WEEK,
-    ):
+    ) -> None:
         """Clears storage.
 
         :param absolutely_dead_time: timedelta when state can be forgotten.

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -83,7 +83,7 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         result = await handler.check(event.ctx_api, ctx.raw_update, ctx)
 
         if result is True:
-            await handler.run(event, ctx)
+            await handler.run(event.api, event, ctx)
 
         elif short_state.default_behaviour is not None:
             await self.machine.call_behaviour(

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -24,7 +24,7 @@ class ShortStateContext(typing.Generic[EventModel], typing.NamedTuple):
     context: Context
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class ShortState(typing.Generic[EventModel]):
     key: "Identificator"
     ctx_api: ABCAPI
@@ -38,6 +38,7 @@ class ShortState(typing.Generic[EventModel]):
     on_drop_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None, kw_only=True)
     exit_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None, kw_only=True)
     expiration_date: datetime.datetime | None = dataclasses.field(init=False, kw_only=True)
+    creation_date: datetime.datetime = dataclasses.field(init=False)
     context: ShortStateContext[EventModel] | None = dataclasses.field(default=None, init=False, kw_only=True)
 
     def __post_init__(self, expiration: datetime.timedelta | None = None) -> None:

telegrinder/bot/polling/polling.py

@@ -23,7 +23,7 @@ class Polling(ABCPolling):
         max_reconnetions: int = 10,
         include_updates: set[str | UpdateType] | None = None,
         exclude_updates: set[str | UpdateType] | None = None,
-    ):
+    ) -> None:
         self.api = api
         self.allowed_updates = self.get_allowed_updates(
             include_updates=include_updates,
@@ -48,8 +48,8 @@ class Polling(ABCPolling):
             self.reconnection_timeout,
         )
 
+    @staticmethod
     def get_allowed_updates(
-        self,
         *,
         include_updates: set[str | UpdateType] | None = None,
         exclude_updates: set[str | UpdateType] | None = None,
@@ -111,7 +111,7 @@ class Polling(ABCPolling):
                     exit(6)
                 else:
                     logger.warning(
-                        "Server disconnected, waiting 5 seconds to reconnet...",
+                        "Server disconnected, waiting 5 seconds to reconnect...",
                     )
                     reconn_counter += 1
                     await asyncio.sleep(self.reconnection_timeout)

telegrinder/bot/rules/abc.py

@@ -1,5 +1,6 @@
 import inspect
 from abc import ABC, abstractmethod
+from functools import cached_property
 
 import typing_extensions as typing
 
@@ -8,12 +9,14 @@ from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.process import check_rule
 from telegrinder.bot.rules.adapter import ABCAdapter, RawUpdateAdapter
 from telegrinder.bot.rules.adapter.node import Event
-from telegrinder.node.base import Node, is_node
-from telegrinder.node.composer import NodeCollection
+from telegrinder.node.base import Node, get_nodes, is_node
 from telegrinder.tools.i18n.base import ABCTranslator
 from telegrinder.tools.magic import cache_translation, get_annotations, get_cached_translation
 from telegrinder.types.objects import Update as UpdateObject
 
+if typing.TYPE_CHECKING:
+    from telegrinder.node.composer import NodeCollection
+
 AdaptTo = typing.TypeVar("AdaptTo", default=typing.Any)
 
 Message: typing.TypeAlias = MessageCute
@@ -41,14 +44,15 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
     async def check(self, event: AdaptTo, *, ctx: Context) -> bool:
         pass
 
-    def get_required_nodes(self) -> dict[str, type[Node]]:
-        return {k: v for k, v in get_annotations(self.check).items() if is_node(v)}
+    @cached_property
+    def required_nodes(self) -> dict[str, type[Node]]:
+        return get_nodes(self.check)
 
     async def bounding_check(
         self,
         adapted_value: AdaptTo,
         ctx: Context,
-        node_col: NodeCollection | None = None,
+        node_col: "NodeCollection | None" = None,
     ) -> bool:
         kw = {}
         node_col_values = node_col.values() if node_col is not None else {}
@@ -179,10 +183,10 @@ class Always(ABCRule):
 
 __all__ = (
     "ABCRule",
+    "Always",
     "AndRule",
+    "Never",
     "NotRule",
     "OrRule",
     "with_caching_translations",
-    "Never",
-    "Always",
 )

telegrinder/bot/rules/adapter/event.py

@@ -3,7 +3,7 @@ import typing
 from fntypes.result import Error, Ok, Result
 
 from telegrinder.api.abc import ABCAPI
-from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.rules.adapter.abc import ABCAdapter
 from telegrinder.bot.rules.adapter.errors import AdapterError
 from telegrinder.msgspec_utils import Nothing
@@ -43,16 +43,19 @@ class EventAdapter(ABCAdapter[Update, ToCute]):
                     AdapterError(f"Update is not of event type {self.event!r}."),
                 )
 
-            if update_dct[self.event.value] is Nothing:
+            if (event := getattr(update, self.event.value, Nothing)) is Nothing:
                 return Error(
                     AdapterError(f"Update is not an {self.event!r}."),
                 )
 
             return Ok(
-                self.cute_model.from_update(update_dct[self.event.value].unwrap(), bound_api=api),
+                self.cute_model.from_update(
+                    getattr(update, self.event.value).unwrap(),
+                    bound_api=api,
+                ),
             )
 
-        event = update_dct[update.update_type.value].unwrap()
+        event = getattr(update, update.update_type.value).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))

telegrinder/bot/rules/adapter/node.py

@@ -31,7 +31,7 @@ class NodeAdapter(typing.Generic[*Ts], ABCAdapter[Update, Event[tuple[*Ts]]]):
         for node_t in self.nodes:
             try:
                 # FIXME: adapters should have context
-                node_sessions.append(await compose_node(node_t, update_cute, Context()))  # type: ignore
+                node_sessions.append(await compose_node(node_t, update_cute, Context(raw_update=update)))  # type: ignore
             except ComposeError:
                 for session in node_sessions:
                     await session.close(with_value=None)

telegrinder/bot/rules/command.py

@@ -2,24 +2,22 @@ import dataclasses
 import typing
 
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.node import Source
 from telegrinder.node.command import CommandInfo, single_split
 from telegrinder.node.me import Me
+from telegrinder.node.source import Source
+from telegrinder.types.enums import ChatType
 
-from ...types import ChatType
 from .abc import ABCRule
 
-Validator = typing.Callable[[str], typing.Any | None]
+Validator: typing.TypeAlias = typing.Callable[[str], typing.Any | None]
 
 
-@dataclasses.dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True, slots=True)
 class Argument:
     name: str
     validators: list[Validator] = dataclasses.field(default_factory=lambda: [])
     optional: bool = dataclasses.field(default=False, kw_only=True)
 
-    # NOTE: add optional param `description`
-
     def check(self, data: str) -> typing.Any | None:
         for validator in self.validators:
             data = validator(data)  # type: ignore
@@ -79,7 +77,7 @@ class Command(ABCRule):
 
         return self.parse_arguments(arguments[1:], s)
 
-    def parse_arguments(self, arguments: list[Argument], s: str) -> dict | None:
+    def parse_arguments(self, arguments: list[Argument], s: str) -> dict[str, typing.Any] | None:
         if not arguments:
             return {} if not s else None
 

telegrinder/bot/rules/func.py

@@ -2,7 +2,7 @@ import inspect
 import typing
 
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.types import Update
+from telegrinder.types.objects import Update
 
 from .abc import ABCAdapter, ABCRule, AdaptTo, RawUpdateAdapter
 

telegrinder/bot/rules/fuzzy.py

@@ -7,7 +7,7 @@ from .abc import ABCRule
 
 
 class FuzzyText(ABCRule):
-    def __init__(self, texts: str | list[str], min_ratio: float = 0.7):
+    def __init__(self, texts: str | list[str], min_ratio: float = 0.7) -> None:
         if isinstance(texts, str):
             texts = [texts]
         self.texts = texts

telegrinder/bot/rules/integer.py

@@ -1,4 +1,3 @@
-from telegrinder.bot.dispatch.context import Context
 from telegrinder.node.text import TextInteger
 
 from .abc import ABCRule
@@ -11,7 +10,7 @@ class IsInteger(NodeRule):
 
 
 class IntegerInRange(ABCRule):
-    def __init__(self, rng: range):
+    def __init__(self, rng: range) -> None:
         self.rng = rng
 
     async def check(self, integer: TextInteger) -> bool:

telegrinder/bot/rules/markup.py

@@ -4,12 +4,12 @@ import vbml
 
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.node.text import Text
-from telegrinder.tools.global_context import TelegrinderCtx
+from telegrinder.tools.global_context.telegrinder_ctx import TelegrinderContext
 
 from .abc import ABCRule
 
 PatternLike: typing.TypeAlias = str | vbml.Pattern
-global_ctx = TelegrinderCtx()
+global_ctx = TelegrinderContext()
 
 
 def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
@@ -24,7 +24,7 @@ def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
 
 
 class Markup(ABCRule):
-    def __init__(self, patterns: PatternLike | list[PatternLike], /):
+    def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
         if not isinstance(patterns, list):
             patterns = [patterns]
         self.patterns = [

telegrinder/bot/rules/message_entities.py

@@ -15,7 +15,7 @@ class HasEntities(MessageRule):
 
 
 class MessageEntities(MessageRule, requires=[HasEntities()]):
-    def __init__(self, entities: Entity | list[Entity]):
+    def __init__(self, entities: Entity | list[Entity], /) -> None:
         self.entities = [entities] if not isinstance(entities, list) else entities
 
     async def check(self, message: Message, ctx: Context) -> bool:

telegrinder/bot/rules/node.py

@@ -1,7 +1,7 @@
 import typing
 
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.node import Node
+from telegrinder.node.base import Node
 
 from .abc import ABCRule
 from .adapter.node import NodeAdapter
@@ -15,7 +15,7 @@ class NodeRule(ABCRule[tuple[Node, ...]]):
 
     @property
     def adapter(self) -> NodeAdapter:
-        return NodeAdapter(*self.nodes)
+        return NodeAdapter(*self.nodes)  # type: ignore
 
     async def check(self, resolved_nodes: tuple[Node, ...], ctx: Context) -> typing.Literal[True]:
         for i, node in enumerate(resolved_nodes):

telegrinder/bot/rules/regex.py

@@ -10,7 +10,7 @@ PatternLike: typing.TypeAlias = str | typing.Pattern[str]
 
 
 class Regex(ABCRule):
-    def __init__(self, regexp: PatternLike | list[PatternLike]):
+    def __init__(self, regexp: PatternLike | list[PatternLike]) -> None:
         self.regexp: list[re.Pattern[str]] = []
         match regexp:
             case re.Pattern() as pattern:

telegrinder/bot/rules/rule_enum.py

@@ -7,7 +7,7 @@ from .abc import ABCRule, Update, check_rule
 from .func import FuncRule
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class RuleEnumState:
     name: str
     rule: ABCRule

telegrinder/bot/scenario/checkbox.py

@@ -15,7 +15,7 @@ if typing.TYPE_CHECKING:
     from telegrinder.bot.dispatch.view.abc import BaseStateView
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class Choice:
     name: str
     is_picked: bool
@@ -114,7 +114,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         api: "API",
         view: "BaseStateView[CallbackQueryCute]",
     ) -> tuple[dict[str, bool], int]:
-        assert len(self.choices) > 1
+        assert len(self.choices) > 0
         message = (
             await api.send_message(
                 chat_id=self.chat_id,

telegrinder/model.py

@@ -1,5 +1,6 @@
 import dataclasses
 import enum
+import keyword
 import secrets
 import typing
 from datetime import datetime
@@ -8,18 +9,17 @@ from types import NoneType
 import msgspec
 from fntypes.co import Nothing, Result, Some
 
-from .msgspec_utils import decoder, encoder, get_origin
+from telegrinder.msgspec_utils import decoder, encoder, get_origin
 
 if typing.TYPE_CHECKING:
     from telegrinder.api.error import APIError
 
 T = typing.TypeVar("T")
 
-
 MODEL_CONFIG: typing.Final[dict[str, typing.Any]] = {
     "omit_defaults": True,
     "dict": True,
-    "rename": {"from_": "from"},
+    "rename": {kw + "_": kw for kw in keyword.kwlist},
 }
 
 
@@ -59,48 +59,79 @@ def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
 
 
 class Model(msgspec.Struct, **MODEL_CONFIG):
+    @classmethod
+    def from_data(cls, data: dict[str, typing.Any]) -> typing.Self:
+        return decoder.convert(data, type=cls)
+
     @classmethod
     def from_bytes(cls, data: bytes) -> typing.Self:
         return decoder.decode(data, type=cls)
 
+    def _to_dict(
+        self,
+        dct_name: str,
+        exclude_fields: set[str],
+        full: bool,
+    ) -> dict[str, typing.Any]:
+        if dct_name not in self.__dict__:
+            self.__dict__[dct_name] = (
+                msgspec.structs.asdict(self)
+                if not full
+                else encoder.to_builtins(self.to_dict(exclude_fields=exclude_fields), order="deterministic")
+            )
+
+        if not exclude_fields:
+            return self.__dict__[dct_name]
+
+        return {key: value for key, value in self.__dict__[dct_name].items() if key not in exclude_fields}
+
     def to_dict(
         self,
         *,
         exclude_fields: set[str] | None = None,
     ) -> dict[str, typing.Any]:
-        exclude_fields = exclude_fields or set()
-        if "model_as_dict" not in self.__dict__:
-            self.__dict__["model_as_dict"] = msgspec.structs.asdict(self)
-        return {
-            key: value for key, value in self.__dict__["model_as_dict"].items() if key not in exclude_fields
-        }
+        """
+        :param exclude_fields: Model field names to exclude from the dictionary representation of this model.
+        :return: A dictionary representation of this model.
+        """
 
+        return self._to_dict("model_as_dict", exclude_fields or set(), full=False)
 
-@dataclasses.dataclass(kw_only=True)
+    def to_full_dict(
+        self,
+        *,
+        exclude_fields: set[str] | None = None,
+    ) -> dict[str, typing.Any]:
+        """
+        :param exclude_fields: Model field names to exclude from the dictionary representation of this model.
+        :return: A dictionary representation of this model including all models, structs, custom types.
+        """
+
+        return self._to_dict("model_as_full_dict", exclude_fields or set(), full=True)
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True, slots=True, repr=False)
 class DataConverter:
-    files: dict[str, tuple[str, bytes]] = dataclasses.field(default_factory=lambda: {})
+    _converters: dict[type[typing.Any], typing.Callable[..., typing.Any]] = dataclasses.field(
+        init=False,
+        default_factory=lambda: {},
+    )
+    _files: dict[str, tuple[str, bytes]] = dataclasses.field(default_factory=lambda: {})
 
     def __repr__(self) -> str:
         return "<{}: {}>".format(
             self.__class__.__name__,
-            ", ".join(f"{k}={v.__name__!r}" for k, v in self.converters.items()),
+            ", ".join(f"{k}={v.__name__!r}" for k, v in self._converters.items()),
         )
 
-    @property
-    def converters(self) -> dict[type[typing.Any], typing.Callable[..., typing.Any]]:
-        return {
-            get_origin(value.__annotations__["data"]): value
-            for key, value in vars(self.__class__).items()
-            if key.startswith("convert_") and callable(value)
-        }
-
-    @staticmethod
-    def convert_enum(data: enum.Enum, _: bool = True) -> typing.Any:
-        return data.value
-
-    @staticmethod
-    def convert_datetime(data: datetime, _: bool = True) -> int:
-        return int(data.timestamp())
+    def __post_init__(self) -> None:
+        self._converters.update(
+            {
+                get_origin(value.__annotations__["data"]): value
+                for key, value in vars(self.__class__).items()
+                if key.startswith("convert_") and callable(value)
+            }
+        )
 
     def __call__(self, data: typing.Any, *, serialize: bool = True) -> typing.Any:
         converter = self.get_converter(get_origin(type(data)))
@@ -110,9 +141,25 @@ class DataConverter:
             return converter(self, data, serialize)
         return data
 
+    @property
+    def converters(self) -> dict[type[typing.Any], typing.Callable[..., typing.Any]]:
+        return self._converters.copy()
+
+    @property
+    def files(self) -> dict[str, tuple[str, bytes]]:
+        return self._files.copy()
+
+    @staticmethod
+    def convert_enum(data: enum.Enum, _: bool = False) -> typing.Any:
+        return data.value
+
+    @staticmethod
+    def convert_datetime(data: datetime, _: bool = False) -> int:
+        return int(data.timestamp())
+
     def get_converter(self, t: type[typing.Any]):
-        for type, converter in self.converters.items():
-            if issubclass(t, type):
+        for type_, converter in self._converters.items():
+            if issubclass(t, type_):
                 return converter
         return None
 
@@ -121,7 +168,7 @@ class DataConverter:
         data: Model,
         serialize: bool = True,
     ) -> str | dict[str, typing.Any]:
-        converted_dct = self(data.to_dict(), serialize=False)
+        converted_dct = self(data.to_full_dict(), serialize=False)
         return encoder.encode(converted_dct) if serialize is True else converted_dct
 
     def convert_dct(
@@ -141,25 +188,18 @@ class DataConverter:
         converted_lst = [self(x, serialize=False) for x in data]
         return encoder.encode(converted_lst) if serialize is True else converted_lst
 
-    def convert_tpl(
-        self,
-        data: tuple[typing.Any, ...],
-        _: bool = True,
-    ) -> str | tuple[typing.Any, ...]:
-        if (
-            isinstance(data, tuple)
-            and len(data) == 2
-            and isinstance(data[0], str)
-            and isinstance(data[1], bytes)
-        ):
-            attach_name = secrets.token_urlsafe(16)
-            self.files[attach_name] = data
-            return "attach://{}".format(attach_name)
+    def convert_tpl(self, data: tuple[typing.Any, ...], _: bool = False) -> str | tuple[typing.Any, ...]:
+        match data:
+            case (str(filename), bytes(content)):
+                attach_name = secrets.token_urlsafe(16)
+                self._files[attach_name] = (filename, content)
+                return "attach://{}".format(attach_name)
+
         return data
 
 
 class Proxy:
-    def __init__(self, cfg: "_ProxiedDict", key: str):
+    def __init__(self, cfg: "_ProxiedDict", key: str) -> None:
         self.key = key
         self.cfg = cfg
 
@@ -192,11 +232,11 @@ else:
 
 
 __all__ = (
-    "Proxy",
     "DataConverter",
-    "ProxiedDict",
     "MODEL_CONFIG",
     "Model",
+    "ProxiedDict",
+    "Proxy",
     "full_result",
     "get_params",
 )

telegrinder/modules.py

@@ -108,8 +108,8 @@ elif logging_module == "logging":
             "level": "green",
             "level_module": "blue",
             "level_func": "cyan",
-            "level_lineno": "green",
-            "level_message": "white",
+            "level_lineno": "white",
+            "level_message": "green",
         },
         "DEBUG": {
             "level": "blue",
@@ -232,7 +232,7 @@ def _set_logger_level(level):
     if logging_module == "logging":
         import logging
 
-        logging.getLogger("telegrinder").setLevel(logging.getLevelName(level))
+        logging.getLogger("telegrinder").setLevel(level)
     elif logging_module == "loguru":
         import loguru  # type: ignore