telegrinder 0.1.dev11__tar.gz → 0.1.dev14__tar.gz

{telegrinder-0.1.dev11 → telegrinder-0.1.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telegrinder
-Version: 0.1.dev11
+Version: 0.1.dev14
 Summary: async telegram bot building
 License: MIT
 Author: timoniq

{telegrinder-0.1.dev11 → telegrinder-0.1.dev14}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "telegrinder"
-version = "0.1.dev11"
+version = "0.1.dev14"
 description = "async telegram bot building"
 authors = ["timoniq <tesseradecades@mail.ru>"]
 license = "MIT"

{telegrinder-0.1.dev11 → telegrinder-0.1.dev14}/setup.py

@@ -35,7 +35,7 @@ install_requires = \
 
 setup_kwargs = {
     'name': 'telegrinder',
-    'version': '0.1.dev11',
+    'version': '0.1.dev14',
     'description': 'async telegram bot building',
     'long_description': 'None',
     'author': 'timoniq',

{telegrinder-0.1.dev11 → telegrinder-0.1.dev14}/telegrinder/__init__.py

@@ -19,6 +19,7 @@ from .bot import (
     ABCMiddleware,
     ABCScenario,
     Checkbox,
+    SingleChoice,
 )
 from .tools import (
     Keyboard,

{telegrinder-0.1.dev11 → telegrinder-0.1.dev14}/telegrinder/api/abc.py

@@ -17,6 +17,10 @@ class Token(str):
             env.read_envfile()
         return cls(env.str(var_name))
 
+    @property
+    def bot_id(self) -> int:
+        return int(self.split(":")[0])
+
 
 class ABCAPI(ABC):
     http: ABCClient

{telegrinder-0.1.dev11 → telegrinder-0.1.dev14}/telegrinder/bot/__init__.py

@@ -12,4 +12,4 @@ from .dispatch import (
 from .bot import Telegrinder
 from .cute_types import MessageCute, CallbackQueryCute, InlineQueryCute
 from .rules import ABCRule, ABCMessageRule
-from .scenario import ABCScenario, Checkbox
+from .scenario import ABCScenario, Checkbox, SingleChoice

{telegrinder-0.1.dev11 → telegrinder-0.1.dev14}/telegrinder/bot/cute_types/callback_query.py

@@ -1,6 +1,6 @@
 from telegrinder.types import CallbackQuery, User
-from telegrinder.types.methods import APIMethods
-from telegrinder.api import API, APIError, Token
+from telegrinder.model import get_params
+from telegrinder.api import API, APIError
 from telegrinder.result import Result
 import typing
 
@@ -24,5 +24,5 @@ class CallbackQueryCute(CallbackQuery):
         cache_time: typing.Optional[int] = None,
         **other
     ) -> Result[bool, APIError]:
-        params = APIMethods.get_params(locals())
+        params = get_params(locals())
         return await self.ctx_api.answer_callback_query(self.id, **params)

{telegrinder-0.1.dev11 → telegrinder-0.1.dev14}/telegrinder/bot/cute_types/message.py

@@ -6,8 +6,8 @@ from telegrinder.types import (
     ReplyKeyboardRemove,
     ForceReply,
 )
-from telegrinder.types.methods import APIMethods
-from telegrinder.api import API, APIError, Token
+from telegrinder.model import get_params
+from telegrinder.api import API, APIError
 from telegrinder.result import Result
 import typing
 
@@ -39,7 +39,9 @@ class MessageCute(Message):
         ] = None,
         **other
     ) -> Result["Message", APIError]:
-        params = APIMethods.get_params(locals())
+        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 reply(
@@ -61,7 +63,11 @@ class MessageCute(Message):
         ] = None,
         **other
     ) -> Result["Message", APIError]:
-        params = APIMethods.get_params(locals())
+        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, reply_to_message_id=self.message_id, **params
+            chat_id=self.chat.id,
+            reply_to_message_id=self.message_id,
+            **params
         )

{telegrinder-0.1.dev11 → telegrinder-0.1.dev14}/telegrinder/bot/dispatch/handler/func.py

@@ -5,6 +5,7 @@ from telegrinder.tools import magic_bundle
 from telegrinder.types import Update
 from telegrinder.api.abc import ABCAPI
 from .abc import ABCHandler
+from telegrinder.modules import logger
 
 T = typing.TypeVar("T")
 
@@ -38,6 +39,7 @@ class FuncHandler(ABCHandler, typing.Generic[T]):
                     api=api,
                 )
             if not await rule.run_check(e, self.ctx):
+                logger.debug("Rule {} failed", rule)
                 return False
         return True
 

{telegrinder-0.1.dev11 → telegrinder-0.1.dev14}/telegrinder/bot/rules/abc.py

@@ -29,7 +29,7 @@ class ABCRule(ABC, typing.Generic[T]):
     async def check(self, event: T, ctx: dict) -> bool:
         pass
 
-    def __init_subclass__(cls, require: typing.List["ABCRule[T]"] = None):
+    def __init_subclass__(cls, require: typing.Optional[typing.List["ABCRule[T]"]] = None):
         """Merges requirements from inherited classes and rule-specific requirements"""
         requirements = []
         for base in inspect.getmro(cls):

{telegrinder-0.1.dev11 → telegrinder-0.1.dev14}/telegrinder/bot/scenario/__init__.py

