telegrinder 0.1.dev170__py3-none-any.whl → 0.2.0__py3-none-any.whl

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
 
@@ -12,7 +12,7 @@ class FuncRule(ABCRule, typing.Generic[AdaptTo]):
         self,
         func: typing.Callable[[AdaptTo, Context], typing.Awaitable[bool] | bool],
         adapter: ABCAdapter[Update, AdaptTo] | None = None,
-    ):
+    ) -> None:
         self.func = func
         self.adapter = adapter or RawUpdateAdapter()  # type: ignore
 

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/inline.py

@@ -21,7 +21,7 @@ class InlineQueryRule(ABCRule[InlineQuery], abc.ABC):
 
 
 class HasLocation(InlineQueryRule):
-    async def check(self, query: InlineQuery, ctx: Context) -> bool:
+    async def check(self, query: InlineQuery) -> bool:
         return bool(query.location)
 
 
@@ -29,7 +29,7 @@ class InlineQueryChatType(InlineQueryRule):
     def __init__(self, chat_type: ChatType, /) -> None:
         self.chat_type = chat_type
 
-    async def check(self, query: InlineQuery, ctx: Context) -> bool:
+    async def check(self, query: InlineQuery) -> bool:
         return query.chat_type.map(lambda x: x == self.chat_type).unwrap_or(False)
 
 
@@ -40,7 +40,7 @@ class InlineQueryText(InlineQueryRule):
         ]
         self.lower_case = lower_case
 
-    async def check(self, query: InlineQuery, ctx: Context) -> bool:
+    async def check(self, query: InlineQuery) -> bool:
         return (query.query.lower() if self.lower_case else query.query) in self.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: typing.Final[TelegrinderContext] = TelegrinderContext()
 
 
 def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
@@ -24,7 +24,9 @@ def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
 
 
 class Markup(ABCRule):
-    def __init__(self, patterns: PatternLike | list[PatternLike], /):
+    """Markup Language. See [VBML docs](https://github.com/tesseradecade/vbml/blob/master/docs/index.md)"""
+
+    def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
         if not isinstance(patterns, list):
             patterns = [patterns]
         self.patterns = [

telegrinder/bot/rules/message_entities.py

@@ -10,12 +10,12 @@ Entity: typing.TypeAlias = str | MessageEntityType
 
 
 class HasEntities(MessageRule):
-    async def check(self, message: Message, ctx: Context) -> bool:
+    async def check(self, message: Message) -> bool:
         return bool(message.entities)
 
 
 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/rules/text.py

@@ -1,5 +1,4 @@
 from telegrinder import node
-from telegrinder.bot.dispatch.context import Context
 from telegrinder.tools.i18n.base import ABCTranslator
 
 from .abc import ABCRule, with_caching_translations
@@ -18,7 +17,7 @@ class Text(ABCRule):
         self.texts = texts if not ignore_case else list(map(str.lower, texts))
         self.ignore_case = ignore_case
 
-    async def check(self, text: node.text.Text, ctx: Context) -> bool:
+    async def check(self, text: node.text.Text) -> bool:
         return (text if not self.ignore_case else text.lower()) in self.texts
 
     @with_caching_translations

telegrinder/bot/rules/update.py

@@ -1,5 +1,4 @@
 from telegrinder.bot.cute_types.update import UpdateCute
-from telegrinder.bot.dispatch.context import Context
 from telegrinder.types.enums import UpdateType
 
 from .abc import ABCRule
@@ -9,7 +8,7 @@ class IsUpdateType(ABCRule):
     def __init__(self, update_type: UpdateType, /) -> None:
         self.update_type = update_type
 
-    async def check(self, event: UpdateCute, ctx: Context) -> bool:
+    async def check(self, event: UpdateCute) -> bool:
         return event.update_type == self.update_type
 
 

telegrinder/bot/scenario/abc.py

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

telegrinder/bot/scenario/checkbox.py

@@ -4,18 +4,17 @@ import typing
 
 from telegrinder.bot.cute_types import CallbackQueryCute
 from telegrinder.bot.dispatch.waiter_machine import WaiterMachine
+from telegrinder.bot.scenario.abc import ABCScenario
 from telegrinder.tools import InlineButton, InlineKeyboard
 from telegrinder.tools.parse_mode import ParseMode
 from telegrinder.types.objects import InlineKeyboardMarkup
 
-from .abc import ABCScenario
-
 if typing.TYPE_CHECKING:
     from telegrinder.api import API
     from telegrinder.bot.dispatch.view.abc import BaseStateView
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class Choice:
     name: str
     is_picked: bool
@@ -114,7 +113,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/bot/scenario/choice.py

@@ -1,8 +1,7 @@
 import typing
 
 from telegrinder.bot.cute_types import CallbackQueryCute
-
-from .checkbox import Checkbox
+from telegrinder.bot.scenario.checkbox import Checkbox
 
 if typing.TYPE_CHECKING:
     from telegrinder.api import API

telegrinder/model.py

@@ -9,14 +9,13 @@ 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,
@@ -59,49 +58,85 @@ def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
     return validated_params
 
 
+def encode_name(name: str) -> str:
+    # TODO
+    return MODEL_CONFIG.get("rename", {}).get(name, name)
+
+
 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)))
@@ -111,9 +146,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
 
@@ -142,25 +193,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
 
@@ -193,11 +237,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