telegrinder 0.1.dev20__py3-none-any.whl → 0.1.dev158__py3-none-any.whl

telegrinder/bot/cute_types/callback_query.py

@@ -1,28 +1,78 @@
-from telegrinder.types import CallbackQuery, User
-from telegrinder.model import get_params
-from telegrinder.api import API, APIError
-from telegrinder.result import Result
 import typing
+from contextlib import suppress
+
+import msgspec
+from fntypes.co import Result, Some, Variative
+
+from telegrinder.api import ABCAPI, APIError
+from telegrinder.model import get_params
+from telegrinder.msgspec_utils import Nothing, Option, decoder
+from telegrinder.types import (
+    CallbackQuery,
+    InlineKeyboardMarkup,
+    Message,
+    MessageEntity,
+    User,
+)
+
+from .base import BaseCute
 
 
-class CallbackQueryCute(CallbackQuery):
-    api: API
+class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True, dict=True):
+    api: ABCAPI
 
     @property
     def from_user(self) -> User:
         return self.from_
+    
+    def decode_callback_data(self, *, strict: bool = True) -> Option[dict]:
+        if "cached_callback_data" in self.__dict__:
+            return self.__dict__["cached_callback_data"]
 
-    @property
-    def ctx_api(self) -> API:
-        return self.api
+        data = Nothing
+        with suppress(msgspec.ValidationError):
+            data = Some(decoder.decode(self.data.unwrap()))
+        
+        self.__dict__["cached_callback_data"] = data
+        return data
 
     async def answer(
         self,
-        text: typing.Optional[str] = None,
-        show_alert: typing.Optional[bool] = None,
-        url: typing.Optional[str] = None,
-        cache_time: typing.Optional[int] = None,
-        **other
+        text: str | Option[str] = Nothing,
+        show_alert: bool | Option[bool] = Nothing,
+        url: str | Option[str] = Nothing,
+        cache_time: int | Option[int] = Nothing,
+        **other: typing.Any,
     ) -> Result[bool, APIError]:
         params = get_params(locals())
         return await self.ctx_api.answer_callback_query(self.id, **params)
+
+    async def edit_text(
+        self,
+        text: str | Option[str],
+        parse_mode: str | Option[str] = Nothing,
+        entities: list[MessageEntity] | Option[list[MessageEntity]] = Nothing,
+        disable_web_page_preview: bool | Option[bool] = Nothing,
+        reply_markup: InlineKeyboardMarkup
+        | Option[InlineKeyboardMarkup]
+        = Nothing,
+        **other: typing.Any,
+    ) -> Result[Variative[Message, bool], APIError]:
+        params = get_params(locals())
+        
+        if message := self.message.map(lambda message: message.only().unwrap_or_none()).unwrap_or_none():
+            if message.message_thread_id and "message_thread_id" not in params:
+                params["message_thread_id"] = message.message_thread_id.unwrap()
+            return await self.ctx_api.edit_message_text(
+                chat_id=message.chat.id,
+                message_id=message.message_id,
+                **params,
+            )
+        
+        return await self.ctx_api.edit_message_text(
+            inline_message_id=self.inline_message_id,
+            **params,
+        )
+
+
+__all__ = ("CallbackQueryCute",)

telegrinder/bot/cute_types/inline_query.py

@@ -1,35 +1,41 @@
-from telegrinder.types import InlineQuery, User
-from telegrinder.api import API, APIError
-from telegrinder.result import Result
 import typing
 
+from fntypes.result import Result
 
-class InlineQueryCute(InlineQuery):
-    api: API
+from telegrinder.api import ABCAPI, APIError
+from telegrinder.msgspec_utils import Nothing, Option
+from telegrinder.types import InlineQuery, InlineQueryResult, User
+
+from .base import BaseCute
+
+
+class InlineQueryCute(BaseCute[InlineQuery], InlineQuery, kw_only=True):
+    api: ABCAPI
 
     @property
     def from_user(self) -> User:
         return self.from_
 
-    @property
-    def ctx_api(self) -> API:
-        return self.api
-
     async def answer(
         self,
-        results: typing.Optional[list] = None,
-        cache_time: typing.Optional[int] = None,
-        is_personal: typing.Optional[bool] = None,
-        next_offset: typing.Optional[str] = None,
-        switch_pm_text: typing.Optional[str] = None,
-        switch_pm_parameter: typing.Optional[str] = None,
+        results: InlineQueryResult | list[InlineQueryResult],
+        cache_time: int | Option[int] = Nothing,
+        is_personal: bool | Option[bool] = Nothing,
+        next_offset: str | Option[str] = Nothing,
+        switch_pm_text: str | Option[str] = Nothing,
+        switch_pm_parameter: str | Option[str] = Nothing,
+        **other: typing.Any,
     ) -> Result[bool, APIError]:
         return await self.ctx_api.answer_inline_query(
             self.id,
-            results=results,
+            results=[results] if not isinstance(results, list) else results,
             cache_time=cache_time,
             is_personal=is_personal,
             next_offset=next_offset,
             switch_pm_text=switch_pm_text,
             switch_pm_parameter=switch_pm_parameter,
+            **other,
         )
