telegrinder 0.1.dev20__tar.gz → 0.1.dev159__tar.gz

{telegrinder-0.1.dev20 → telegrinder-0.1.dev159}/LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
-Copyright (c) 2022 timoniq
+Copyright (c) 2022-2024 timoniq
+Copyright (c) 2024 luwqz1
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

telegrinder-0.1.dev159/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.1
+Name: telegrinder
+Version: 0.1.dev159
+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
+Author: timoniq
+Author-email: tesseradecades@mail.ru
+Maintainer: luwqz1
+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.11
+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 (>=2023.7.22,<2024.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: requests (>=2.28.1,<3.0.0)
+Requires-Dist: typing-extensions (>=4.8.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
+
+# Telegrinder
+
+Framework for effective and reliable telegram bot building.
+
+Still in development.
+
+* Type hinted
+* Customizable and extensible
+* Ready to use scenarios and rules
+* Fast models built on msgspec
+* Both low-level and high-level API
+
+# Getting started
+
+Install using pip:
+
+```
+pip install telegrinder
+```
+
+Using poetry:
+
+```
+poetry add telegrinder
+```
+
+Install from github:
+
+```
+pip install -U https://github.com/timoniq/telegrinder/archive/dev.zip
+```
+
+```
+poetry add git+https://github.com/timoniq/telegrinder.git#dev
+```
+
+Basic example:
+
+```python
+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)
+
+
+@bot.on.message(Text("/start"))
+async def start(message: Message):
+    me = (await api.get_me()).unwrap()
+    await message.answer(
+        f"Hello, {message.from_user.full_name}! I'm {me.full_name}."
+    )
+
+
+bot.run_forever()
+```
+
+# Documentation
+
+[Readthedocs](https://telegrinder.readthedocs.io)
+
+# Community
+
+Join our [telegram forum](https://t.me/botoforum).
+
+# [Contributing](https://github.com/timoniq/telegrinder/blob/main/contributing.md)
+
+# License
+
+Telegrinder is [MIT licensed](./LICENSE)  
+Copyright © 2022-2024 [timoniq](https://github.com/timoniq)\
+Copyright © 2024 [luwqz1](https://github.com/luwqz1)
+

telegrinder-0.1.dev159/pyproject.toml

@@ -0,0 +1,73 @@
+[tool.poetry]
+name = "telegrinder"
+version = "0.1.dev159"
+description = "Framework for effective and reliable async telegram bot building."
+authors = ["timoniq <tesseradecades@mail.ru>"]
+maintainers = ["luwqz1"]
+license = "MIT"
+readme = "readme.md"
+homepage = "https://github.com/timoniq/telegrinder"
+repository = "https://github.com/timoniq/telegrinder"
+keywords = [
+  "telegram",
+  "telegram bot api framework",
+  "telegrinder",
+  "asyncio",
+  "middleware",
+  "composition",
+  "bot api",
+  "async",
+]
+classifiers = [
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3.11",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Topic :: Software Development :: Quality Assurance",
+  "Typing :: Typed",
+]
+
+[tool.poetry.dependencies]
+python = "^3.11"
+aiohttp = "^3.8.1"
+colorama = "^0.4.0"
+vbml = "^1.1.post1"
+choicelib = "^0.1.5"
+envparse = "^0.2.0"
+PyYAML = "^6.0"
+certifi = "^2023.7.22"
+msgspec = "^0.18.4"
+requests = "^2.28.1"
+typing-extensions = "^4.8.0"
+fntypes = "^0.1.1"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0.0"
+pytest-asyncio = "^0.23.5"
+pytest-cov = "^4.0.0"
+pytest-mock = "^3.10.0"
+
+[tool.poetry.dev-dependencies]
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+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"
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.ruff.per-file-ignores]
+"__init__.py" = ["F401", "F403"]
+
+[tool.ruff.flake8-quotes]
+docstring-quotes = "double"

telegrinder-0.1.dev159/readme.md

@@ -0,0 +1,74 @@
+# Telegrinder
+
+Framework for effective and reliable telegram bot building.
+
+Still in development.
+
+* Type hinted
+* Customizable and extensible
+* Ready to use scenarios and rules
+* Fast models built on msgspec
+* Both low-level and high-level API
+
+# Getting started
+
+Install using pip:
+
+```
+pip install telegrinder
+```
+
+Using poetry:
+
+```
+poetry add telegrinder
+```
+
+Install from github:
+
+```
+pip install -U https://github.com/timoniq/telegrinder/archive/dev.zip
+```
+
+```
+poetry add git+https://github.com/timoniq/telegrinder.git#dev
+```
+
+Basic example:
+
+```python
+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)
+
+
+@bot.on.message(Text("/start"))
+async def start(message: Message):
+    me = (await api.get_me()).unwrap()
+    await message.answer(
+        f"Hello, {message.from_user.full_name}! I'm {me.full_name}."
+    )
+
+
+bot.run_forever()
+```
+
+# Documentation
+
+[Readthedocs](https://telegrinder.readthedocs.io)
+
+# Community
+
+Join our [telegram forum](https://t.me/botoforum).
+
+# [Contributing](https://github.com/timoniq/telegrinder/blob/main/contributing.md)
+
+# License
+
+Telegrinder is [MIT licensed](./LICENSE)  
+Copyright © 2022-2024 [timoniq](https://github.com/timoniq)\
+Copyright © 2024 [luwqz1](https://github.com/luwqz1)

telegrinder-0.1.dev159/telegrinder/__init__.py

@@ -0,0 +1,146 @@
+import typing
+
+from .api import ABCAPI, API, APIError, APIResponse, Token
+from .bot import (
+    ABCDispatch,
+    ABCHandler,
+    ABCMiddleware,
+    ABCPolling,
+    ABCReturnManager,
+    ABCRule,
+    ABCScenario,
+    ABCStateView,
+    ABCView,
+    BaseCute,
+    BaseReturnManager,
+    BaseStateView,
+    BaseView,
+    CallbackQueryCute,
+    CallbackQueryReturnManager,
+    CallbackQueryView,
+    Checkbox,
+    Dispatch,
+    FuncHandler,
+    InlineQueryCute,
+    InlineQueryReturnManager,
+    MessageCute,
+    MessageReplyHandler,
+    MessageReturnManager,
+    MessageRule,
+    MessageView,
+    Polling,
+    SingleChoice,
+    Telegrinder,
+    ViewBox,
+    WaiterMachine,
+    register_manager,
+)
+from .client import ABCClient, AiohttpClient
+from .model import Model
+from .modules import logger
+from .tools import (
+    ABCGlobalContext,
+    ABCLoopWrapper,
+    ABCTranslator,
+    ABCTranslatorMiddleware,
+    AnyMarkup,
+    Button,
+    CtxVar,
+    DelayedTask,
+    FormatString,
+    GlobalContext,
+    HTMLFormatter,
+    I18nEnum,
+    InlineButton,
+    InlineKeyboard,
+    Keyboard,
+    KeyboardSetBase,
+    KeyboardSetYAML,
+    LoopWrapper,
+    ParseMode,
+    RowButtons,
+    SimpleI18n,
+    SimpleTranslator,
+    ctx_var,
+    keyboard_remove,
+    magic_bundle,
+)
+
+Message: typing.TypeAlias = MessageCute
+CallbackQuery: typing.TypeAlias = CallbackQueryCute
+InlineQuery: typing.TypeAlias = InlineQueryCute
+Bot: typing.TypeAlias = Telegrinder
+
+
+__all__ = (
+    "ABCAPI",
+    "ABCClient",
+    "ABCDispatch",
+    "ABCGlobalContext",
+    "ABCHandler",
+    "ABCLoopWrapper",
+    "ABCMiddleware",
+    "ABCPolling",
+    "ABCReturnManager",
+    "ABCRule",
+    "ABCScenario",
+    "ABCStateView",
+    "ABCTranslator",
+    "ABCTranslatorMiddleware",
+    "ABCView",
+    "API",
+    "APIError",
+    "APIResponse",
+    "AiohttpClient",
+    "AnyMarkup",
+    "BaseCute",
+    "BaseReturnManager",
+    "BaseStateView",
+    "BaseView",
+    "Bot",
+    "Button",
+    "CallbackQuery",
+    "CallbackQueryCute",
+    "CallbackQueryReturnManager",
+    "CallbackQueryView",
+    "Checkbox",
+    "CtxVar",
+    "DelayedTask",
+    "Dispatch",
+    "FormatString",
+    "FuncHandler",
+    "GlobalContext",
+    "HTMLFormatter",
+    "I18nEnum",
+    "InlineButton",
+    "InlineKeyboard",
+    "InlineQuery",
+    "InlineQueryCute",
+    "InlineQueryReturnManager",
+    "Keyboard",
+    "KeyboardSetBase",
+    "KeyboardSetYAML",
+    "LoopWrapper",
+    "Message",
+    "MessageCute",
+    "MessageReplyHandler",
+    "MessageReturnManager",
+    "MessageRule",
+    "MessageView",
+    "Model",
+    "ParseMode",
+    "Polling",
+    "RowButtons",
+    "SimpleI18n",
+    "SimpleTranslator",
+    "SingleChoice",
+    "Telegrinder",
+    "Token",
+    "ViewBox",
+    "WaiterMachine",
+    "ctx_var",
+    "keyboard_remove",
+    "logger",
+    "magic_bundle",
+    "register_manager",
+)

telegrinder-0.1.dev159/telegrinder/api/__init__.py

@@ -0,0 +1,13 @@
+from .abc import ABCAPI, Token
+from .api import API
+from .error import APIError, InvalidTokenError
+from .response import APIResponse
+
+__all__ = (
+    "ABCAPI",
+    "API",
+    "APIError",
+    "APIResponse",
+    "InvalidTokenError",
+    "Token",
+)

telegrinder-0.1.dev159/telegrinder/api/abc.py

@@ -0,0 +1,68 @@
+import pathlib
+import typing
+from abc import ABC, abstractmethod
+
+import msgspec
+from envparse import env
+from fntypes.result import Result
+
+from telegrinder.api.error import APIError
+from telegrinder.client import ABCClient
+
+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)
+
+    @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))
+
+    @property
+    def bot_id(self) -> int:
+        return int(self.split(":")[0])
+
+
+class ABCAPI(ABC):
+    http: ABCClient
+
+    @abstractmethod
+    async def request(
+        self,
+        method: str,
+        data: dict[str, typing.Any] | None = None,
+    ) -> Result[list[typing.Any] | dict[str, typing.Any] | bool, APIError]:
+        pass
+
+    @abstractmethod
+    async def request_raw(
+        self,
+        method: str,
+        data: dict[str, typing.Any] | None = None,
+    ) -> Result[msgspec.Raw, APIError]:
+        pass
+
+    @property
+    @abstractmethod
+    def request_url(self) -> str:
+        pass
+
+    @property
+    @abstractmethod
+    def id(self) -> int:
+        pass
+
+
+__all__ = ("ABCAPI", "Token")

telegrinder-0.1.dev159/telegrinder/api/api.py

@@ -0,0 +1,80 @@
+import typing
+
+import msgspec
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.response import APIResponse
+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)
+    return client.get_form(
+        data={k: converter.convert(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) -> 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:
+        return self.token.bot_id
+
+    @property
+    def request_url(self) -> str:
+        return self.API_URL + f"bot{self.token}/"
+
+    async def request(
+        self,
+        method: str,
+        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 {}, files or {})
+        )
+        if response.get("ok"):
+            assert "result" in response
+            return Ok(response["result"])
+        return Error(APIError(
+            code=response.get("error_code", 0),
+            error=response.get("description"),
+        ))
+
+    async def request_raw(
+        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 {}, files or {}),
+        )
+        return decoder.decode(response_bytes, type=APIResponse).to_result()
+
+
+__all__ = ("API",)

telegrinder-0.1.dev159/telegrinder/api/error.py

@@ -0,0 +1,16 @@
+class APIError(BaseException):
+    def __init__(self, code: int, error: str | None = None):
+        self.code, self.error = code, error
+    
+    def __str__(self) -> str:
+        return f"[{self.code}] {self.error}"
+
+    def __repr__(self) -> str:
+        return f"<APIError {self.__str__()}>"
+
+
+class InvalidTokenError(BaseException):
+    ...
+
+
+__all__ = ("APIError", "InvalidTokenError")

{telegrinder-0.1.dev20 → telegrinder-0.1.dev159}/telegrinder/api/response.py

@@ -1,16 +1,20 @@
-from telegrinder.model import Model
-from telegrinder.result import Result
-from telegrinder.api.error import APIError
 import msgspec
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.error import APIError
+from telegrinder.model import Model
 
 
 class APIResponse(Model):
-    ok: bool
-    result: msgspec.Raw = b""
+    ok: bool = False
+    result: msgspec.Raw = msgspec.Raw(b"")
     error_code: int = 0
     description: str = ""
 
     def to_result(self) -> Result[msgspec.Raw, APIError]:
         if self.ok:
-            return Result(True, value=self.result)
-        return Result(False, error=APIError(self.error_code, self.description))
+            return Ok(self.result)
+        return Error(APIError(self.error_code, self.description))
+
+
+__all__ = ("APIResponse",)

telegrinder-0.1.dev159/telegrinder/bot/__init__.py

@@ -0,0 +1,76 @@
+from .bot import Telegrinder
+from .cute_types import (
+    BaseCute,
+    CallbackQueryCute,
+    InlineQueryCute,
+    MessageCute,
+    UpdateCute,
+)
+from .dispatch import (
+    ABCDispatch,
+    ABCHandler,
+    ABCMiddleware,
+    ABCReturnManager,
+    ABCStateView,
+    ABCView,
+    BaseReturnManager,
+    BaseStateView,
+    BaseView,
+    CallbackQueryReturnManager,
+    CallbackQueryView,
+    CompositionDispatch,
+    Context,
+    Dispatch,
+    FuncHandler,
+    InlineQueryReturnManager,
+    Manager,
+    MessageReplyHandler,
+    MessageReturnManager,
+    MessageView,
+    ViewBox,
+    WaiterMachine,
+    register_manager,
+)
+from .polling import ABCPolling, Polling
+from .rules import ABCRule, CallbackQueryRule, MessageRule
+from .scenario import ABCScenario, Checkbox, SingleChoice
+
+__all__ = (
+    "ABCDispatch",
+    "ABCHandler",
+    "ABCMiddleware",
+    "ABCPolling",
+    "ABCReturnManager",
+    "ABCRule",
+    "ABCScenario",
+    "ABCStateView",
+    "ABCView",
+    "BaseCute",
+    "BaseReturnManager",
+    "BaseStateView",
+    "BaseView",
+    "CallbackQueryCute",
+    "CallbackQueryReturnManager",
+    "CallbackQueryRule",
+    "CallbackQueryView",
+    "Checkbox",
+    "CompositionDispatch",
+    "Context",
+    "Dispatch",
+    "FuncHandler",
+    "InlineQueryCute",
+    "InlineQueryReturnManager",
+    "Manager",
+    "MessageCute",
+    "MessageReplyHandler",
+    "MessageReturnManager",
+    "MessageRule",
+    "MessageView",
+    "Polling",
+    "SingleChoice",
+    "Telegrinder",
+    "UpdateCute",
+    "ViewBox",
+    "WaiterMachine",
+    "register_manager",
+)