@@ -1,2 +1,3 @@
 from .abc import ABCScenario
 from .checkbox import Checkbox
+from .choice import SingleChoice

{telegrinder-0.1.dev11 → telegrinder-0.1.dev14}/telegrinder/bot/scenario/checkbox.py

@@ -35,13 +35,11 @@ class Checkbox(ABCScenario):
         self,
         chat_id: int,
         msg: str,
-        multiple_choice: bool = True,
         ready_text: str = "Ready",
         max_in_row: int = 3,
     ):
         self.chat_id = chat_id
         self.msg = msg
-        self.multiple_choice = multiple_choice
         self.choices: typing.List[Choice] = []
         self.ready = ready_text
         self.max_in_row = max_in_row
@@ -100,7 +98,7 @@ class Checkbox(ABCScenario):
         assert len(self.choices) > 1
         message = (
             await api.send_message(
-                self.chat_id, self.msg, self.PARSE_MODE, reply_markup=self.get_markup()
+                self.chat_id, text=self.msg, parse_mode=self.PARSE_MODE, reply_markup=self.get_markup()
             )
         ).unwrap()
         while True:

telegrinder-0.1.dev14/telegrinder/bot/scenario/choice.py

@@ -0,0 +1,39 @@
+from .checkbox import Checkbox
+from telegrinder.bot.cute_types import CallbackQueryCute
+import typing
+
+if typing.TYPE_CHECKING:
+    from telegrinder.api import API
+    from telegrinder.bot.dispatch import Dispatch
+
+
+class SingleChoice(Checkbox):
+    async def handle(self, cb: CallbackQueryCute) -> bool:
+        code = cb.data.replace(self.random_code + "/", "", 1)
+
+        if code == "ready":
+            return False
+
+        for choice in self.choices:
+            choice.is_picked = False
+
+        for i, choice in enumerate(self.choices):
+            if choice.code == code:
+                self.choices[i].is_picked = True
+                await cb.ctx_api.edit_message_text(
+                    cb.message.chat.id,
+                    cb.message.message_id,
+                    text=self.msg,
+                    parse_mode=self.PARSE_MODE,
+                    reply_markup=self.get_markup(),
+                )
+
+        return True
+
+    async def wait(
+        self, api: "API", dispatch: "Dispatch"
+    ) -> typing.Tuple[str, int]:
+        if len([choice for choice in self.choices if choice.is_picked]) != 1:
+            raise ValueError("Exactly one choice must be picked")
+        choices, m_id = await super().wait(api, dispatch)
+        return list(choices.keys())[list(choices.values()).index(True)], m_id

{telegrinder-0.1.dev11 → telegrinder-0.1.dev14}/telegrinder/model.py

@@ -42,6 +42,17 @@ class Model(msgspec.Struct, **model_config):
         return self._dict_cached
 
 
+def get_params(params: dict) -> dict:
+    return {
+        k: v for k, v in (
+            *params.items(),
+            *params.pop("other").items()
+        )
+        if k != "self"
+        and v is not None
+    }
+
+
 __all__ = (
     "convert",
     "model_config",
@@ -50,4 +61,5 @@ __all__ = (
     "msgspec",
     "Model",
     "Raw",
+    "get_params",
 )

{telegrinder-0.1.dev11 → telegrinder-0.1.dev14}/telegrinder/typegen/schema_generator.py

@@ -59,7 +59,7 @@ def convert_type(name: str, d: dict, obj: dict, forward_ref: bool = True) -> str
         if t in TYPES:
             return TYPES[t]
         elif t == "array":
-            nt = convert_type(name, d["items"], obj, forward_ref)
+            nt = convert_type("", d["items"], obj, forward_ref)
             return "typing.List[" + nt + "]"
         else:
             if "." in t:
@@ -74,7 +74,7 @@ def convert_type(name: str, d: dict, obj: dict, forward_ref: bool = True) -> str
     elif "anyOf" in d:
         return (
             "typing.Union["
-            + ", ".join(convert_type(name, ut, obj, forward_ref) for ut in d["anyOf"])
+            + ", ".join(convert_type("", ut, obj, forward_ref) for ut in d["anyOf"])
             + "]"
         )
     else:
@@ -210,13 +210,7 @@ def generate(path: str, schema_url: str = URL) -> None:
                 "\n\n",
                 "class APIMethods:\n",
                 SPACES + 'def __init__(self, api: "ABCAPI"):\n',
-                SPACES + SPACES + "self.api = api\n\n",
-                SPACES + "@staticmethod\n",
-                SPACES + "def get_params(loc: dict) -> dict:\n",
-                SPACES
-                + SPACES
-                + 'n = {k: v for k, v in loc.items() if k not in ("self", "other") and v is not None}\n',
-                SPACES + SPACES + "n.update(loc['other'])\n        return n\n",
+                SPACES + SPACES + "self.api = api\n",
             ]
         )
 
@@ -247,7 +241,7 @@ def generate(path: str, schema_url: str = URL) -> None:
             [
                 SPACES + li
                 for li in (
-                    "result = await self.api.request_raw({}, self.get_params(locals()))\n".format(
+                    "result = await self.api.request_raw({}, get_params(locals()))\n".format(
                         '"' + method_name + '"'
                     ),
                     ("\n" + SPACES + SPACES).join(parse_response(response).split("\n"))