+
+
+__all__ = ("InlineQueryCute",)

telegrinder/bot/cute_types/message.py

@@ -1,67 +1,131 @@
+import typing
+
+from fntypes.co import Option, Result, Some, Variative
+
+from telegrinder.api import ABCAPI, APIError
+from telegrinder.model import get_params
+from telegrinder.msgspec_utils import Nothing
 from telegrinder.types import (
+    ForceReply,
+    InlineKeyboardMarkup,
     Message,
     MessageEntity,
+    ReactionType,
+    ReactionTypeEmoji,
+    ReactionTypeType,
+    ReplyKeyboardMarkup,
+    ReplyKeyboardRemove,
+    ReplyParameters,
+    User,
+)
+from telegrinder.types.objects import InputFile
+
+from .base import BaseCute
+
+ReplyMarkup = typing.Union[
     InlineKeyboardMarkup,
     ReplyKeyboardMarkup,
     ReplyKeyboardRemove,
     ForceReply,
-)
-from telegrinder.model import get_params
-from telegrinder.api import API, APIError
-from telegrinder.result import Result
-import typing
+]
+
+
+def get_entity_value(
+    entities: list[MessageEntity], entity_value: str
+) -> Option[typing.Any]:
+    for entity in entities:
+        if (obj := getattr(entity, entity_value, Nothing)):
+            return Some(obj.value if isinstance(obj, Some) else obj)
+    return Nothing
 
 
-class MessageCute(Message):
-    api: API
+class MessageCute(BaseCute[Message], Message, kw_only=True):
+    api: ABCAPI
 
     @property
-    def ctx_api(self) -> API:
-        return self.api
+    def mentioned_user(self) -> Option[User]:
+        """Mentioned user without username."""
+
+        if not self.entities:
+            return Nothing
+        return get_entity_value(self.entities.unwrap(), "user")
+
+    @property
+    def url(self) -> Option[str]:
+        """Clickable text URL."""
+
+        if not self.entities:
+            return Nothing
+        return get_entity_value(self.entities.unwrap(), "url")
+
+    @property
+    def programming_language(self) -> Option[str]:
+        """The programming language of the entity text."""
+
+        if not self.entities:
+            return Nothing
+        return get_entity_value(self.entities.unwrap(), "language")
+
+    @property
+    def custom_emoji_id(self) -> Option[str]:
+        """Unique identifier of the custom emoji."""
+
+        if not self.entities:
+            return Nothing
+        return get_entity_value(self.entities.unwrap(), "custom_emoji_id")
 
     async def answer(
         self,
-        text: typing.Optional[str] = None,
-        parse_mode: typing.Optional[str] = None,
-        entities: typing.Optional[typing.List["MessageEntity"]] = None,
-        disable_web_page_preview: typing.Optional[bool] = None,
-        disable_notification: typing.Optional[bool] = None,
-        protect_content: typing.Optional[bool] = None,
-        reply_to_message_id: typing.Optional[int] = None,
-        allow_sending_without_reply: typing.Optional[bool] = None,
-        reply_markup: typing.Optional[
-            typing.Union[
-                "InlineKeyboardMarkup",
-                "ReplyKeyboardMarkup",
-                "ReplyKeyboardRemove",
-                "ForceReply",
-            ]
-        ] = None,
-        **other
+        text: str | Option[str],
+        parse_mode: str | Option[str] = Nothing,
+        entities: list[MessageEntity] | Option[list[MessageEntity]] = Nothing,
+        disable_web_page_preview: bool | Option[bool] = Nothing,
+        disable_notification: bool | Option[bool] = Nothing,
+        protect_content: bool | Option[bool] = Nothing,
+        reply_to_message_id: int | Option[int] = Nothing,
+        allow_sending_without_reply: bool | Option[bool] = Nothing,
+        reply_markup: ReplyMarkup | Option[ReplyMarkup] = Nothing,
+        **other: typing.Any,
     ) -> Result["Message", APIError]:
         params = get_params(locals())
         if "message_thread_id" not in params and self.is_topic_message:
             params["message_thread_id"] = self.message_thread_id
         return await self.ctx_api.send_message(chat_id=self.chat.id, **params)
