Initial implemenation of room associations and audio processing

Author: juergenpabel

bot_commands.py

@@ -34,7 +34,7 @@
 class Command(object):
     """Use this class for your bot commands."""
 
-    def __init__(self, client, store, config, command_dict, command, room, event):
+    def __init__(self, client, store, config, command_dict, command, room_dict, room, event):
         """Set up bot commands.
 
         Arguments:
@@ -44,6 +44,7 @@ def __init__(self, client, store, config, command_dict, command, room, event):
             config (Config): Bot configuration parameters
             command_dict (CommandDict): Command dictionary
             command (str): The command and arguments
+            room_dict (CommandDict): Room dictionary
             room (nio.rooms.MatrixRoom): The room the command was sent in
             event (nio.events.room_events.RoomMessageText): The event
                 describing the command
@@ -54,6 +55,7 @@ def __init__(self, client, store, config, command_dict, command, room, event):
         self.config = config
         self.command_dict = command_dict
         self.command = command
+        self.room_dict = room_dict
         self.room = room
         self.event = event
         # self.args: list : list of arguments
@@ -81,6 +83,18 @@ async def process(self):  # noqa
         ):
             await self._show_help()
 
+        # command from room dict
+        elif self.room_dict.match(self.room.display_name):
+            matched_cmd = self.room_dict.get_last_matched_room()
+            await self._os_cmd(
+                cmd=self.room_dict.get_cmd(matched_cmd),
+                args=self.room_dict.get_opt_args(matched_cmd),
+                markdown_convert=self.room_dict.get_opt_markdown_convert(matched_cmd),
+                formatted=self.room_dict.get_opt_formatted(matched_cmd),
+                code=self.room_dict.get_opt_code(matched_cmd),
+                split=self.room_dict.get_opt_split(matched_cmd),
+            )
+
         # command from command dict
         elif self.command_dict.match(self.commandlower):
             matched_cmd = self.command_dict.get_last_matched_command()
@@ -139,9 +153,10 @@ async def _unknown_command(self):
             self.client,
             self.room.room_id,
             (
-                f"Unknown command `{self.command}`. "
-                "Try the `help` command for more information."
+                f"{self.command}\n"
+                "Try the *help* command for more information."
             ),
+            split="\n",
         )
 
     async def _os_cmd(
@@ -175,7 +190,10 @@ async def _os_cmd(
         """
         try:
             # create a combined argv list, e.g. ['date', '--utc']
-            argv_list = [cmd] + args
+            argv_list = [cmd]
+            if args is not None:
+                argv_list += args
+
             logger.debug(
                 f'OS command "{argv_list[0]}" with ' f'args: "{argv_list[1:]}"'
             )
@@ -192,11 +210,13 @@ async def _os_cmd(
 
             run = subprocess.Popen(
                 argv_list,  # list of argv
+                stdin=subprocess.PIPE,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 universal_newlines=True,
                 env=new_env,
             )
+            run.stdin.write( self.command )
             output, std_err = run.communicate()
             output = output.strip()
             std_err = std_err.strip()

callbacks.py

@@ -28,10 +28,17 @@
     KeyVerificationMac,
     ToDeviceError,
     LocalProtocolError,
+    DownloadError,
+    DownloadResponse,
 )
+from nio.crypto import decrypt_attachment
+
 import logging
 import traceback
+from base64 import b64encode
+from urllib.parse import urlparse
 from command_dict import CommandDict
+from room_dict import RoomDict
 
 logger = logging.getLogger(__name__)
 
@@ -55,6 +62,7 @@ def __init__(self, client, store, config):
         self.config = config
         self.command_dict = CommandDict(config.command_dict_filepath)
         self.command_prefix = config.command_prefix
