telegrinder 0.3.0.post1__py3-none-any.whl → 0.3.0.post2__py3-none-any.whl

telegrinder/node/source.py

@@ -21,7 +21,7 @@ class Source(Polymorphic, DataNode):
     thread_id: Option[int] = dataclasses.field(default_factory=lambda: Nothing())
 
     @impl
-    async def compose_message(cls, message: MessageNode) -> typing.Self:
+    def compose_message(cls, message: MessageNode) -> typing.Self:
         return cls(
             api=message.ctx_api,
             chat=message.chat,
@@ -30,7 +30,7 @@ class Source(Polymorphic, DataNode):
         )
 
     @impl
-    async def compose_callback_query(cls, callback_query: CallbackQueryNode) -> typing.Self:
+    def compose_callback_query(cls, callback_query: CallbackQueryNode) -> typing.Self:
         return cls(
             api=callback_query.ctx_api,
             chat=callback_query.chat.expect(ComposeError("CallbackQueryNode has no chat")),
@@ -39,9 +39,7 @@ class Source(Polymorphic, DataNode):
         )
 
     @impl
-    async def compose_chat_join_request(
-        cls, chat_join_request: EventNode[ChatJoinRequestCute]
-    ) -> typing.Self:
+    def compose_chat_join_request(cls, chat_join_request: EventNode[ChatJoinRequestCute]) -> typing.Self:
         return cls(
             api=chat_join_request.ctx_api,
             chat=chat_join_request.chat,
@@ -60,13 +58,13 @@ class Source(Polymorphic, DataNode):
 
 class ChatSource(ScalarNode, Chat):
     @classmethod
-    async def compose(cls, source: Source) -> Chat:
+    def compose(cls, source: Source) -> Chat:
         return source.chat
 
 
 class UserSource(ScalarNode, User):
     @classmethod
-    async def compose(cls, source: Source) -> User:
+    def compose(cls, source: Source) -> User:
         return source.from_user
 
 

telegrinder/node/text.py

@@ -4,7 +4,7 @@ from telegrinder.node.message import MessageNode
 
 class Text(ScalarNode, str):
     @classmethod
-    async def compose(cls, message: MessageNode) -> str:
+    def compose(cls, message: MessageNode) -> str:
         if not message.text:
             raise ComposeError("Message has no text.")
         return message.text.unwrap()
@@ -12,7 +12,7 @@ class Text(ScalarNode, str):
 
 class TextInteger(ScalarNode, int):
     @classmethod
-    async def compose(cls, text: Text) -> int:
+    def compose(cls, text: Text) -> int:
         if not text.isdigit():
             raise ComposeError("Text is not digit.")
         return int(text)

telegrinder/node/tools/generator.py

@@ -25,8 +25,7 @@ def generate_node(
     casts: tuple[typing.Callable[[typing.Any], typing.Any], ...] = (cast_false_to_none, error_on_none),
 ) -> type[Node]:
     async def compose(cls, **kw) -> typing.Any:
-        args = await ContainerNode.compose(**kw)
-        result = func(*args)  # type: ignore
+        result = func(*ContainerNode.compose(**kw))  # type: ignore
         if inspect.isawaitable(result):
             result = await result
         for cast in casts:

telegrinder/node/update.py

@@ -1,12 +1,12 @@
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types import UpdateCute
 from telegrinder.node.base import ScalarNode
-from telegrinder.types import Update
+from telegrinder.types.objects import Update
 
 
 class UpdateNode(ScalarNode, UpdateCute):
     @classmethod
-    async def compose(cls, update: Update, api: API) -> UpdateCute:
+    def compose(cls, update: Update, api: API) -> UpdateCute:
         if isinstance(update, UpdateCute):
             return update
         return UpdateCute.from_update(update, api)

telegrinder/rules.py

@@ -56,5 +56,7 @@ __all__ = (
     "Regex",
     "RuleEnum",
     "StartCommand",
+    "State",
+    "StateMeta",
     "Text",
 )

telegrinder/tools/buttons.py

@@ -14,7 +14,7 @@ from telegrinder.types.objects import (
     WebAppInfo,
 )
 
-ButtonT = typing.TypeVar("ButtonT", bound="BaseButton")
+KeyboardButton = typing.TypeVar("KeyboardButton", bound="BaseButton")
 
 
 @dataclasses.dataclass
@@ -27,11 +27,11 @@ class BaseButton:
         }
 
 
-class RowButtons(typing.Generic[ButtonT]):
-    buttons: list[ButtonT]
+class RowButtons(typing.Generic[KeyboardButton]):
+    buttons: list[KeyboardButton]
     auto_row: bool
 