+    
+    async def answer_file(
+        self,
+        file: str | InputFile,
+        caption: str | Option[str] = Nothing,
+        parse_mode: str | Option[str] = Nothing,
+        thumbnail: Option[InputFile | str] | InputFile | str = Nothing,
+        caption_entities: list[MessageEntity] | Option[list[MessageEntity]] = Nothing,
+        disable_content_type_detection: Option[bool] | bool = Nothing,
+        disable_notification: Option[bool] | bool = Nothing,
+        protect_content: bool | Option[bool] = Nothing,
+        reply_parameters: Option[ReplyParameters] | ReplyParameters = Nothing,
+        reply_markup: ReplyMarkup | Option[ReplyMarkup] = Nothing,
+        **other: typing.Any,
+    ) -> Result[Message, APIError]:
+        params = get_params(locals())
+        if "message_thread_id" not in params and self.is_topic_message:
+            params["message_thread_id"] = self.message_thread_id
+        return await self.ctx_api.send_document(
+            chat_id=self.chat.id,
+            document=file,
+            **params,
+        )
 
     async def reply(
         self,
-        text: typing.Optional[str] = None,
-        parse_mode: typing.Optional[str] = None,
-        entities: typing.Optional[typing.List["MessageEntity"]] = None,
-        disable_web_page_preview: typing.Optional[bool] = None,
-        disable_notification: typing.Optional[bool] = None,
-        protect_content: typing.Optional[bool] = None,
-        allow_sending_without_reply: typing.Optional[bool] = None,
-        reply_markup: typing.Optional[
-            typing.Union[
-                "InlineKeyboardMarkup",
-                "ReplyKeyboardMarkup",
-                "ReplyKeyboardRemove",
-                "ForceReply",
-            ]
-        ] = None,
-        **other
+        text: str | Option[str],
+        parse_mode: str | Option[str] = Nothing,
+        entities: list[MessageEntity] | Option[list[MessageEntity]] = Nothing,
+        disable_web_page_preview: bool | Option[bool] = Nothing,
+        disable_notification: bool | Option[bool] = Nothing,
+        protect_content: bool | Option[bool] = Nothing,
+        allow_sending_without_reply: bool | Option[bool] = Nothing,
+        reply_markup: ReplyMarkup | Option[ReplyMarkup] = Nothing,
+        **other: typing.Any,
     ) -> Result["Message", APIError]:
         params = get_params(locals())
         if "message_thread_id" not in params and self.is_topic_message:
@@ -69,33 +133,61 @@ class MessageCute(Message):
         return await self.ctx_api.send_message(
             chat_id=self.chat.id,
             reply_to_message_id=self.message_id,
-            **params
+            **params,
         )
 
