telegrinder 0.1.dev158__tar.gz → 0.1.dev160__tar.gz

{telegrinder-0.1.dev158 → telegrinder-0.1.dev160}/PKG-INFO

@@ -1,32 +1,34 @@
 Metadata-Version: 2.1
 Name: telegrinder
-Version: 0.1.dev158
+Version: 0.1.dev160
 Summary: Framework for effective and reliable async telegram bot building.
 Home-page: https://github.com/timoniq/telegrinder
 License: MIT
-Keywords: telegram,telegram bot api framework,telegrinder,asyncio,middleware,composition,bot api,async
+Keywords: asyncio,api schema,async,bot building,bot api,custom rules,telegram,telegram bot api framework,telegrinder,middleware,composition
 Author: timoniq
 Author-email: tesseradecades@mail.ru
 Maintainer: luwqz1
+Maintainer-email: howluwqz1@gmail.com
 Requires-Python: >=3.11,<4.0
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Typing :: Typed
 Requires-Dist: PyYAML (>=6.0,<7.0)
 Requires-Dist: aiohttp (>=3.8.1,<4.0.0)
-Requires-Dist: certifi (>=2022.6.15,<2023.0.0)
+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.1,<0.2.0)
-Requires-Dist: msgspec (>=0.18.4,<0.19.0)
+Requires-Dist: fntypes (>=0.1.2.post1,<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.8.0,<5.0.0)
+Requires-Dist: typing-extensions (>=4.10.0,<5.0.0)
 Requires-Dist: vbml (>=1.1.post1,<2.0)
 Project-URL: Repository, https://github.com/timoniq/telegrinder
 Description-Content-Type: text/markdown
@@ -74,9 +76,9 @@ from telegrinder import API, Message, Telegrinder, Token
 from telegrinder.modules import logger
 from telegrinder.rules import Text
 
-logger.set_level("INFO")
 api = API(token=Token("123:token"))
 bot = Telegrinder(api)
+logger.set_level("INFO")
 
 
 @bot.on.message(Text("/start"))

{telegrinder-0.1.dev158 → telegrinder-0.1.dev160}/pyproject.toml

@@ -1,22 +1,25 @@
 [tool.poetry]
 name = "telegrinder"
-version = "0.1.dev158"
+version = "0.1.dev160"
 description = "Framework for effective and reliable async telegram bot building."
 authors = ["timoniq <tesseradecades@mail.ru>"]