-    def __init__(self, *buttons: ButtonT, auto_row: bool = True) -> None:
+    def __init__(self, *buttons: KeyboardButton, auto_row: bool = True) -> None:
         self.buttons = list(buttons)
         self.auto_row = auto_row
 

telegrinder/tools/error_handler/abc.py

@@ -6,28 +6,28 @@ from fntypes.result import Result
 from telegrinder.api import API
 from telegrinder.bot.dispatch.context import Context
 
-EventT = typing.TypeVar("EventT")
-Handler = typing.Callable[typing.Concatenate[EventT, ...], typing.Awaitable[typing.Any]]
+Event = typing.TypeVar("Event")
+Handler = typing.Callable[..., typing.Awaitable[typing.Any]]
 
 
-class ABCErrorHandler(ABC, typing.Generic[EventT]):
+class ABCErrorHandler(ABC, typing.Generic[Event]):
     @abstractmethod
     def __call__(
         self,
         *args: typing.Any,
         **kwargs: typing.Any,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]]:
-        """Decorator for registering callback as an error handler."""
+        """Decorator for registering callback as a catcher for the error handler."""
 
     @abstractmethod
     async def run(
         self,
-        handler: Handler[EventT],
-        event: EventT,
+        handler: Handler,
+        event: Event,
         api: API,
         ctx: Context,
     ) -> Result[typing.Any, typing.Any]:
-        """Run error handler."""
+        """Run the error handler."""
 
 
 __all__ = ("ABCErrorHandler",)

telegrinder/tools/error_handler/error_handler.py

@@ -3,21 +3,32 @@ import typing
 
 from fntypes.result import Error, Ok, Result
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.modules import logger
+from telegrinder.node.base import is_node
+from telegrinder.tools.error_handler.abc import ABCErrorHandler, Event, Handler
+from telegrinder.tools.error_handler.error import CatcherError
 from telegrinder.tools.magic import magic_bundle
 
-from .abc import ABCErrorHandler, EventT, Handler
-from .error import CatcherError
-
 F = typing.TypeVar("F", bound="FuncCatcher")
 ExceptionT = typing.TypeVar("ExceptionT", bound=BaseException, contravariant=True)
 FuncCatcher = typing.Callable[typing.Concatenate[ExceptionT, ...], typing.Awaitable[typing.Any]]
 
 
+async def run_handler(
+    handler: Handler,
+    event: typing.Any,
+    ctx: dict[str, typing.Any],
+) -> typing.Any:
+    annotations = tuple(handler.__annotations__.values())
+    start_idx = 0 if is_node(None if not annotations else annotations[0]) else 1
+    context = magic_bundle(handler, ctx, start_idx=start_idx)
+    return await (handler(event, **context) if start_idx == 1 else handler(**context))
+
+
 @dataclasses.dataclass(frozen=True, repr=False, slots=True)
-class Catcher(typing.Generic[EventT]):
+class Catcher(typing.Generic[Event]):
     func: FuncCatcher[BaseException]
     exceptions: list[type[BaseException] | BaseException] = dataclasses.field(
         default_factory=lambda: [],
@@ -37,20 +48,29 @@ class Catcher(typing.Generic[EventT]):
 
     async def __call__(
         self,
-        handler: Handler[EventT],
-        event: EventT,
+        handler: Handler,
+        event: Event,
         api: API,
         ctx: Context,
     ) -> Result[typing.Any, BaseException]:
         try:
-            return Ok(await handler(event, **magic_bundle(handler, ctx)))  # type: ignore
+            return Ok(await run_handler(handler, event, ctx))
         except BaseException as exc:
-            return await self.process_exception(api, event, ctx, exc, handler.__name__)
+            return await self.run(api, event, ctx, exc, handler.__name__)
+
+    def match_exception(self, exception: BaseException) -> bool:
+        for exc in self.exceptions:
+            if isinstance(exc, type) and type(exception) is exc:
+                return True
+            if isinstance(exc, object) and type(exception) is type(exc):
+                return True if not exc.args else exc.args == exception.args
+
+        return False
 
-    async def process_exception(
+    async def run(
         self,
         api: API,
-        event: EventT,
+        event: Event,
         ctx: Context,
         exception: BaseException,
         handler_name: str,
@@ -61,26 +81,14 @@ class Catcher(typing.Generic[EventT]):
                     exception, handler_name, self.func.__name__
                 )
             )
-            return Ok(
-                await self.func(
-                    exception,
-                    **magic_bundle(self.func, {"event": event, "api": api} | ctx),  # type: ignore
-                )
-            )
+            return Ok(await run_handler(self.func, event, {"event": event, "api": api} | ctx))
+
         logger.debug("Failed to match exception {!r}.", exception.__class__.__name__)
         return Error(exception)
 
-    def match_exception(self, exception: BaseException) -> bool:
-        for exc in self.exceptions:
-            if isinstance(exc, type) and type(exception) is exc:
-                return True
-            if isinstance(exc, object) and type(exception) is type(exc):
-                return True if not exc.args else exc.args == exception.args
-        return False
-
 
-class ErrorHandler(ABCErrorHandler[EventT]):
-    def __init__(self, catcher: Catcher[EventT] | None = None, /) -> None:
+class ErrorHandler(ABCErrorHandler[Event]):
+    def __init__(self, catcher: Catcher[Event] | None = None, /) -> None:
         self.catcher = catcher
 
     def __repr__(self) -> str:
@@ -103,8 +111,8 @@ class ErrorHandler(ABCErrorHandler[EventT]):
     ):
         """Register the catcher.
 
-        :param logging: Logging the result of the catcher at the level 'DEBUG'.
-        :param raise_exception: Raise an exception if the catcher hasn't started.
+        :param logging: Logging the result of the catcher at the level `DEBUG`.
+        :param raise_exception: Raise an exception if the catcher has not started.
         :param ignore_errors: Ignore errors that may occur.
         """
 