-    async def delete(self, **other) -> Result[bool, APIError]:
+    async def delete(self, **other: typing.Any) -> Result[bool, APIError]:
         params = get_params(locals())
         if "message_thread_id" not in params and self.is_topic_message:
             params["message_thread_id"] = self.message_thread_id
         return await self.ctx_api.delete_message(
             chat_id=self.chat.id,
             message_id=self.message_id,
-            **params
+            **params,
         )
 
     async def edit(
         self,
-        text: typing.Optional[str] = None,
-        parse_mode: typing.Optional[str] = None,
-        entities: typing.Optional[typing.List[MessageEntity]] = None,
-        disable_web_page_preview: typing.Optional[bool] = None,
-        reply_markup: typing.Optional[InlineKeyboardMarkup] = None,
-        **other
-    ) -> Result[Message | bool, APIError]:
+        text: str | Option[str] = Nothing,
+        parse_mode: str | Option[str] = Nothing,
+        entities: list[MessageEntity] | Option[list[MessageEntity]] = Nothing,
+        disable_web_page_preview: bool | Option[bool] = Nothing,
+        reply_markup: InlineKeyboardMarkup
+        | Option[InlineKeyboardMarkup] = Nothing,
+        **other: typing.Any,
+    ) -> Result[Variative[Message, bool], APIError]:
         params = get_params(locals())
         if "message_thread_id" not in params and self.is_topic_message:
             params["message_thread_id"] = self.message_thread_id
         return await self.ctx_api.edit_message_text(
             chat_id=self.chat.id,
             message_id=self.message_id,
-            **params
+            **params,
+        )
+    
+    async def react(
+        self,
+        reaction: str | ReactionType
+        | list[str | ReactionType]
+        | Option[list[str | ReactionType]] = Nothing,
+        is_big: bool | Option[bool] = Nothing,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        if reaction:
+            reaction = [
+                ReactionTypeEmoji(ReactionTypeType.EMOJI, r)
+                if isinstance(r, str)
+                else r
+                for r in (
+                    reaction.unwrap_or([]) if isinstance(reaction, Some | type(Nothing))
+                    else [reaction] if not isinstance(reaction, list) else reaction
+                )
+            ]
+        return await self.ctx_api.set_message_reaction(
+            chat_id=self.chat.id,
+            message_id=self.message_id,
+            **get_params(locals())
         )
+
+
+__all__ = ("MessageCute", "get_entity_value")

telegrinder/bot/cute_types/update.py

@@ -0,0 +1,23 @@
+from fntypes.co import Nothing, Some
+
+from telegrinder.api import ABCAPI
+from telegrinder.msgspec_utils import Option
+from telegrinder.types import Update, UpdateType
+
+from .base import BaseCute
+
+
+class UpdateCute(BaseCute[Update], Update, kw_only=True):
+    api: ABCAPI
+
+    @property
+    def update_type(self) -> Option[UpdateType]:
+        for name, update in self.to_dict(
+            exclude_fields={"update_id"},
+        ).items():
+            if update is not None:
+                return Some(UpdateType(name))
+        return Nothing()
+
+
+__all__ = ("UpdateCute",)

telegrinder/bot/dispatch/__init__.py

@@ -1,5 +1,58 @@
 from .abc import ABCDispatch
-from .dispatch import ABCDispatch, Dispatch, ABCRule
-from .handler import ABCHandler, FuncHandler
+from .composition import CompositionDispatch
+from .context import Context
+from .dispatch import ABCRule, Dispatch, TelegrinderCtx
+from .handler import ABCHandler, FuncHandler, MessageReplyHandler
 from .middleware import ABCMiddleware
-from .view import ABCView, MessageView, CallbackQueryView, InlineQueryView
+from .process import check_rule, process_inner
+from .return_manager import (
+    ABCReturnManager,
+    BaseReturnManager,
+    CallbackQueryReturnManager,
+    InlineQueryReturnManager,
+    Manager,
+    MessageReturnManager,
+    register_manager,
+)
+from .view import (
+    ABCStateView,
+    ABCView,
+    BaseStateView,
+    BaseView,
+    CallbackQueryView,
+    InlineQueryView,
+    MessageView,
+    ViewBox,
+)
+from .waiter_machine import WaiterMachine
+
+__all__ = (
+    "ABCDispatch",
+    "ABCHandler",
+    "ABCMiddleware",
+    "ABCReturnManager",
+    "ABCRule",
+    "ABCStateView",
+    "ABCView",
+    "BaseReturnManager",
+    "BaseStateView",
+    "BaseView",
+    "CallbackQueryReturnManager",
+    "CallbackQueryView",
+    "CompositionDispatch",
+    "Context",
+    "Dispatch",
+    "FuncHandler",
+    "InlineQueryReturnManager",
+    "InlineQueryView",
+    "Manager",
+    "MessageReplyHandler",
+    "MessageReturnManager",
+    "MessageView",
+    "TelegrinderCtx",
+    "ViewBox",
+    "WaiterMachine",
+    "check_rule",
+    "process_inner",
+    "register_manager",
+)

telegrinder/bot/dispatch/abc.py

@@ -1,19 +1,21 @@
+import typing
 from abc import ABC, abstractmethod
+
 from telegrinder.api.abc import ABCAPI
+from telegrinder.tools.global_context import ABCGlobalContext
 from telegrinder.types import Update
-from .view.abc import ABCView
-import typing
 
 
 class ABCDispatch(ABC):
-    @abstractmethod
-    def feed(self, event: Update, api: ABCAPI) -> bool:
-        pass
+    global_context: ABCGlobalContext
 
     @abstractmethod
-    def load(self, external: "ABCDispatch"):
+    async def feed(self, event: Update, api: ABCAPI) -> bool:
         pass
 
     @abstractmethod
-    def mount(self, view_t: typing.Type["ABCView"], name: str):
+    def load(self, external: typing.Self):
         pass
+
+
+__all__ = ("ABCDispatch",)

telegrinder/bot/dispatch/composition.py

@@ -0,0 +1,74 @@
+import inspect
+import typing
+
+from telegrinder.api.abc import ABCAPI
+from telegrinder.bot.cute_types import UpdateCute
+from telegrinder.bot.dispatch.abc import ABCDispatch
+from telegrinder.node import (
+    ComposeError,
+    ContainerNode,
+    Node,
+    NodeCollection,
+    NodeSession,
+    compose_node,
+)
+from telegrinder.tools import magic_bundle
+from telegrinder.types import Update
+
+
+class Composition:
+    nodes: dict[str, type[Node]]
+
+    def __init__(self, func: typing.Callable, is_blocking: bool) -> None:
+        self.func = func
+        self.nodes = {
+            name: parameter.annotation
+            for name, parameter in inspect.signature(func).parameters.items()
+        }
+        self.is_blocking = is_blocking
+    
+    async def compose_nodes(self, update: UpdateCute) -> NodeCollection | None:
+        nodes: dict[str, NodeSession] = {}
+        for name, node_t in self.nodes.items():
+            try:
+                nodes[name] = await compose_node(node_t, update)
+            except ComposeError as err:
+                await NodeCollection(nodes).close_all()
+                return None
+        return NodeCollection(nodes)
+    
+    async def __call__(self, **kwargs) -> typing.Any:
+        return await self.func(**magic_bundle(self.func, kwargs, start_idx=0, bundle_ctx=False))  # type: ignore
+
+
+class CompositionDispatch(ABCDispatch):
+    def __init__(self) -> None:
+        self.compositions: list[Composition] = []
+    
+    async def feed(self, event: Update, api: ABCAPI) -> bool:
+        update = UpdateCute(**event.to_dict(), api=api)
+        is_found = False
+        for composition in self.compositions:
+            nodes = await composition.compose_nodes(update)
+            if nodes is not None:
+                result = await composition(**nodes.values())
+                await nodes.close_all(with_value=result)
+                if composition.is_blocking:
+                    return True
+                is_found = True
+        return is_found
+    
+    def load(self, external: typing.Self):
+        self.compositions.extend(external.compositions)
+
+    def __call__(self, *container_nodes: type[Node], is_blocking: bool = True):
+        def wrapper(func: typing.Callable):
+            composition = Composition(func, is_blocking)
+            if container_nodes:
+                composition.nodes["container"] = ContainerNode.link_nodes(list(container_nodes))
+            self.compositions.append(composition)
+            return func
+        return wrapper
+
+
+__all__ = ("Composition", "CompositionDispatch")

telegrinder/bot/dispatch/context.py

@@ -0,0 +1,71 @@
+import enum
+import typing
+
+from telegrinder.types import Update
+
+T = typing.TypeVar("T")
+
+Key: typing.TypeAlias = str | enum.Enum
+AnyValue: typing.TypeAlias = typing.Any
+
+
+@typing.dataclass_transform(kw_only_default=True, order_default=True)
+class Context(dict[str, AnyValue]):
+    """Context class for rules and middlewares.
+    ```
+    class MyRule(ABCRule[T]):
+        adapter: ABCAdapter[Update, T] = RawUpdateAdapter()
+
+        async def check(self, event: T, ctx: Context) -> bool:
+            ctx.set("value", (await event.ctx_api.get_me()).unwrap())
+            return True
+    ```
+    """
+
+    raw_update: Update
+
+    def __init__(self, **kwargs: AnyValue) -> None:
+        cls_vars = vars(self.__class__)
+        defaults = {}
+        for k in self.__class__.__annotations__:
+            if k in cls_vars:
+                defaults[k] = cls_vars[k]
+                delattr(self.__class__, k)
+        dict.__init__(self, **defaults | kwargs)
+    
+    def __setitem__(self, __key: Key, __value: AnyValue) -> None:
+        dict.__setitem__(self, self.key_to_str(__key), __value)
+    
+    def __getitem__(self, __key: Key) -> AnyValue:
+        return dict.__getitem__(self, self.key_to_str(__key))
+    
+    def __delitem__(self, __key: Key) -> None:
+        dict.__delitem__(self, self.key_to_str(__key))
+
+    def __setattr__(self, __name: str, __value: AnyValue) -> None:
+        self.__setitem__(__name, __value)
+    
+    def __getattr__(self, __name: str) -> AnyValue:
+        return self.__getitem__(__name)
+    
+    def __delattr__(self, __name: str) -> None:
+        self.__delitem__(__name)
+
+    @staticmethod
+    def key_to_str(key: Key) -> str:
+        return key if isinstance(key, str) else str(key.value)
+    
+    def copy(self) -> typing.Self:
+        return self.__class__(**self)
+
+    def set(self, key: Key, value: AnyValue) -> None:
+        self[key] = value
+    
+    def get(self, key: Key, default: T | None = None) -> T | AnyValue:
+        return dict.get(self, key, default)
+    
+    def delete(self, key: Key) -> None:
+        del self[key]
+
+
+__all__ = ("Context",)