pgbotlib/api.py

@@ -1,3 +1,5 @@
+""" Some functions for api calls """
+
 import json
 import random
 import re
@@ -29,15 +31,14 @@ class ApiWrapper:
     # this could have used match - case statement, but python 3.9
     def call(self, api: str, data: typing.Union[str, None],
              message: str) -> str:
-        match api:
+        if api == 'img_url': return self.format_img(data)
-            case 'img_url': return self.format_img(data)
+        elif api == 'gif': return self.get_gif()
-            case 'gif': return self.get_gif()
+        elif api == 'kmp': return self.get_kmp()
-            case 'kmp': return self.get_kmp()
+        elif api == 'fga': return self.get_fga()
-            case 'fga': return self.get_fga()
+        elif api == 'fakenews': return self.get_fakenews()
-            case 'fakenews': return self.get_fakenews()
+        elif api == 'anek': return self.get_anek()
-            case 'anek': return self.get_anek()
+        elif api == 'y_search': return self.y_search(message)
-            case 'y_search': return self.y_search(message)
+        return self.FAILED
-            case _: return self.FAILED
 
     def __sanitize_search(self, message: str) -> str:
         """Removes one of each of the search tokens from the query

pgbotlib/commands.py

@@ -10,8 +10,7 @@ import pgbotlib.response
 
 # TODO: quote via response?
 # chat = await event.get_chat()
-# result = await client.get_messages(chat.id,
+# result = await client.get_messages(chat.id, ids=[event.message.reply_to.reply_to_msg_id])
-#   ids=[event.message.reply_to.reply_to_msg_id])
 # print(result)
 class Commander:
     T_START = frozenset(['cmd_start'])
@@ -60,18 +59,15 @@ class Commander:
     def __add_response(self, caller: int, command: str) -> bool:
         if caller not in self.admins:
             return self.NOPE
-        DB_QUERY = 'INSERT INTO responses (tokens, response) values (%s,%s)'
+        input_tokens, phrase = command.strip().split(' ', 1)
-        try:
+        input_tokenset = frozenset(input_tokens.split(','))
-            input_tokens, phrase = command.strip().split(' ', 1)
+        for token in input_tokenset:
-            input_tokenset = frozenset(input_tokens.split(','))
+            if token not in self.available_tokens:
-            for token in input_tokenset:
+                return False
-                if token not in self.available_tokens:
+        query = 'INSERT INTO responses (tokens, response) values (%s,%s)'
-                    return "token not found!"
+        values = (','.join(sorted(input_tokenset)), phrase.strip())
-            values = (','.join(sorted(input_tokenset)), phrase.strip())
+        self.db_conn.update(query, values)
-            self.db_conn.update(DB_QUERY, values)
+        return self.YEP
-            return self.YEP
-        except Exception as e:
-            return str(e)
 
     def __add_user(self, caller: int, userspec: str) -> bool:
         if caller not in self.admins:
@@ -83,15 +79,16 @@ class Commander:
             self.db_conn.update(query, values)
         return self.YEP
 
+
     def __start_response(self) -> str:
-        if self.responder.is_enabled():
+            if self.responder.is_enabled():
-            return self.responder.get_response(self.T_START_E)
+                return self.responder.get_response(self.T_START_E)
-        return self.responder.get_response(self.T_START)
+            return self.responder.get_response(self.T_START)
 
     def __stop_response(self) -> str:
-        if self.responder.is_enabled():
+            if self.responder.is_enabled():
-            return self.responder.get_response(self.T_STOP)
+                return self.responder.get_response(self.T_STOP)
-        return self.responder.get_response(self.T_STOP_D)
+            return self.responder.get_response(self.T_STOP_D)
 
     def __list_users(self, users: list) -> str:
         userlist = [f'{user.id}: {self.namegen.get_tg_name(user)}'
@@ -112,32 +109,35 @@ class Commander:
             return None
         command = event.message.text
         sender = await event.get_sender()
-        match command:
+        response = None
-            case '.chat':
+        if command.startswith('.add '):
-                response = str(chat_id)
+            try:
-            case '.list':
-                response = ', '.join(self.available_tokens)
-            case '.users':
-                users = await self.client.get_participants(
-                        entity=event.message.peer_id)
-                response = self.__list_users(users)
-            case '.start':
-                response = self.__start_response()
-                self.responder.enable()
-            case '.stop':
-                response = self.__stop_response()
-                self.responder.disable()
-            case '.help':
-                response = self.DOC
-            case command if command.startswith('.add '):
                 response = self.__add_response(sender.id, command[5:])
-            case command if command.startswith('.adduser '):
+            except Exception as e:
-                try:
+                response = str(e)
-                    response = self.__add_user(sender.id, command[9:])
+        elif command.startswith('.adduser '):
-                except Exception as e:
+            try:
-                    response = str(e)
+                response = self.__add_user(sender.id, command[9:])
-            case command if command.startswith('.regex '):
+            except Exception as e:
-                response = self.__list_regex(command[7:].strip())
+                response = str(e)
-            case _:
+        elif command == '.chat':
-                return None
+            response = str(chat_id)
-        await self.client.send_message(event.message.peer_id, response)
+        elif command == '.list':
+            response = ', '.join(self.available_tokens)
+        elif command.startswith('.regex '):
+            response = self.__list_regex(command[7:].strip())
+        elif command == '.users':
+            users = await self.client.get_participants(
+                    entity=event.message.peer_id)
+            response = self.__list_users(users)
+        elif command == '.start':
+            response = self.__start_response()
+            self.responder.enable()
+        elif command == '.stop':
+            response = self.__stop_response()
+            self.responder.disable()
+        elif command == '.help':
+            response = self.DOC
+        if response:
+            await self.client.send_message(event.message.peer_id, response)
+        return None

pgbotlib/cron.py

@@ -30,7 +30,6 @@ class Cron:
 
     def __mkjob(self, job: dict) -> callable:
         tokens = frozenset(job['tokens'].split(','))
-
         async def send_message() -> None:
             if 'rand' in job:
                 wait_seconds = random.randint(0, job['rand']) * 60

pgbotlib/misc.py

@@ -32,14 +32,10 @@ class MiscReactor:
 
     def spawn_edited_handler(self,
                              client: telethon.TelegramClient,
-                             trigger: telethon.events.common.EventBuilder
+                             trigger: telethon.events.common.EventBuilder) -> None:
-                             ) -> None:
         @client.on(trigger)
         async def handle_edited_message(event):
             sender = await event.get_sender()
             sender_name = self.namegen.get_name(sender)
             chat_id = event.message.peer_id
-            await client.send_message(
+            await client.send_message(chat_id, f'Я всё видел! {sender_name} совсем охуел, сообщения правит!')
-                chat_id,
-                f'Я всё видел! {sender_name} совсем охуел, сообщения правит!'
-            )