+        self.room_dict = RoomDict(config.room_dict_filepath)
 
     async def message(self, room, event):
         """Handle an incoming message event.
@@ -98,7 +106,46 @@ async def message(self, room, event):
             msg = msg[len(self.command_prefix):]
 
         command = Command(self.client, self.store,
-                          self.config, self.command_dict, msg, room, event)
+                          self.config, self.command_dict, msg, self.room_dict, room, event)
+        await command.process()
+
+    async def audio(self, room, event):
+        """Handle an incoming audio event.
+
+        Arguments:
+        ---------
+            room (nio.rooms.MatrixRoom): The room the event came from
+            event (nio.events.room_events.RoomMessageAudio): The event
+                defining the (audio) message
+
+        """
+        # Ignore messages from ourselves
+        if event.sender == self.client.user:
+            return
+
+        # Ignore non-ogg audio
+        if event.body[-4:] != '.ogg':
+            logger.debug(
+                f"Bot received (apparently) non-ogg data for room {room.display_name} | "
+                f"{room.user_name(event.sender)}: {event.body}"
+            )
+            return
+
+        # download the audio data
+        logger.debug(
+            f"Bot downloading audio for room {room.display_name} | "
+            f"{room.user_name(event.sender)}: {event.url}"
+        )
+        mxc = urlparse(event.url)
+        response = await self.client.download(server_name=mxc.netloc, media_id=mxc.path.strip("/"), filename=None, allow_remote=True)
+        if isinstance(response, DownloadError):
+            logger.error(f"Bot download of media resulted in error")
+            return
+        data = decrypt_attachment(response.body, event.key["k"], event.hashes["sha256"], event.iv)
+        data = f"data:audio/ogg;base64,{b64encode(data).decode('utf-8')}"
+
+        command = Command(self.client, self.store,
+                          self.config, self.command_dict, data, self.room_dict, room, event)
         await command.process()
 
     async def invite(self, room, event):

command_dict.py

@@ -176,10 +176,7 @@ def match(self, string):
                     cmd = command
                     break
 
-        if cmd and len(cmd) > 0:
-            self._last_matched_command = cmd
-        else:
-            self._last_matched_command = None
+        self._last_matched_command = cmd
 
         return matched
 

config.py

@@ -75,6 +75,8 @@ def __init__(self, filepath):
             ["storage", "store_filepath"], required=True)
         self.command_dict_filepath = self._get_cfg(
             ["storage", "command_dict_filepath"], default=None)
+        self.room_dict_filepath = self._get_cfg(
+            ["storage", "room_dict_filepath"], default=None)
 
         # Create the store folder if it doesn't exist
         if not os.path.isdir(self.store_filepath):
@@ -112,6 +114,10 @@ def __init__(self, filepath):
             ["matrix", "trust_own_devices"], default=False, required=False)
         self.change_device_name = self._get_cfg(
             ["matrix", "change_device_name"], default=False, required=False)
+        self.process_audio = self._get_cfg(
+            ["matrix", "process_audio"], default=False, required=False)
+        self.accept_invitations = self._get_cfg(
+            ["matrix", "accept_invitations"], default=True, required=False)
 
     def _get_cfg(
             self,

config.yaml.example

@@ -48,6 +48,16 @@ matrix:
   # If true, device_name of bot will be changed to value given in device_name.
   change_device_name: false
   # encrytion is enabled by default
+  accept_invitations: true
+  # Should the bot accept invitations? If disabled then the bot must be
+  # added to the desired rooms "manually". This configuration is mostly
+  # useful in combination with the room-specific processing "feature"
+  # (refer to storage.room_dict_path)
+  process_audio: false
+  # Should the bot also process audio messages (need to be downloaded
+  # before processing)? If true the audio content will be passed (just
+  # as with text content) to the handling command program, but base64
+  # encoded inside a "data:" url
 
 storage:
   # The path to the database
@@ -57,6 +67,8 @@ storage:
   store_filepath: "./store"
   # The path to the command dictionary configuration file
   command_dict_filepath: "./commands.yaml"
+  # The path to the room dictionary configuration file
+  room_dict_filepath: "./room.yaml"
 
 # Logging setup
 logging:

main.py

@@ -27,6 +27,8 @@
     AsyncClient,
     AsyncClientConfig,
     RoomMessageText,
+    RoomMessageAudio,
+    RoomEncryptedAudio,
     InviteMemberEvent,
     LoginError,
     LocalProtocolError,
@@ -78,7 +80,10 @@ async def main():  # noqa
     # Set up event callbacks
     callbacks = Callbacks(client, store, config)
     client.add_event_callback(callbacks.message, (RoomMessageText,))
-    client.add_event_callback(callbacks.invite, (InviteMemberEvent,))
+    if config.accept_invitations:
+        client.add_event_callback(callbacks.invite, (InviteMemberEvent,))
+    if config.process_audio:
+        client.add_event_callback(callbacks.audio, (RoomEncryptedAudio,))
     client.add_to_device_callback(
         callbacks.to_device_cb, (KeyVerificationEvent,))