@@ -121,10 +129,22 @@ class ErrorHandler(ABCErrorHandler[EventT]):
 
         return decorator
 
+    def _process_catcher_error(self, error: CatcherError) -> Result[None, BaseException]:
+        assert self.catcher is not None
+
+        if self.catcher.raise_exception:
+            raise error.exc from None
+        if self.catcher.logging:
+            logger.error(error.message)
+        if not self.catcher.ignore_errors:
+            return Error(error.exc)
+
+        return Ok(None)
+
     async def process(
         self,
-        handler: Handler[EventT],
-        event: EventT,
+        handler: Handler,
+        event: Event,
         api: API,
         ctx: Context,
     ) -> Result[typing.Any, BaseException]:
@@ -143,27 +163,15 @@ class ErrorHandler(ABCErrorHandler[EventT]):
                 )
             )
 
-    def process_catcher_error(self, error: CatcherError) -> Result[None, BaseException]:
-        assert self.catcher is not None
-
-        if self.catcher.raise_exception:
-            raise error.exc from None
-        if self.catcher.logging:
-            logger.error(error.message)
-        if not self.catcher.ignore_errors:
-            return Error(error.exc)
-
-        return Ok(None)
-
     async def run(
         self,
-        handler: Handler[EventT],
-        event: EventT,
+        handler: Handler,
+        event: Event,
         api: API,
         ctx: Context,
     ) -> Result[typing.Any, BaseException]:
         if not self.catcher:
-            return Ok(await handler(event, **magic_bundle(handler, ctx)))  # type: ignore
+            return Ok(await run_handler(handler, event, ctx))
 
         match await self.process(handler, event, api, ctx):
             case Ok(value) as ok:
@@ -176,7 +184,10 @@ class ErrorHandler(ABCErrorHandler[EventT]):
                 return ok
             case Error(exc) as err:
                 if isinstance(exc, CatcherError):
-                    return self.process_catcher_error(exc)
+                    return self._process_catcher_error(exc)
                 if self.catcher.ignore_errors:
                     return Ok(None)
                 return err
+
+
+__all__ = ("Catcher", "ErrorHandler")

telegrinder/tools/formatting/html.py

@@ -1,5 +1,3 @@
-# NOTE: NEED REFACTORING
-
 import html
 import string
 import typing

telegrinder/tools/functional.py

@@ -7,3 +7,6 @@ T = typing.TypeVar("T")
 
 def from_optional(value: T | None) -> Option[T]:
     return Some(value) if value is not None else Nothing()
+
+
+__all__ = ("from_optional",)

telegrinder/tools/global_context/telegrinder_ctx.py

@@ -1,3 +1,4 @@
+import re
 import typing
 
 import vbml
@@ -19,6 +20,7 @@ class TelegrinderContext(GlobalContext):
 
     __ctx_name__ = "telegrinder"
 
+    vbml_pattern_flags: re.RegexFlag | None = None
     vbml_patcher: typing.ClassVar[vbml.Patcher] = ctx_var(vbml.Patcher(), const=True)
 
 

telegrinder/tools/i18n/__init__.py

@@ -1,4 +1,4 @@
-from .base import ABCI18n, ABCTranslator, I18nEnum
+from .abc import ABCI18n, ABCTranslator, I18nEnum
 from .middleware import ABCTranslatorMiddleware
 from .simple import SimpleI18n, SimpleTranslator
 

telegrinder/tools/i18n/middleware/__init__.py

@@ -1,3 +1,3 @@
-from .base import ABCTranslatorMiddleware
+from .abc import ABCTranslatorMiddleware
 
 __all__ = ("ABCTranslatorMiddleware",)

telegrinder/tools/i18n/middleware/{base.py → abc.py}

