telegrinder 0.1.dev170__tar.gz → 0.2.0__tar.gz

{telegrinder-0.1.dev170 → telegrinder-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telegrinder
-Version: 0.1.dev170
+Version: 0.2.0
 Summary: Modern visionary telegram bot framework.
 Home-page: https://github.com/timoniq/telegrinder
 License: MIT
@@ -25,7 +25,7 @@ Requires-Dist: certifi (>=2024.2.2,<2025.0.0)
 Requires-Dist: choicelib (>=0.1.5,<0.2.0)
 Requires-Dist: colorama (>=0.4.0,<0.5.0)
 Requires-Dist: envparse (>=0.2.0,<0.3.0)
-Requires-Dist: fntypes (>=0.1.2.post2,<0.2.0)
+Requires-Dist: fntypes (>=0.1.3,<0.2.0)
 Requires-Dist: msgspec (>=0.18.6,<0.19.0)
 Requires-Dist: requests (>=2.28.1,<3.0.0)
 Requires-Dist: typing-extensions (>=4.10.0,<5.0.0)

{telegrinder-0.1.dev170 → telegrinder-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "telegrinder"
-version = "0.1.dev170"
+version = "0.2.0"
 description = "Modern visionary telegram bot framework."
 authors = ["timoniq <tesseradecades@mail.ru>"]
 maintainers = ["luwqz1 <howluwqz1@gmail.com>"]
@@ -29,6 +29,7 @@ classifiers = [
   "Intended Audience :: Developers",
   "License :: OSI Approved :: MIT License",
   "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
   "Topic :: Software Development :: Libraries :: Python Modules",
   "Topic :: Software Development :: Quality Assurance",
   "Typing :: Typed",
@@ -49,10 +50,11 @@ certifi = "^2024.2.2"
 msgspec = "^0.18.6"
 requests = "^2.28.1"
 typing-extensions = "^4.10.0"
-fntypes = "^0.1.2.post2"
+fntypes = "^0.1.3"
 
 [tool.poetry.group.dev.dependencies]
-ruff = "^0.5.0"
+pre-commit = "^3.8.0"
+ruff = ">=0.5,<0.7"
 basedpyright = "^1.12.1"
 sort-all = "1.2.0"
 pytest = "^8.0.0"
@@ -85,11 +87,9 @@ docstring-quotes = "double"
 
 [tool.pyright]
 exclude = [
-    "**/__pycache__",
-    "examples/blueprint_bot",
-    "examples/webhook_bot",
-    "docs",
-    "local",
+  "**/__pycache__",
+  "docs",
+  "local",
 ]
 typeCheckingMode = "basic"
 pythonPlatform = "All"

{telegrinder-0.1.dev170 → telegrinder-0.2.0}/telegrinder/__init__.py

@@ -34,7 +34,7 @@ bot.run_forever()
 
 import typing
 
-from .api import ABCAPI, API, APIError, APIResponse, Token
+from .api import API, APIError, APIResponse, Token
 from .bot import (
     ABCDispatch,
     ABCHandler,
@@ -122,7 +122,7 @@ Bot: typing.TypeAlias = Telegrinder
 
 
 __all__ = (
-    "ABCAPI",
+    "API",
     "ABCClient",
     "ABCDispatch",
     "ABCErrorHandler",

{telegrinder-0.1.dev170 → telegrinder-0.2.0}/telegrinder/api/__init__.py

@@ -1,10 +1,9 @@
-from .abc import ABCAPI, Token
 from .api import API
 from .error import APIError, InvalidTokenError
 from .response import APIResponse
+from .token import Token
 
 __all__ = (
-    "ABCAPI",
     "API",
     "APIError",
     "APIResponse",

{telegrinder-0.1.dev170 → telegrinder-0.2.0}/telegrinder/api/api.py

@@ -1,32 +1,34 @@
 import typing
+from functools import cached_property
 
 import msgspec
 from fntypes.result import Error, Ok, Result
 
+from telegrinder.api.error import APIError
 from telegrinder.api.response import APIResponse
+from telegrinder.api.token import Token
 from telegrinder.client import ABCClient, AiohttpClient
 from telegrinder.model import DataConverter, decoder
 from telegrinder.types.methods import APIMethods
 
-from .abc import ABCAPI, APIError, Token
-
 
 def compose_data(
     client: ABCClient,
     data: dict[str, typing.Any],
     files: dict[str, tuple[str, bytes]],
 ) -> typing.Any:
-    converter = DataConverter(files=files.copy())
+    converter = DataConverter(_files=files.copy())
     return client.get_form(
         data={k: converter(v) for k, v in data.items()},
         files=converter.files,
     )
 
 
-class API(ABCAPI, APIMethods):
-    """Bot API with available API methods."""
+class API(APIMethods):
+    """Bot API with available API methods and http client."""
 
     API_URL = "https://api.telegram.org/"
+    API_FILE_URL = "https://api.telegram.org/file/"
 
     def __init__(self, token: Token, *, http: ABCClient | None = None) -> None:
         self.token = token
@@ -40,7 +42,7 @@ class API(ABCAPI, APIMethods):
             self.http,
         )
 
-    @property
+    @cached_property
     def id(self) -> int:
         return self.token.bot_id
 
@@ -48,6 +50,13 @@ class API(ABCAPI, APIMethods):
     def request_url(self) -> str:
         return self.API_URL + f"bot{self.token}/"
 
+    @property
+    def request_file_url(self) -> str:
+        return self.API_FILE_URL + f"bot{self.token}/"
+
+    async def download_file(self, file_path: str) -> bytes:
+        return await self.http.request_content(f"{self.request_file_url}/{file_path}")
+
     async def request(
         self,
         method: str,

{telegrinder-0.1.dev170 → telegrinder-0.2.0}/telegrinder/api/error.py

@@ -9,7 +9,8 @@ class APIError(BaseException):
         return f"<APIError: {self.__str__()}>"
 
 
-class InvalidTokenError(BaseException): ...
+class InvalidTokenError(BaseException):
+    pass
 
 
 __all__ = ("APIError", "InvalidTokenError")

telegrinder-0.2.0/telegrinder/api/token.py

@@ -0,0 +1,36 @@
+import pathlib
+import typing
+from functools import cached_property
+
+from envparse import env
+
+from .error import InvalidTokenError
+
+
+class Token(str):
+    def __new__(cls, token: str) -> typing.Self:
+        if token.count(":") != 1 or not token.split(":")[0].isdigit():
+            raise InvalidTokenError("Invalid token, it should look like this '123:ABC'.")
+        return super().__new__(cls, token)
+
+    def __repr__(self) -> str:
+        return f"<Token: {self.bot_id}:{''.join(self.split(':')[-1])[:6]}...>"
+
+    @classmethod
+    def from_env(
+        cls,
+        var_name: str = "BOT_TOKEN",
+        *,
+        is_read: bool = False,
+        path_to_envfile: str | pathlib.Path | None = None,
+    ) -> typing.Self:
+        if not is_read:
+            env.read_envfile(path_to_envfile)
+        return cls(env.str(var_name))
+
+    @cached_property
+    def bot_id(self) -> int:
+        return int(self.split(":")[0])
+
+
+__all__ = ("Token",)

{telegrinder-0.1.dev170 → telegrinder-0.2.0}/telegrinder/bot/__init__.py

@@ -1,5 +1,5 @@
-from .bot import Telegrinder
-from .cute_types import (
+from telegrinder.bot.bot import Telegrinder
+from telegrinder.bot.cute_types import (
     BaseCute,
     CallbackQueryCute,
     ChatJoinRequestCute,
@@ -8,7 +8,7 @@ from .cute_types import (
     MessageCute,
     UpdateCute,
 )
-from .dispatch import (
+from telegrinder.bot.dispatch import (
     ABCDispatch,
     ABCHandler,
     ABCMiddleware,
@@ -37,9 +37,15 @@ from .dispatch import (
     clear_wm_storage_worker,
     register_manager,
 )
-from .polling import ABCPolling, Polling
-from .rules import ABCRule, CallbackQueryRule, ChatJoinRequestRule, InlineQueryRule, MessageRule
-from .scenario import ABCScenario, Checkbox, Choice
+from telegrinder.bot.polling import ABCPolling, Polling
+from telegrinder.bot.rules import (
+    ABCRule,
+    CallbackQueryRule,
+    ChatJoinRequestRule,
+    InlineQueryRule,
+    MessageRule,
+)
+from telegrinder.bot.scenario import ABCScenario, Checkbox, Choice
 
 __all__ = (
     "ABCDispatch",

{telegrinder-0.1.dev170 → telegrinder-0.2.0}/telegrinder/bot/bot.py

@@ -1,10 +1,13 @@
 import typing_extensions as typing
 
-from telegrinder.api import API
-from telegrinder.bot.dispatch import ABCDispatch, Dispatch
-from telegrinder.bot.polling import ABCPolling, Polling
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.abc import ABCDispatch
+from telegrinder.bot.dispatch.dispatch import Dispatch
+from telegrinder.bot.polling.abc import ABCPolling
+from telegrinder.bot.polling.polling import Polling
 from telegrinder.modules import logger
-from telegrinder.tools.loop_wrapper import ABCLoopWrapper, LoopWrapper
+from telegrinder.tools.loop_wrapper import ABCLoopWrapper
+from telegrinder.tools.loop_wrapper.loop_wrapper import LoopWrapper
 
 DispatchT = typing.TypeVar("DispatchT", bound=ABCDispatch, default=Dispatch)
 PollingT = typing.TypeVar("PollingT", bound=ABCPolling, default=Polling)
@@ -43,7 +46,12 @@ class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
             return
         await self.api.delete_webhook()
 
-    async def run_polling(self, *, offset: int = 0, skip_updates: bool = False) -> None:
+    async def run_polling(
+        self,
+        *,
+        offset: int = 0,
+        skip_updates: bool = False,
+    ) -> None:
         if skip_updates:
             logger.debug("Dropping pending updates")
             await self.reset_webhook()
@@ -52,7 +60,11 @@ class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
 
         async for updates in self.polling.listen():
             for update in updates:
-                logger.debug("Received update (update_id={})", update.update_id)
+                logger.debug(
+                    "Received update (update_id={}, update_type={!r})",
+                    update.update_id,
+                    update.update_type.name,
+                )
                 self.loop_wrapper.add_task(self.dispatch.feed(update, self.api))
 
     def run_forever(self, *, offset: int = 0, skip_updates: bool = False) -> None:

telegrinder-0.2.0/telegrinder/bot/cute_types/__init__.py

@@ -0,0 +1,17 @@
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
+from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
+from telegrinder.bot.cute_types.inline_query import InlineQueryCute
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.cute_types.update import UpdateCute
+
+__all__ = (
+    "BaseCute",
+    "CallbackQueryCute",
+    "ChatJoinRequestCute",
+    "ChatMemberUpdatedCute",
+    "InlineQueryCute",
+    "MessageCute",
+    "UpdateCute",
+)

telegrinder-0.2.0/telegrinder/bot/cute_types/base.py

@@ -0,0 +1,235 @@
+import dataclasses
+import inspect
+import typing
+from functools import wraps
+
+import typing_extensions
+from fntypes.result import Result
+
+from telegrinder.api.api import API
+from telegrinder.model import Model, get_params
+
+F = typing.TypeVar("F", bound=typing.Callable[..., typing.Any])
+Cute = typing.TypeVar("Cute", bound="BaseCute")
+Update = typing_extensions.TypeVar("Update", bound=Model)
+CtxAPI = typing_extensions.TypeVar("CtxAPI", bound=API, default=API)
+
+Executor: typing.TypeAlias = typing.Callable[
+    [Cute, str, dict[str, typing.Any]],
+    typing.Awaitable[Result[typing.Any, typing.Any]],
+]
+
+if typing.TYPE_CHECKING:
+
+    class BaseCute(Model, typing.Generic[Update, CtxAPI]):
+        api: API
+
+        @classmethod
+        def from_update(cls, update: Update, bound_api: API) -> typing.Self: ...
+
+        @property
+        def ctx_api(self) -> CtxAPI: ...
+
+        def to_dict(
+            self,
+            *,
+            exclude_fields: set[str] | None = None,
+        ) -> dict[str, typing.Any]:
+            """
+            :param exclude_fields: Cute model field names to exclude from the dictionary representation of this cute model.
+            :return: A dictionary representation of this cute model.
+            """
+
+            ...
+
+        def to_full_dict(
+            self,
+            *,
+            exclude_fields: set[str] | None = None,
+        ) -> dict[str, typing.Any]:
+            """
+            :param exclude_fields: Cute model field names to exclude from the dictionary representation of this cute model.
+            :return: A dictionary representation of this model including all models, structs, custom types.
+            """
+
+            ...
+
+else:
+    from fntypes.co import Some, Variative
+
+    from telegrinder.msgspec_utils import Option, decoder
+    from telegrinder.msgspec_utils import get_class_annotations as _get_class_annotations
+
+    def _get_cute_from_args(args):
+        for hint in args:
+            if not isinstance(hint, type):
+                hint = typing.get_origin(hint) or hint
+                if not isinstance(hint, type):
+                    continue
+
+            if hint in (Variative, Some, Option):
+                return _get_cute_from_args(typing.get_args(hint))
+            if issubclass(hint, BaseCute):
+                return hint
+
+        return None
+
+    def _get_cute_annotations(annotations):
+        cute_annotations = {}
+
+        for key, hint in annotations.items():
+            if not isinstance(hint, type):
+                if (val := _get_cute_from_args(typing.get_args(hint))) is not None:
+                    cute_annotations[key] = val
+
+            elif issubclass(hint, BaseCute):
+                cute_annotations[key] = hint
+
+        return cute_annotations
+
+    def _get_value(value):
+        while isinstance(value, Variative | Some):
+            if isinstance(value, Variative):
+                value = value.v
+            if isinstance(value, Some):
+                value = value.value
+        return value
+
+    class BaseCute(typing.Generic[Update, CtxAPI]):
+        def __init_subclass__(cls, *args, **kwargs):
+            super().__init_subclass__(*args, **kwargs)
+
+            if not cls.__bases__ or not issubclass(cls.__bases__[0], BaseCute):
+                return
+
+            cls.__is_solved_annotations__ = False
+            cls.__cute_annotations__ = None
+
+        @classmethod
+        def from_update(cls, update, bound_api):
+            if not cls.__is_solved_annotations__:
+                cls.__is_solved_annotations__ = True
+                cls.__annotations__ = _get_class_annotations(cls)
+
+            if cls.__cute_annotations__ is None:
+                cls.__cute_annotations__ = _get_cute_annotations(cls.__annotations__)
+
+            return cls(
+                **{
+                    field: decoder.convert(
+                        cls.__cute_annotations__[field].from_update(_get_value(value), bound_api=bound_api),
+                        type=cls.__annotations__[field],
+                    )
+                    if field in cls.__cute_annotations__ and value
+                    else value
+                    for field, value in update.to_dict().items()
+                },
+                api=bound_api,
+            )
+
+        @property
+        def ctx_api(self):
+            return self.api
+
+        def to_dict(self, *, exclude_fields=None):
+            exclude_fields = exclude_fields or set()
+            return super().to_dict(exclude_fields={"api"} | exclude_fields)
+
+        def to_full_dict(self, *, exclude_fields=None):
+            exclude_fields = exclude_fields or set()
+            return super().to_full_dict(exclude_fields={"api"} | exclude_fields)
+
+
+def compose_method_params(
+    params: dict[str, typing.Any],
+    update: Cute,
+    *,
+    default_params: set[str | tuple[str, str]] | None = None,
+    validators: dict[str, typing.Callable[[Cute], bool]] | None = None,
+) -> dict[str, typing.Any]:
+    """Compose method `params` from `update` by `default_params` and `validators`.
+
+    :param params: Method params.
+    :param update: Update object.
+    :param default_params: Default params. \
+    (`str`) - Attribute name to be get from `update` if param is undefined. \
+    (`tuple[str, str]`): tuple[0] - Parameter name to be set in `params`, \
+    tuple[1] - attribute name to be get from `update`.
+    :param validators: Validators mapping (`str, Callable`), key - `Parameter name` \
+    for which the validator will be applied, value - `Validator`, if returned `True` \
+    parameter will be set, otherwise will not.
+    :return: Composed params.
+    """
+
+    default_params = default_params or set()
+    validators = validators or {}
+
+    for param in default_params:
+        param_name = param if isinstance(param, str) else param[0]
+        if param_name not in params:
+            if param_name in validators and not validators[param_name](update):
+                continue
+            params[param_name] = getattr(update, param if isinstance(param, str) else param[1])
+
+    return params
+
+
+def shortcut(
+    method_name: str,
+    *,
+    executor: Executor[Cute] | None = None,
+    custom_params: set[str] | None = None,
+):
+    def wrapper(func: F) -> F:
+        @wraps(func)
+        async def inner(
+            self: Cute,
+            *args: typing.Any,
+            **kwargs: typing.Any,
+        ) -> typing.Any:
+            if executor is None:
+                return await func(self, *args, **kwargs)
+
+            if not hasattr(func, "_signature_params"):
+                setattr(
+                    func,
+                    "_signature_params",
+                    {k: p for k, p in inspect.signature(func).parameters.items() if k != "self"},
+                )
+
+            signature_params: dict[str, inspect.Parameter] = getattr(func, "_signature_params")
+            params: dict[str, typing.Any] = {}
+            index = 0
+
+            for k, p in signature_params.items():
+                if p.kind in (p.POSITIONAL_OR_KEYWORD, p.POSITIONAL_ONLY) and len(args) > index:
+                    params[k] = args[index]
+                    index += 1
+                    continue
+
+                if p.kind in (p.VAR_KEYWORD, p.VAR_POSITIONAL):
+                    params[k] = kwargs.copy() if p.kind is p.VAR_KEYWORD else args[index:]
+                    continue
+
+                params[k] = kwargs.pop(k, p.default) if p.default is not p.empty else kwargs.pop(k)
+
+            return await executor(self, method_name, get_params(params))
+
+        inner.__shortcut__ = Shortcut(  # type: ignore
+            method_name=method_name,
+            executor=executor,
+            custom_params=custom_params or set(),
+        )
+        return inner  # type: ignore
+
+    return wrapper
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class Shortcut:
+    method_name: str
+    executor: Executor | None = dataclasses.field(default=None, kw_only=True)
+    custom_params: set[str] = dataclasses.field(default_factory=lambda: set(), kw_only=True)
+
+
+__all__ = ("BaseCute", "Shortcut", "compose_method_params", "shortcut")

{telegrinder-0.1.dev170 → telegrinder-0.2.0}/telegrinder/bot/cute_types/callback_query.py

@@ -4,12 +4,15 @@ from contextlib import suppress
 import msgspec
 from fntypes.co import Nothing, Result, Some, Variative, unwrapping
 
-from telegrinder.api import ABCAPI, APIError
+from telegrinder.api import API, APIError
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
+from telegrinder.bot.cute_types.message import MediaType, MessageCute, ReplyMarkup, execute_method_edit
 from telegrinder.model import get_params
 from telegrinder.msgspec_utils import Option, decoder
-from telegrinder.types import (
+from telegrinder.types.objects import (
     CallbackQuery,
     Chat,
+    InaccessibleMessage,
     InlineKeyboardMarkup,
     InputFile,
     InputMedia,
@@ -20,12 +23,13 @@ from telegrinder.types import (
     User,
 )
 
-from .base import BaseCute, compose_method_params, shortcut
-from .message import MediaType, MessageCute, ReplyMarkup, execute_method_edit
 
+class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True):
+    api: API
 
-class CallbackQueryCute(BaseCute[CallbackQuery], CallbackQuery, kw_only=True, dict=True):
-    api: ABCAPI
+    message: Option[Variative[MessageCute, InaccessibleMessage]] = Nothing()
+    """Optional. Message sent by the bot with the callback button that originated
+    the query."""
 
     @property
     def from_user(self) -> User:

{telegrinder-0.1.dev170 → telegrinder-0.2.0}/telegrinder/bot/cute_types/chat_join_request.py

@@ -2,15 +2,14 @@ import typing
 
 from fntypes.result import Result
 
-from telegrinder.api.abc import ABCAPI, APIError
+from telegrinder.api import API, APIError
+from telegrinder.bot.cute_types.base import BaseCute, shortcut
+from telegrinder.bot.cute_types.chat_member_updated import ChatMemberShortcuts, chat_member_interaction
 from telegrinder.types.objects import ChatJoinRequest, User
 
-from .base import BaseCute, shortcut
-from .chat_member_updated import ChatMemberShortcuts, chat_member_interaction
-
 
 class ChatJoinRequestCute(BaseCute[ChatJoinRequest], ChatJoinRequest, ChatMemberShortcuts, kw_only=True):
-    api: ABCAPI
+    api: API
 
     @property
     def from_user(self) -> User:

{telegrinder-0.1.dev170 → telegrinder-0.2.0}/telegrinder/bot/cute_types/chat_member_updated.py

@@ -3,13 +3,11 @@ from datetime import datetime
 
 from fntypes.result import Result
 
-from telegrinder.api import ABCAPI, APIError
+from telegrinder.api import API, APIError
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
 from telegrinder.model import get_params
 from telegrinder.types.objects import ChatMemberUpdated, ChatPermissions, User
 
-from .base import BaseCute, compose_method_params, shortcut
-from .utils import compose_chat_permissions
-
 
 async def chat_member_interaction(
     update: BaseCute[typing.Any],
@@ -17,7 +15,7 @@ async def chat_member_interaction(
     params: dict[str, typing.Any],
 ) -> Result[typing.Any, APIError]:
     if isinstance(params.get("permissions"), dict):
-        params["permissions"] = compose_chat_permissions(**params["permissions"])
+        params["permissions"] = ChatPermissions(**params["permissions"])
     params = compose_method_params(
         get_params(locals()),
         update,
@@ -235,7 +233,7 @@ class ChatMemberShortcuts:
 class ChatMemberUpdatedCute(
     BaseCute[ChatMemberUpdated], ChatMemberUpdated, ChatMemberShortcuts, kw_only=True
 ):
-    api: ABCAPI
+    api: API
 
     @property
     def from_user(self) -> User:

{telegrinder-0.1.dev170 → telegrinder-0.2.0}/telegrinder/bot/cute_types/inline_query.py

@@ -2,7 +2,8 @@ import typing
 
 from fntypes.result import Result
 
-from telegrinder.api import ABCAPI, APIError
+from telegrinder.api import API, APIError
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
 from telegrinder.model import get_params
 from telegrinder.types import (
     InlineQuery,
@@ -11,11 +12,9 @@ from telegrinder.types import (
     User,
 )
 
-from .base import BaseCute, compose_method_params, shortcut
-
 
 class InlineQueryCute(BaseCute[InlineQuery], InlineQuery, kw_only=True):
-    api: ABCAPI
+    api: API
 
     @property
     def from_user(self) -> User: