telegrinder 0.1.dev159__py3-none-any.whl → 0.1.dev161__py3-none-any.whl

telegrinder/bot/dispatch/handler/func.py

@@ -36,7 +36,7 @@ class FuncHandler(ABCHandler[EventT], typing.Generic[EventT, F, ErrorHandlerT]):
     
     @property
     def on_error(self):
-        return self.error_handler.catch
+        return self.error_handler.register_catcher
     
     async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
         ctx = ctx or Context()

telegrinder/bot/dispatch/view/abc.py

@@ -18,6 +18,11 @@ from telegrinder.types.objects import Update
 EventType = typing.TypeVar("EventType", bound=BaseCute)
 MiddlewareT = typing.TypeVar("MiddlewareT", bound=ABCMiddleware)
 
+FuncType: typing.TypeAlias = typing.Callable[
+    typing.Concatenate[EventType, ...],
+    typing.Coroutine[typing.Any, typing.Any, typing.Any],
+]
+
 
 class ABCView(ABC):
     @abstractmethod
@@ -41,7 +46,7 @@ class ABCStateView(ABCView, typing.Generic[EventType]):
     def __repr__(self) -> str:
         return "<{!r}: {}>".format(
             self.__class__.__name__,
-            ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items())
+            ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items()),
         )
 
 
@@ -56,10 +61,12 @@ class BaseView(ABCView, typing.Generic[EventType]):
         for base in cls.__dict__.get("__orig_bases__", ()):
             if issubclass(typing.get_origin(base) or base, ABCView):
                 for generic_type in typing.get_args(base):
-                    if issubclass(typing.get_origin(generic_type) or generic_type, BaseCute):
+                    if issubclass(
+                        typing.get_origin(generic_type) or generic_type, BaseCute
+                    ):
                         return Some(generic_type)
         return Nothing()
-    
+
     @classmethod
     def get_raw_event(cls, update: Update) -> Option[Model]:
         match update.update_type:
@@ -74,13 +81,8 @@ class BaseView(ABCView, typing.Generic[EventType]):
         is_blocking: bool = True,
         error_handler: ErrorHandlerT | None = None,
     ):