-maintainers = ["luwqz1"]
+maintainers = ["luwqz1 <howluwqz1@gmail.com>"]
 license = "MIT"
 readme = "readme.md"
 homepage = "https://github.com/timoniq/telegrinder"
 repository = "https://github.com/timoniq/telegrinder"
 keywords = [
+  "asyncio",
+  "api schema",
+  "async",
+  "bot building",
+  "bot api",
+  "custom rules",
   "telegram",
   "telegram bot api framework",
   "telegrinder",
-  "asyncio",
   "middleware",
   "composition",
-  "bot api",
-  "async",
 ]
 classifiers = [
   "Environment :: Console",
@@ -36,11 +39,11 @@ vbml = "^1.1.post1"
 choicelib = "^0.1.5"
 envparse = "^0.2.0"
 PyYAML = "^6.0"
-certifi = "^2022.6.15"
-msgspec = "^0.18.4"
+certifi = "^2024.2.2"
+msgspec = "^0.18.6"
 requests = "^2.28.1"
-typing-extensions = "^4.8.0"
-fntypes = "^0.1.1"
+typing-extensions = "^4.10.0"
+fntypes = "^0.1.2.post1"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.0.0"
@@ -59,10 +62,14 @@ line-length = 100
 target-version = "py311"
 select = ["I", "N", "ANN", "COM", "YTT", "TCH", "SIM"]
 ignore = [
-    "ANN001", "ANN002", "ANN003", "ANN101", "ANN102", "ANN201", "ANN202",
-    "ANN204", "ANN206", "ANN401", "COM812", "N818", "TCH001", "TCH004"
+  "ANN001", "ANN002", "ANN003", "ANN101", "ANN102", "ANN201", "ANN202",
+  "ANN204", "ANN206", "ANN401", "COM812", "N818", "TCH001", "TCH004"
 ]
 
+[tool.black]
+line-length = 90
+target-version = ["py311"]
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 

{telegrinder-0.1.dev158 → telegrinder-0.1.dev160}/readme.md

@@ -41,9 +41,9 @@ from telegrinder import API, Message, Telegrinder, Token
 from telegrinder.modules import logger
 from telegrinder.rules import Text
 
-logger.set_level("INFO")
 api = API(token=Token("123:token"))
 bot = Telegrinder(api)
+logger.set_level("INFO")
 
 
 @bot.on.message(Text("/start"))

{telegrinder-0.1.dev158 → telegrinder-0.1.dev160}/telegrinder/__init__.py

@@ -39,6 +39,7 @@ from .client import ABCClient, AiohttpClient
 from .model import Model
 from .modules import logger
 from .tools import (
+    ABCErrorHandler,
     ABCGlobalContext,
     ABCLoopWrapper,
     ABCTranslator,
@@ -47,6 +48,7 @@ from .tools import (
     Button,
     CtxVar,
     DelayedTask,
+    ErrorHandler,
     FormatString,
     GlobalContext,
     HTMLFormatter,
@@ -62,7 +64,6 @@ from .tools import (
     SimpleI18n,
     SimpleTranslator,
     ctx_var,
-    keyboard_remove,
     magic_bundle,
 )
 
@@ -76,6 +77,7 @@ __all__ = (
     "ABCAPI",
     "ABCClient",
     "ABCDispatch",
+    "ABCErrorHandler",
     "ABCGlobalContext",
     "ABCHandler",
     "ABCLoopWrapper",
@@ -107,6 +109,7 @@ __all__ = (
     "CtxVar",
     "DelayedTask",
     "Dispatch",
+    "ErrorHandler",
     "FormatString",
     "FuncHandler",
     "GlobalContext",
@@ -139,7 +142,6 @@ __all__ = (
     "ViewBox",
     "WaiterMachine",
     "ctx_var",
-    "keyboard_remove",
     "logger",
     "magic_bundle",
     "register_manager",

{telegrinder-0.1.dev158 → telegrinder-0.1.dev160}/telegrinder/api/abc.py

@@ -15,7 +15,7 @@ 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:token'.")
+            raise InvalidTokenError("Invalid token, it should look like this '123:ABC'.")
         return super().__new__(cls, token)
 
     @classmethod
@@ -42,15 +42,17 @@ class ABCAPI(ABC):
     async def request(
         self,
         method: str,
-        data: dict | None = None,
-    ) -> Result[list | dict | bool, APIError]:
+        data: dict[str, typing.Any] | None = None,
+        files: dict[str, tuple[str, bytes]] | None = None,
+    ) -> Result[list[typing.Any] | dict[str, typing.Any] | bool, APIError]:
         pass
 
     @abstractmethod
     async def request_raw(
         self,
         method: str,
-        data: dict | None = None,
+        data: dict[str, typing.Any] | None = None,
+        files: dict[str, tuple[str, bytes]] | None = None,
     ) -> Result[msgspec.Raw, APIError]:
         pass
 

{telegrinder-0.1.dev158 → telegrinder-0.1.dev160}/telegrinder/api/api.py

@@ -5,26 +5,38 @@ from fntypes.result import Error, Ok, Result
 
 from telegrinder.api.response import APIResponse
 from telegrinder.client import ABCClient, AiohttpClient
-from telegrinder.model import convert, decoder
+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]) -> typing.Any:
-    data = {k: convert(v) for k, v in data.items()}
-    if any(isinstance(v, tuple) for v in data.values()):
-        data = client.get_form(data)
-    return data
+def compose_data(
+    client: ABCClient,
+    data: dict[str, typing.Any],
+    files: dict[str, tuple[str, bytes]],
+) -> typing.Any:
+    converter = DataConverter(files=files)
+    return client.get_form(
+        data={k: converter(v) for k, v in data.items()},
+        files=converter.files,
+    )
 
 
 class API(ABCAPI, APIMethods):
     API_URL: typing.ClassVar[str] = "https://api.telegram.org/"
 
-    def __init__(self, token: Token, *, http: ABCClient | None = None):
+    def __init__(self, token: Token, *, http: ABCClient | None = None) -> None:
         self.token = token
         self.http = http or AiohttpClient()
         super().__init__(self)
+    
+    def __repr__(self) -> str:
+        return "<{}: id={}, http={!r}>".format(
+            self.__class__.__name__,
+            self.id,
+            self.http,
+        )
 
     @property
     def id(self) -> int:
@@ -37,11 +49,12 @@ class API(ABCAPI, APIMethods):
     async def request(
         self,
         method: str,
-        data: dict | None = None,
-    ) -> Result[dict | list | bool, APIError]:
+        data: dict[str, typing.Any] | None = None,
+        files: dict[str, tuple[str, bytes]] | None = None,
+    ) -> Result[dict[str, typing.Any] | list[typing.Any] | bool, APIError]:
         response = await self.http.request_json(
             url=self.request_url + method,
-            data=compose_data(self.http, data or {})
+            data=compose_data(self.http, data or {}, files or {})
         )
         if response.get("ok"):
             assert "result" in response
@@ -55,10 +68,11 @@ class API(ABCAPI, APIMethods):
         self,
         method: str,
         data: dict[str, typing.Any] | None = None,
+        files: dict[str, tuple[str, bytes]] | None = None,
     ) -> Result[msgspec.Raw, APIError]:
         response_bytes = await self.http.request_bytes(
             url=self.request_url + method,
-            data=compose_data(self.http, data or {}),
+            data=compose_data(self.http, data or {}, files or {}),
         )
         return decoder.decode(response_bytes, type=APIResponse).to_result()
 

telegrinder-0.1.dev160/telegrinder/bot/cute_types/base.py

@@ -0,0 +1,138 @@
+import dataclasses
+import inspect
+import typing
+from functools import wraps
+
+from fntypes.result import Result
+
+from telegrinder.api import ABCAPI, API
+from telegrinder.model import Model, get_params
+
+F = typing.TypeVar("F", bound=typing.Callable[..., typing.Any])
+CuteT = typing.TypeVar("CuteT", bound="BaseCute")
+UpdateT = typing.TypeVar("UpdateT", bound=Model)
+
+Executor: typing.TypeAlias = typing.Callable[
+    [CuteT, str, dict[str, typing.Any]],
+    typing.Awaitable[Result[typing.Any, typing.Any]],
+]
+
+if typing.TYPE_CHECKING:
+
+    class BaseCute(Model, typing.Generic[UpdateT]):
+        api: ABCAPI
+
+        @classmethod
+        def from_update(cls, update: UpdateT, bound_api: ABCAPI) -> typing.Self:
+            ...
+
+        @property
+        def ctx_api(self) -> API:
+            ...
+
+else:
+
+    class BaseCute(typing.Generic[UpdateT]):
+        api: ABCAPI
+
+        @classmethod
+        def from_update(cls, update, bound_api):
+            return cls(**update.to_dict(), api=bound_api)
+
+        @property
+        def ctx_api(self):
+            assert isinstance(self.api, API)
+            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 compose_method_params(
+    params: dict[str, typing.Any],
+    update: CuteT,
+    *,
+    default_params: set[str | tuple[str, str]] | None = None,
+    validators: dict[str, typing.Callable[[CuteT], 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. \
+    type (`str`) - Attribute name to be taken from `update` if param undefined. \
+    type (`tuple[str, str]`) - tuple[0] Parameter name to be set in `params`, \
+    tuple[1] attribute name to be taken 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 be set.
+    :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
+
+
+# NOTE: implement parser on ast for methods decorated this decorator
+# to support updates to the schema Bot API.
+def shortcut(
+    method_name: str,
+    *,
+    executor: Executor[CuteT] | None = None,
+    custom_params: set[str] | None = None,
+):
+    def wrapper(func: F) -> F:
+        @wraps(func)
+        async def inner(self: CuteT, *args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+            if executor is None:
+                return await func(self, *args, **kwargs)
+            signature_params = {
+                k: p
+                for k, p in inspect.signature(func).parameters.items()
+                if k != "self"
+            }
+            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))
+
+        func.__repr__ = lambda _: f"<Shortcut {method_name!r}@{func!r}>"   
+        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
+class Shortcut:
+    method_name: str
+    _: dataclasses.KW_ONLY
+    executor: Executor | None = dataclasses.field(default=None)
+    custom_params: set[str] = dataclasses.field(default_factory=lambda: set())
+
+
+__all__ = ("BaseCute", "Shortcut", "compose_method_params", "shortcut")