@@ -2,6 +2,7 @@ import typing
 from abc import abstractmethod
 
 from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.middleware import ABCMiddleware
 from telegrinder.tools.i18n import ABCI18n, I18nEnum
 
@@ -9,14 +10,14 @@ T = typing.TypeVar("T", bound=BaseCute)
 
 
 class ABCTranslatorMiddleware(ABCMiddleware[T]):
-    def __init__(self, i18n: ABCI18n):
+    def __init__(self, i18n: ABCI18n) -> None:
         self.i18n = i18n
 
     @abstractmethod
     async def get_locale(self, event: T) -> str:
         pass
 
-    async def pre(self, event: T, ctx: dict) -> bool:
+    async def pre(self, event: T, ctx: Context) -> bool:
         ctx[I18nEnum.I18N] = self.i18n.get_translator_by_locale(await self.get_locale(event))
         return True
 

telegrinder/tools/i18n/simple.py

@@ -3,12 +3,20 @@
 import gettext
 import os
 
-from telegrinder.tools.i18n import ABCI18n
-from telegrinder.tools.i18n.base import ABCTranslator
+from telegrinder.tools.i18n.abc import ABCI18n, ABCTranslator
+
+
+class SimpleTranslator(ABCTranslator):
+    def __init__(self, locale: str, g: gettext.GNUTranslations) -> None:
+        self.g = g
+        super().__init__(locale)
+
+    def get(self, __key: str, *args: object, **kwargs: object) -> str:
+        return self.g.gettext(__key).format(*args, **kwargs)
 
 
 class SimpleI18n(ABCI18n):
-    def __init__(self, folder: str, domain: str, default_locale: str):
+    def __init__(self, folder: str, domain: str, default_locale: str) -> None:
         self.folder = folder
         self.domain = domain
         self.default_locale = default_locale
@@ -32,13 +40,4 @@ class SimpleI18n(ABCI18n):
         return SimpleTranslator(locale, self.translators.get(locale, self.translators[self.default_locale]))
 
 
-class SimpleTranslator(ABCTranslator):
-    def __init__(self, locale: str, g: gettext.GNUTranslations):
-        self.g = g
-        super().__init__(locale)
-
-    def get(self, __key: str, *args, **kwargs) -> str:
-        return self.g.gettext(__key).format(*args, **kwargs)
-
-
 __all__ = ("SimpleI18n", "SimpleTranslator")

telegrinder/tools/keyboard.py

@@ -11,12 +11,16 @@ from telegrinder.types.objects import (
     ReplyKeyboardRemove,
 )
 
-from .buttons import Button, ButtonT, InlineButton, RowButtons
+from .buttons import Button, InlineButton, KeyboardButton, RowButtons
 
 DictStrAny: typing.TypeAlias = dict[str, typing.Any]
 AnyMarkup: typing.TypeAlias = InlineKeyboardMarkup | ReplyKeyboardMarkup
 
 
+def copy_keyboard(keyboard: list[list[DictStrAny]]) -> list[list[DictStrAny]]:
+    return [row.copy() for row in keyboard]
+
+
 @dataclasses.dataclass(kw_only=True, slots=True)
 class KeyboardModel:
     resize_keyboard: bool
@@ -26,13 +30,8 @@ class KeyboardModel:
     keyboard: list[list[DictStrAny]]
 
 
-
-def copy_keyboard(keyboard: list[list[DictStrAny]]) -> list[list[DictStrAny]]:
-    return [row.copy() for row in keyboard]
-
-
-class ABCMarkup(ABC, typing.Generic[ButtonT]):
-    BUTTON: type[ButtonT]
+class ABCMarkup(ABC, typing.Generic[KeyboardButton]):
+    BUTTON: type[KeyboardButton]
     keyboard: list[list[DictStrAny]]
 
     @abstractmethod
@@ -47,7 +46,7 @@ class ABCMarkup(ABC, typing.Generic[ButtonT]):
     def get_empty_markup(cls) -> AnyMarkup:
         return cls().get_markup()
 
-    def add(self, row_or_button: RowButtons[ButtonT] | ButtonT) -> typing.Self:
+    def add(self, row_or_button: RowButtons[KeyboardButton] | KeyboardButton) -> typing.Self:
         if not len(self.keyboard):
             self.row()
 
@@ -129,4 +128,5 @@ __all__ = (
     "InlineKeyboard",
     "Keyboard",
     "KeyboardModel",
+    "copy_keyboard",
 )

{telegrinder-0.3.0.post1.dist-info → telegrinder-0.3.0.post2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telegrinder
-Version: 0.3.0.post1
+Version: 0.3.0.post2
 Summary: Modern visionary telegram bot framework.
 Home-page: https://github.com/timoniq/telegrinder
 License: MIT