-        def wrapper(
-            func: typing.Callable[
-                typing.Concatenate[EventType, ...],
-                typing.Coroutine,
-            ]
-        ):
-            func_handler = FuncHandler(
+        def wrapper(func: FuncType[EventType]):
+            func_handler = FuncHandler[EventType, FuncType[EventType], ErrorHandlerT](
                 func,
                 [*self.auto_rules, *rules],
                 is_blocking,
@@ -91,14 +93,14 @@ class BaseView(ABCView, typing.Generic[EventType]):
             return func_handler
 
         return wrapper
-    
+
     def register_middleware(self, *args: typing.Any, **kwargs: typing.Any):
-        def wrapper(cls: type[MiddlewareT]):
+        def wrapper(cls: type[MiddlewareT]) -> type[MiddlewareT]:
             self.middlewares.append(cls(*args, **kwargs))
             return cls
-        
+
         return wrapper
-    
+
     async def check(self, event: Update) -> bool:
         match self.get_raw_event(event):
             case Some(e) if issubclass(
@@ -110,10 +112,12 @@ class BaseView(ABCView, typing.Generic[EventType]):
                 return True
             case _:
                 return False
-        
+
     async def process(self, event: Update, api: ABCAPI) -> bool:
         return await process_inner(
-            self.get_event_type().unwrap().from_update(
+            self.get_event_type()
+            .unwrap()
+            .from_update(
                 update=self.get_raw_event(event).unwrap(),
                 bound_api=api,
             ),

telegrinder/bot/polling/polling.py

@@ -71,16 +71,14 @@ class Polling(ABCPolling):
     async def listen(self) -> typing.AsyncGenerator[list[Update], None]:
         logger.debug("Listening polling")
         reconn_counter = 0
-        
+
         while not self._stop:
             try:
                 updates = await self.get_updates()
                 reconn_counter = 0
                 if not updates:
                     continue
-                updates_list: list[Update] = decoder.decode(
-                    updates, type=list[Update]
-                )
+                updates_list: list[Update] = decoder.decode(updates, type=list[Update])
                 if updates_list:
                     yield updates_list
                     self.offset = updates_list[-1].update_id + 1
@@ -100,16 +98,14 @@ class Polling(ABCPolling):
                     self.stop()
                     exit(9)
                 else:
-                    logger.warning("Server disconnected, waiting 5 seconds to reconnetion...")
+                    logger.warning(
+                        "Server disconnected, waiting 5 seconds to reconnetion...",
+                    )
                     reconn_counter += 1
                     await asyncio.sleep(self.reconnection_timeout)
             except aiohttp.ClientConnectorError:
-                logger.error(
-                    "Client connection failed, polling stopping! "
-                    "Please, check your internet connection."
-                )
-                self.stop()
-                exit(3)
+                logger.error("Client connection failed, attempted to reconnect...")
+                await asyncio.sleep(self.reconnection_timeout)
             except BaseException as e:
                 logger.exception(e)
 

telegrinder/bot/rules/abc.py

@@ -19,7 +19,7 @@ Update: typing.TypeAlias = UpdateCute
 def with_caching_translations(func):
     """Should be used as decorator for .translate method. Caches rule translations."""
 
-    async def wrapper(self: "ABCRule", translator: ABCTranslator):
+    async def wrapper(self: "ABCRule[typing.Any]", translator: ABCTranslator):
         if translation := get_cached_translation(self, translator.locale):
             return translation
         translation = await func(self, translator)

telegrinder/bot/rules/callback_data.py

@@ -14,18 +14,10 @@ from telegrinder.tools.buttons import DataclassInstance
 from .abc import ABCRule
 from .markup import Markup, PatternLike, check_string
 
-if typing.TYPE_CHECKING:
+T = typing.TypeVar("T")
 
-    T = typing.TypeVar("T")
-    Ref: typing.TypeAlias = typing.Annotated[T, ...]
-else:
-
-    class Ref:
-        def __class_getitem__(cls, code: str) -> typing.ForwardRef:
-            return typing.ForwardRef(code)
-
-
-CallbackQuery = CallbackQueryCute
+Ref: typing.TypeAlias = typing.Annotated[T, ...]
+CallbackQuery: typing.TypeAlias = CallbackQueryCute
 Validator: typing.TypeAlias = typing.Callable[[typing.Any], bool | typing.Awaitable[bool]]
 MapDict: typing.TypeAlias = dict[
     str, typing.Any | type[typing.Any] | Validator | list[Ref["MapDict"]] | Ref["MapDict"]

telegrinder/bot/rules/inline.py

@@ -1,4 +1,5 @@
 import abc
+import typing
 
 from telegrinder.bot.cute_types import InlineQueryCute
 from telegrinder.bot.dispatch.context import Context
@@ -8,7 +9,7 @@ from telegrinder.types.enums import ChatType
 
 from .markup import Markup, PatternLike, check_string
 
-InlineQuery = InlineQueryCute
+InlineQuery: typing.TypeAlias = InlineQueryCute
 
 
 class InlineQueryRule(ABCRule[InlineQuery], abc.ABC):

telegrinder/bot/rules/markup.py

@@ -1,3 +1,5 @@
+import typing
+
 import vbml
 
 from telegrinder.bot.dispatch.context import Context
@@ -6,7 +8,7 @@ from telegrinder.tools.global_context import TelegrinderCtx
 from .abc import Message
 from .text import TextMessageRule
 
-PatternLike = str | vbml.Pattern
+PatternLike: typing.TypeAlias = str | vbml.Pattern
 global_ctx = TelegrinderCtx()
 
 

telegrinder/bot/rules/message_entities.py

@@ -1,10 +1,12 @@
+import typing
+
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.types.enums import MessageEntityType
 from telegrinder.types.objects import MessageEntity
 
 from .abc import Message, MessageRule
 
-Entity = str | MessageEntityType
+Entity: typing.TypeAlias = str | MessageEntityType
 
 
 class HasEntities(MessageRule):

telegrinder/bot/rules/regex.py

@@ -6,7 +6,7 @@ from telegrinder.bot.dispatch.context import Context
 from .abc import Message
 from .text import TextMessageRule
 
-PatternLike = str | typing.Pattern[str]
+PatternLike: typing.TypeAlias = str | typing.Pattern[str]
 
 
 class Regex(TextMessageRule):

telegrinder/bot/scenario/__init__.py

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

telegrinder/bot/scenario/checkbox.py

@@ -1,6 +1,5 @@
 import dataclasses
-import random
-import string
+import secrets
 import typing
 
 from telegrinder.bot.cute_types import CallbackQueryCute
@@ -25,29 +24,26 @@ class Choice:
     code: str
 
 
-def random_code(length: int) -> str:
-    return "".join(random.choices(string.ascii_letters + string.digits, k=length))
-
-
 class Checkbox(ABCScenario[CallbackQueryCute]):
-    INVALID_CODE: typing.ClassVar[str] = "Invalid code"
-    CALLBACK_ANSWER: typing.ClassVar[str] = "Done"
-    PARSE_MODE: typing.ClassVar[str] = ParseMode.MARKDOWNV2
+    INVALID_CODE = "Invalid code"
+    CALLBACK_ANSWER = "Done"
+    PARSE_MODE = ParseMode.HTML
 
     def __init__(
         self,
         waiter_machine: WaiterMachine,
         chat_id: int,
         msg: str,
+        *,
         ready_text: str = "Ready",
         max_in_row: int = 3,
-    ):
+    ) -> None:
         self.chat_id = chat_id
         self.msg = msg
         self.choices: list[Choice] = []
         self.ready = ready_text
         self.max_in_row = max_in_row
-        self.random_code = random_code(16)
+        self.random_code = secrets.token_hex(16)
         self.waiter_machine = waiter_machine
 
     def get_markup(self) -> InlineKeyboardMarkup:
@@ -77,7 +73,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         is_picked: bool = False,
     ) -> typing.Self:
         self.choices.append(
-            Choice(name, is_picked, default_text, picked_text, random_code(16)),
+            Choice(name, is_picked, default_text, picked_text, secrets.token_hex(16)),
         )
         return self
 
@@ -128,4 +124,4 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         )
 
 
-__all__ = ("Checkbox", "Choice", "random_code")
+__all__ = ("Checkbox", "Choice")

telegrinder/bot/scenario/choice.py

@@ -34,11 +34,11 @@ class SingleChoice(Checkbox):
     async def wait(
         self,
         api: "API",
-        cb_view: "BaseStateView[CallbackQueryCute]",
+        view: "BaseStateView[CallbackQueryCute]",
     ) -> tuple[str, int]:
         if len([choice for choice in self.choices if choice.is_picked]) != 1:
             raise ValueError("Exactly one choice must be picked")
-        choices, m_id = await super().wait(api, cb_view)
+        choices, m_id = await super().wait(api, view)
         return list(choices.keys())[list(choices.values()).index(True)], m_id
 
 

telegrinder/model.py

@@ -47,7 +47,7 @@ def full_result(
 
 def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
     return {
-        k: v.unwrap() if v and isinstance(v, Some) else v
+        k: v.unwrap() if isinstance(v, Some) else v
         for k, v in (
             *params.pop("other", {}).items(),
             *params.items(),
@@ -77,63 +77,62 @@ class DataConverter:
     files: dict[str, tuple[str, bytes]] = dataclasses.field(default_factory=lambda: {})
 
     @property
-    def converters(self) -> dict[
-        type[typing.Any], typing.Callable[[typing.Self, typing.Any, bool], typing.Any]
-    ]:
+    def converters(self) -> dict[type[typing.Any], typing.Callable[..., typing.Any]]:
         return {
-            get_origin(value.__annotations__["d"]): value
+            get_origin(value.__annotations__["data"]): value
             for key, value in vars(self.__class__).items()
-            if key.startswith("convert_")
-            and callable(value)
+            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 __call__(self, data: typing.Any, *, serialize: bool = True) -> typing.Any:
+        converter = self.get_converter(get_origin(type(data)))
+        if converter is not None:
+            if isinstance(converter, staticmethod):
+                return converter(data, serialize)
+            return converter(self, data, serialize)
+        return data
     
-    def get_converter(
-        self, t: type[typing.Any]
-    ) -> typing.Callable[[typing.Self, typing.Any, bool], typing.Any] | None:
+    def get_converter(self, t: type[typing.Any]):
         for type, converter in self.converters.items():
             if issubclass(t, type):
                 return converter
         return None
     
-    def convert_model(self, d: Model, serialize: bool = True) -> str | dict[str, typing.Any]:
-        converted_dct = self.convert(d.to_dict(), serialize=False)
+    def convert_model(self, data: Model, serialize: bool = True) -> str | dict[str, typing.Any]:
+        converted_dct = self(data.to_dict(), serialize=False)
         return encoder.encode(converted_dct) if serialize is True else converted_dct
     
-    def convert_dct(self, d: dict[str, typing.Any], serialize: bool = True) -> dict[str, typing.Any]:
+    def convert_dct(self, data: dict[str, typing.Any], serialize: bool = True) -> dict[str, typing.Any]:
         return {
-            k: self.convert(v, serialize=serialize)
-            for k, v in d.items()
+            k: self(v, serialize=serialize)
+            for k, v in data.items()
             if type(v) not in (NoneType, Nothing)
         }
     
-    def convert_lst(self, d: list[typing.Any], serialize: bool = True) -> str | list[typing.Any]:
-        converted_lst = [self.convert(x, serialize=False) for x in d]
+    def convert_lst(self, data: list[typing.Any], serialize: bool = True) -> str | list[typing.Any]:
+        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, d: tuple[typing.Any, ...], serialize: bool = True) -> str | tuple[typing.Any, ...]:
+    def convert_tpl(self, data: tuple[typing.Any, ...], _: bool = True) -> str | tuple[typing.Any, ...]:
         if (
-            isinstance(d, tuple)
-            and len(d) == 2
-            and isinstance(d[0], str)
-            and isinstance(d[1], bytes)
+            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] = d
+            self.files[attach_name] = data
             return "attach://{}".format(attach_name)
-        return d
-    
-    def convert_enum(self, d: enum.Enum, serialize: bool = True) -> str:
-        return d.value
-    
-    def convert_datetime(self, d: datetime, serialize: bool = True) -> int:
-        return int(d.timestamp())
-
-    def convert(self, data: typing.Any, *, serialize: bool = True) -> typing.Any:
-        converter = self.get_converter(get_origin(type(data)))
-        if converter is not None:
-            return converter(self, data, serialize)
         return data
-
+    
 
 __all__ = (
     "DataConverter",

telegrinder/modules.py

@@ -5,7 +5,7 @@ from choicelib import choice_in_order
 
 
 class JSONModule(typing.Protocol):
-    def loads(self, s: str) -> dict[str, typing.Any] | list[typing.Any]:
+    def loads(self, s: str | bytes) -> dict[str, typing.Any] | list[typing.Any]:
         ...
 
     def dumps(self, o: dict[str, typing.Any] | list[typing.Any]) -> str:
@@ -13,22 +13,22 @@ class JSONModule(typing.Protocol):
 
 
 class LoggerModule(typing.Protocol):
-    def debug(self, __msg: object, *args: object, **kwargs: object):
+    def debug(self, __msg: object, *args: object, **kwargs: object) -> None:
         ...
 
-    def info(self, __msg: object, *args: object, **kwargs: object):
+    def info(self, __msg: object, *args: object, **kwargs: object) -> None:
         ...
 
-    def warning(self, __msg: object, *args: object, **kwargs: object):
+    def warning(self, __msg: object, *args: object, **kwargs: object) -> None:
         ...
 
-    def error(self, __msg: object, *args: object, **kwargs: object):
+    def error(self, __msg: object, *args: object, **kwargs: object) -> None:
         ...
 
-    def critical(self, __msg: object, *args: object, **kwargs: object):
+    def critical(self, __msg: object, *args: object, **kwargs: object) -> None:
         ...
 
-    def exception(self, __msg: object, *args: object, **kwargs: object):
+    def exception(self, __msg: object, *args: object, **kwargs: object) -> None:
         ...
 
     def set_level(
@@ -187,7 +187,7 @@ elif logging_module == "logging":
 
 
     class LogMessage:
-        def __init__(self, fmt, args, kwargs):
+        def __init__(self, fmt: typing.Any, args: typing.Any, kwargs: typing.Any) -> None:
             self.fmt = fmt
             self.args = args
             self.kwargs = kwargs
@@ -195,17 +195,27 @@ elif logging_module == "logging":
         def __str__(self) -> str:
             return self.fmt.format(*self.args, **self.kwargs)
 
+
     class TelegrinderLoggingStyleAdapter(logging.LoggerAdapter):
-        def __init__(self, logger, extra=None):
+        def __init__(
+            self,
+            logger: LoggerModule,
+            extra: dict[str, typing.Any] | None = None,
+        ) -> None:
             super().__init__(logger, extra or {})
 
-        def log(self, level, msg, *args, **kwargs):
+        def log(self, level: int, msg: object, *args: object, **kwargs: object) -> None:
             if self.isEnabledFor(level):
                 kwargs.setdefault("stacklevel", 2)
                 msg, args, kwargs = self.proc(msg, args, kwargs)
                 self.logger._log(level, msg, args, **kwargs)
 
-        def proc(self, msg, args, kwargs):
+        def proc(
+            self,
+            msg: object,
+            args: tuple[object, ...],
+            kwargs: dict[str, object],
+        ) -> tuple[LogMessage | object, tuple[object, ...], dict[str, object]]:
             log_kwargs = {
                 key: kwargs[key]
                 for key in inspect.getfullargspec(self.logger._log).args[1:]

telegrinder/msgspec_utils.py

@@ -191,11 +191,11 @@ class Encoder:
         return self.enc_hooks[origin_type](obj)
     
     @typing.overload
-    def encode(self, obj: typing.Any) -> str:
+    def encode(self, obj: typing.Any, *, as_str: typing.Literal[True] = True) -> str:
         ...
 
     @typing.overload
-    def encode(self, obj: typing.Any, *, as_str: bool = False) -> bytes:
+    def encode(self, obj: typing.Any, *, as_str: typing.Literal[False] = False) -> bytes:
         ...
 
     def encode(self, obj: typing.Any, *, as_str: bool = True) -> str | bytes: