Even even more migrations to mautrix-python

mautrix_telegram/commands/__init__.py

@@ -1,5 +1,8 @@
-from .handler import (command_handler, command_handlers as _command_handlers,
-                      CommandHandler, CommandProcessor, CommandEvent,
-                      SECTION_GENERAL, SECTION_AUTH, SECTION_CREATING_PORTALS,
-                      SECTION_PORTAL_MANAGEMENT, SECTION_MISC, SECTION_ADMIN)
-from . import portal, telegram, clean_rooms, matrix_auth, meta
+from .handler import (command_handler, CommandHandler, CommandProcessor, CommandEvent,
+                      SECTION_AUTH, SECTION_CREATING_PORTALS, SECTION_PORTAL_MANAGEMENT,
+                      SECTION_MISC, SECTION_ADMIN)
+from . import portal, telegram, clean_rooms, matrix_auth
+
+__all__ = ["command_handler", "CommandHandler", "CommandProcessor", "CommandEvent",
+           "SECTION_AUTH", "SECTION_MISC", "SECTION_ADMIN", "SECTION_CREATING_PORTALS",
+           "SECTION_PORTAL_MANAGEMENT"]

mautrix_telegram/commands/clean_rooms.py

@@ -13,11 +13,11 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict, List, NamedTuple, Optional, Tuple, Union
+from typing import List, NamedTuple, Tuple, Union
 
 from mautrix.appservice import IntentAPI
 from mautrix.errors import MatrixRequestError
-from mautrix.types import RoomID, UserID
+from mautrix.types import RoomID, UserID, EventID
 
 from . import command_handler, CommandEvent, SECTION_ADMIN
 from .. import puppet as pu, portal as po
@@ -61,7 +61,7 @@ async def _find_rooms(intent: IntentAPI) -> Tuple[List[ManagementRoom], List[Roo
 @command_handler(needs_admin=True, needs_auth=False, management_only=True, name="clean-rooms",
                  help_section=SECTION_ADMIN,
                  help_text="Clean up unused portal/management rooms.")
-async def clean_rooms(evt: CommandEvent) -> Optional[Dict]:
+async def clean_rooms(evt: CommandEvent) -> EventID:
     management_rooms, unidentified_rooms, portals, empty_portals = await _find_rooms(evt.az.intent)
 
     reply = ["#### Management rooms (M)"]
@@ -107,10 +107,10 @@ async def clean_rooms(evt: CommandEvent) -> Optional[Dict]:
 
 
 async def set_rooms_to_clean(evt, management_rooms: List[ManagementRoom],
-                             unidentified_rooms: List[MatrixRoomID], portals: List["po.Portal"],
+                             unidentified_rooms: List[RoomID], portals: List["po.Portal"],
                              empty_portals: List["po.Portal"]) -> None:
     command = evt.args[0]
-    rooms_to_clean = []  # type: List[Union[po.Portal, MatrixRoomID]]
+    rooms_to_clean: List[Union[po.Portal, RoomID]] = []
     if command == "clean-recommended":
         rooms_to_clean += empty_portals
         rooms_to_clean += unidentified_rooms
@@ -159,7 +159,7 @@ async def set_rooms_to_clean(evt, management_rooms: List[ManagementRoom],
                     "`$cmdprefix+sp confirm-clean`.")
 
 
-async def execute_room_cleanup(evt, rooms_to_clean: List[Union[po.Portal, MatrixRoomID]]) -> None:
+async def execute_room_cleanup(evt, rooms_to_clean: List[Union[po.Portal, RoomID]]) -> None:
     if len(evt.args) > 0 and evt.args[0] == "confirm-clean":
         await evt.reply(f"Cleaning {len(rooms_to_clean)} rooms. "
                         "This might take a while.")
@@ -168,7 +168,7 @@ async def execute_room_cleanup(evt, rooms_to_clean: List[Union[po.Portal, Matrix
             if isinstance(room, po.Portal):
                 await room.cleanup_and_delete()
                 cleaned += 1
-            elif isinstance(room, str):  # str is aliased by MatrixRoomID
+            else:
                 await po.Portal.cleanup_room(evt.az.intent, room, message="Room deleted")
                 cleaned += 1
         evt.sender.command_status = None

mautrix_telegram/commands/handler.py

@@ -14,24 +14,23 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """This module contains classes handling commands issued by Matrix users."""
-from typing import Awaitable, Callable, Dict, List, NamedTuple, Optional
-import logging
-import traceback
-
-import commonmark
+from typing import Awaitable, Callable, List, Optional, NamedTuple, Any
 
 from telethon.errors import FloodWaitError
 
 from mautrix.types import RoomID, EventID
+from mautrix.bridge.commands import (HelpSection, CommandEvent as BaseCommandEvent,
+                                     CommandHandler as BaseCommandHandler,
+                                     CommandProcessor as BaseCommandProcessor,
+                                     CommandHandlerFunc, command_handler as base_command_handler)
 
 from ..util import format_duration
 from .. import user as u, context as c
 
-command_handlers: Dict[str, 'CommandHandler'] = {}
+HelpCacheKey = NamedTuple('HelpCacheKey',
+                          is_management=bool, is_portal=bool, puppet_whitelisted=bool,
+                          matrix_puppet_whitelisted=bool, is_admin=bool, is_logged_in=bool)
 
-HelpSection = NamedTuple('HelpSection', [('name', str), ('order', int), ('description', str)])
-
-SECTION_GENERAL = HelpSection("General", 0, "")
 SECTION_AUTH = HelpSection("Authentication", 10, "")
 SECTION_CREATING_PORTALS = HelpSection("Creating portals", 20, "")
 SECTION_PORTAL_MANAGEMENT = HelpSection("Portal management", 30, "")
@@ -39,186 +38,42 @@ SECTION_MISC = HelpSection("Miscellaneous", 40, "")
 SECTION_ADMIN = HelpSection("Administration", 50, "")
 
 
-class HtmlEscapingRenderer(commonmark.HtmlRenderer):
-    def __init__(self, allow_html: bool = False):
-        super().__init__()
-        self.allow_html = allow_html
+class CommandEvent(BaseCommandEvent):
+    sender: u.User
 
-    def lit(self, s):
-        if self.allow_html:
-            return super().lit(s)
-        return super().lit(s.replace("<", "&lt;").replace(">", "&gt;"))
-
-    def image(self, node, entering):
-        prev = self.allow_html
-        self.allow_html = True
-        super().image(node, entering)
-        self.allow_html = prev
-
-
-md_parser = commonmark.Parser()
-md_renderer = HtmlEscapingRenderer()
-
-
-def ensure_trailing_newline(s: str) -> str:
-    """Returns the passed string, but with a guaranteed trailing newline."""
-    return s + ("" if s[-1] == "\n" else "\n")
-
-
-class CommandEvent:
-    """Holds information about a command issued in a Matrix room.
-
-    When a Matrix command was issued to the bot, CommandEvent will hold
-    information regarding the event.
-
-    Attributes:
-        room_id: The id of the Matrix room in which the command was issued.
-        event_id: The id of the matrix event which contained the command.
-        sender: The user who issued the command.
-        command: The issued command.
-        args: Arguments given with the issued command.
-        is_management: Determines whether the room in which the command wa
-            issued is a management room.
-        is_portal: Determines whether the room in which the command was issued
-            is a portal.
-    """
-
-    def __init__(self, processor: 'CommandProcessor', room: RoomID, event: EventID,
+    def __init__(self, processor: 'CommandProcessor', room_id: RoomID, event_id: EventID,
                  sender: u.User, command: str, args: List[str], is_management: bool,
                  is_portal: bool) -> None:
-        self.az = processor.az
-        self.log = processor.log
-        self.loop = processor.loop
+        super().__init__(processor, room_id, event_id, sender, command, args, is_management,
+                         is_portal)
         self.tgbot = processor.tgbot
         self.config = processor.config
         self.public_website = processor.public_website
-        self.command_prefix = processor.command_prefix
-        self.room_id = room
-        self.event_id = event
-        self.sender = sender
-        self.command = command
-        self.args = args
-        self.is_management = is_management
-        self.is_portal = is_portal
 
-    def reply(self, message: str, allow_html: bool = False, render_markdown: bool = True
-              ) -> Awaitable[EventID]:
-        """Write a reply to the room in which the command was issued.
-
-        Replaces occurences of "$cmdprefix" in the message with the command
-        prefix and replaces occurences of "$cmdprefix+sp " with the command
-        prefix if the command was not issued in a management room.
-        If allow_html and render_markdown are both False, the message will not
-        be rendered to html and sending of html is disabled.
-
-        Args:
-            message: The message to post in the room.
-            allow_html: Escape html in the message or don't render html at all
-                if markdown is disabled.
-            render_markdown: Use markdown formatting to render the passed
-                message to html.
-
-        Returns:
-            Handler for the message sending function.
-        """
-        message_cmd = self._replace_command_prefix(message)
-        html = self._render_message(message_cmd, allow_html=allow_html,
-                                    render_markdown=render_markdown)
-
-        return self.az.intent.send_notice(self.room_id, message_cmd, html=html)
-
-    def mark_read(self) -> Awaitable[Dict]:
-        """Marks the command as read by the bot."""
-        return self.az.intent.mark_read(self.room_id, self.event_id)
-
-    def _replace_command_prefix(self, message: str) -> str:
-        """Returns the string with the proper command prefix entered."""
-        message = message.replace(
-            "$cmdprefix+sp ", "" if self.is_management else f"{self.command_prefix} "
-        )
-        return message.replace("$cmdprefix", self.command_prefix)
-
-    @staticmethod
-    def _render_message(message: str, allow_html: bool, render_markdown: bool) -> Optional[str]:
-        """Renders the message as HTML.
-
-        Args:
-            allow_html: Flag to allow custom HTML in the message.
-            render_markdown: If true, markdown styling is applied to the message.
-
-        Returns:
-            The message rendered as HTML.
-            None is returned if no styled output is required.
-        """
-        html = ""
-        if render_markdown:
-            md_renderer.allow_html = allow_html
-            html = md_renderer.render(md_parser.parse(message))
-        elif allow_html:
-            html = message
-        return ensure_trailing_newline(html) if html else None
+    async def get_help_key(self) -> HelpCacheKey:
+        return HelpCacheKey(self.is_management, self.is_portal, self.sender.puppet_whitelisted,
+                            self.sender.matrix_puppet_whitelisted, self.sender.is_admin,
+                            await self.sender.is_logged_in())
 
 
-class CommandHandler:
-    """A command which can be executed from a Matrix room.
+class CommandHandler(BaseCommandHandler):
+    name: str
 
-    The command manages its permission and help texts.
-    When called, it will check the permission of the command event and execute
-    the command or, in case of error, report back to the user.
-
-    Attributes:
-        needs_auth: Flag indicating if the sender is required to be logged in.
-        needs_puppeting: Flag indicating if the sender is required to use
-            Telegram puppeteering for this command.
-        needs_matrix_puppeting: Flag indicating if the sender is required to use
-            Matrix pupeteering.
-        needs_admin: Flag for whether only admin users can issue this command.
-        management_only: Whether the command can exclusively be issued in a
-            management room.
-        name: The name of this command.
-        help_section: Section of the help in which this command will appear.
-    """
+    management_only: bool
+    needs_auth: bool
+    needs_puppeting: bool
+    needs_matrix_puppeting: bool
+    needs_admin: bool
 
     def __init__(self, handler: Callable[[CommandEvent], Awaitable[EventID]], needs_auth: bool,
                  needs_puppeting: bool, needs_matrix_puppeting: bool, needs_admin: bool,
                  management_only: bool, name: str, help_text: str, help_args: str,
                  help_section: HelpSection) -> None:
-        """
-        Args:
-            handler: The function handling the execution of this command.
-            needs_auth: Flag indicating if the sender is required to be logged in.
-            needs_puppeting: Flag indicating if the sender is required to use
-                Telegram puppeteering for this command.
-            needs_matrix_puppeting: Flag indicating if the sender is required to
-                use Matrix pupeteering.
-            needs_admin: Flag for whether only admin users can issue this command.
-            management_only: Whether the command can exclusively be issued
-                in a management room.
-            name: The name of this command.
-            help_text: The text displayed in the help for this command.
-            help_args: Help text for the arguments of this command.
-            help_section: Section of the help in which this command will appear.
-        """
-        self._handler = handler
-        self.needs_auth = needs_auth
-        self.needs_puppeting = needs_puppeting
-        self.needs_matrix_puppeting = needs_matrix_puppeting
-        self.needs_admin = needs_admin
-        self.management_only = management_only
-        self.name = name
-        self._help_text = help_text
-        self._help_args = help_args
-        self.help_section = help_section
+        super().__init__(handler, management_only, name, help_text, help_args, help_section,
+                         needs_auth=needs_auth, needs_puppeting=needs_puppeting,
+                         needs_matrix_puppeting=needs_matrix_puppeting, needs_admin=needs_admin)
 
     async def get_permission_error(self, evt: CommandEvent) -> Optional[str]:
-        """Returns the reason why the command could not be issued.
-
-        Args:
-            evt: The event for which to get the error information.
-
-        Returns:
-            A string describing the error or None if there was no error.
-        """
         if self.management_only and not evt.is_management:
             return (f"`{evt.command}` is a restricted command: "
                     "you may only run it in management rooms.")
@@ -232,134 +87,40 @@ class CommandHandler:
             return "This command requires you to be logged in."
         return None
 
-    def has_permission(self, is_management: bool, puppet_whitelisted: bool,
-                       matrix_puppet_whitelisted: bool, is_admin: bool, is_logged_in: bool) -> bool:
-        """Checks the permission for this command with the given status.
-
-        Args:
-            is_management: If the room in which the command will be issued is a
-                management room.
-            puppet_whitelisted: If the connected Telegram account puppet is
-                allowed to issue the command.
-            matrix_puppet_whitelisted: If the connected Matrix account puppet is
-                allowed to issue the command.
-            is_admin: If the issuing user is an admin.
-            is_logged_in: If the issuing user is logged in.
-
-        Returns:
-            True if a user with the given state is allowed to issue the
-            command.
-        """
-        return ((not self.management_only or is_management) and
-                (not self.needs_puppeting or puppet_whitelisted) and
-                (not self.needs_matrix_puppeting or matrix_puppet_whitelisted) and
-                (not self.needs_admin or is_admin) and
-                (not self.needs_auth or is_logged_in))
-
-    async def __call__(self, evt: CommandEvent) -> EventID:
-        """Executes the command if evt was issued with proper rights.
-
-        Args:
-            evt: The CommandEvent for which to check permissions.
-
-        Returns:
-            The result of the command or the error message function.
-
-        Raises:
-            FloodWaitError
-        """
-        error = await self.get_permission_error(evt)
-        if error is not None:
-            return await evt.reply(error)
-        return await self._handler(evt)
-
-    @property
-    def has_help(self) -> bool:
-        """Returns true if this command has a help text."""
-        return bool(self.help_section) and bool(self._help_text)
-
-    @property
-    def help(self) -> str:
-        """Returns the help text to this command."""
-        return f"**{self.name}** {self._help_args} - {self._help_text}"
+    def has_permission(self, key: HelpCacheKey) -> bool:
+        return ((not self.management_only or key.is_management) and
+                (not self.needs_puppeting or key.puppet_whitelisted) and
+                (not self.needs_matrix_puppeting or key.matrix_puppet_whitelisted) and
+                (not self.needs_admin or key.is_admin) and
+                (not self.needs_auth or key.is_logged_in))
 
 
-def command_handler(_func: Optional[Callable[[CommandEvent], Awaitable[EventID]]] = None, *,
-                    needs_auth: bool = True, needs_puppeting: bool = True,
-                    needs_matrix_puppeting: bool = False, needs_admin: bool = False,
-                    management_only: bool = False, name: Optional[str] = None,
-                    help_text: str = "", help_args: str = "", help_section: HelpSection = None
-                    ) -> Callable[[Callable[[CommandEvent], Awaitable[Optional[EventID]]]],
-                                  CommandHandler]:
-    def decorator(func: Callable[[CommandEvent], Awaitable[Optional[EventID]]]) -> CommandHandler:
-        actual_name = name or func.__name__.replace("_", "-")
-        handler = CommandHandler(func, needs_auth, needs_puppeting, needs_matrix_puppeting,
-                                 needs_admin, management_only, actual_name, help_text, help_args,
-                                 help_section)
-        command_handlers[handler.name] = handler
-        return handler
-
-    return decorator if _func is None else decorator(_func)
+def command_handler(_func: Optional[CommandHandlerFunc] = None, *, needs_auth: bool = True,
+                    needs_puppeting: bool = True, needs_matrix_puppeting: bool = False,
+                    needs_admin: bool = False, management_only: bool = False,
+                    name: Optional[str] = None, help_text: str = "", help_args: str = "",
+                    help_section: HelpSection = None) -> Callable[[CommandHandlerFunc],
+                                                                  CommandHandler]:
+    return base_command_handler(
+        _func, _handler_class=CommandHandler, name=name, help_text=help_text, help_args=help_args,
+        help_section=help_section, management_only=management_only, needs_auth=needs_auth,
+        needs_admin=needs_admin, needs_puppeting=needs_puppeting,
+        needs_matrix_puppeting=needs_matrix_puppeting)
 
 
-class CommandProcessor:
-    """Handles the raw commands issued by a user to the Matrix bot."""
-    log = logging.getLogger("mau.commands")
-
+class CommandProcessor(BaseCommandProcessor):
     def __init__(self, context: c.Context) -> None:
+        super().__init__(az=context.az, config=context.config, event_class=CommandEvent,
+                         loop=context.loop)
+        self.tgbot = context.bot
         self.az, self.config, self.loop, self.tgbot = context.core
         self.public_website = context.public_website
         self.command_prefix = self.config["bridge.command_prefix"]
 
-    async def handle(self, room: RoomID, event_id: EventID, sender: u.User,
-                     command: str, args: List[str], is_management: bool, is_portal: bool
-                     ) -> Optional[EventID]:
-        """Handles the raw commands issued by a user to the Matrix bot.
-
-        If the command is not known, it might be a followup command and is
-        delegated to a command handler registered for that purpose in the
-        senders command_status as "next".
-
-        Args:
-            room: ID of the Matrix room in which the command was issued.
-            event_id: ID of the event by which the command was issued.
-            sender: The sender who issued the command.
-            command: The issued command, case insensitive.
-            args: Arguments given with the command.
-            is_management: Whether the room is a management room.
-            is_portal: Whether the room is a portal.
-
-        Returns:
-            The result of the error message function or None if no error
-            occured. Unknown and delegated commands do not count as errors.
-        """
-        if not command_handlers or "unknown-command" not in command_handlers:
-            raise ValueError("command_handlers are not properly initialized.")
-
-        evt = CommandEvent(self, room, event_id, sender, command, args, is_management, is_portal)
-        orig_command = command
-        command = command.lower()
+    @staticmethod
+    async def _run_handler(handler: Callable[[CommandEvent], Awaitable[Any]], evt: CommandEvent
+                           ) -> Any:
         try:
-            handler = command_handlers[command]
-        except KeyError:
-            if sender.command_status and "next" in sender.command_status:
-                args.insert(0, orig_command)
-                evt.command = ""
-                handler = sender.command_status["next"]
-            else:
-                handler = command_handlers["unknown-command"]
-        try:
-            await handler(evt)
+            return await handler(evt)
         except FloodWaitError as e:
             return await evt.reply(f"Flood error: Please wait {format_duration(e.seconds)}")
-        except Exception:
-            self.log.exception("Unhandled error while handling command "
-                               f"{evt.command} {' '.join(args)} from {sender.mxid}")
-            if evt.sender.is_admin and evt.is_management:
-                return await evt.reply("Unhandled error while handling command:\n\n"
-                                       "```traceback\n"
-                                       f"{traceback.format_exc()}"
-                                       "```")
-            return await evt.reply("Unhandled error while handling command. "
-                                   "Check logs for more details.")
-        return None

mautrix_telegram/commands/matrix_auth.py

@@ -13,17 +13,17 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict, Optional
+from mautrix.types import EventID
+from mautrix.bridge import InvalidAccessToken, OnlyLoginSelf
 
 from . import command_handler, CommandEvent, SECTION_AUTH
 from .. import puppet as pu
 
 
 @command_handler(needs_auth=True, needs_matrix_puppeting=True,
-                 help_section=SECTION_AUTH,
-                 help_text="Revert your Telegram account's Matrix puppet to use the default Matrix "
-                           "account.")
-async def logout_matrix(evt: CommandEvent) -> Optional[Dict]:
+                 help_section=SECTION_AUTH, help_text="Revert your Telegram account's Matrix "
+                                                      "puppet to use the default Matrix account.")
+async def logout_matrix(evt: CommandEvent) -> EventID:
     puppet = pu.Puppet.get(evt.sender.tgid)
     if not puppet.is_real_user:
         return await evt.reply("You are not logged in with your Matrix account.")
@@ -35,7 +35,7 @@ async def logout_matrix(evt: CommandEvent) -> Optional[Dict]:
                  help_section=SECTION_AUTH,
                  help_text="Replace your Telegram account's Matrix puppet with your own Matrix "
                            "account.")
-async def login_matrix(evt: CommandEvent) -> Optional[Dict]:
+async def login_matrix(evt: CommandEvent) -> EventID:
     puppet = pu.Puppet.get(evt.sender.tgid)
     if puppet.is_real_user:
         return await evt.reply("You have already logged in with your Matrix account. "
@@ -70,31 +70,29 @@ async def login_matrix(evt: CommandEvent) -> Optional[Dict]:
 @command_handler(needs_auth=True, needs_matrix_puppeting=True,
                  help_section=SECTION_AUTH,
                  help_text="Pings the server with the stored matrix authentication.")
-async def ping_matrix(evt: CommandEvent) -> Optional[Dict]:
+async def ping_matrix(evt: CommandEvent) -> EventID:
     puppet = pu.Puppet.get(evt.sender.tgid)
     if not puppet.is_real_user:
         return await evt.reply("You are not logged in with your Matrix account.")
-    resp = await puppet.init_custom_mxid()
-    if resp == pu.PuppetError.InvalidAccessToken:
+    try:
+        await puppet.init_custom_mxid()
+    except InvalidAccessToken:
         return await evt.reply("Your access token is invalid.")
-    elif resp == pu.PuppetError.Success:
-        return await evt.reply("Your Matrix login is working.")
-    return await evt.reply(f"Unknown response while checking your Matrix login: {resp}.")
+    return await evt.reply("Your Matrix login is working.")
 
 
-async def enter_matrix_token(evt: CommandEvent) -> Dict:
+async def enter_matrix_token(evt: CommandEvent) -> EventID:
     evt.sender.command_status = None
 
     puppet = pu.Puppet.get(evt.sender.tgid)
     if puppet.is_real_user:
         return await evt.reply("You have already logged in with your Matrix account. "
                                "Log out with `$cmdprefix+sp logout-matrix` first.")
-
-    resp = await puppet.switch_mxid(" ".join(evt.args), evt.sender.mxid)
-    if resp == pu.PuppetError.OnlyLoginSelf:
+    try:
+        await puppet.switch_mxid(" ".join(evt.args), evt.sender.mxid)
+    except OnlyLoginSelf:
         return await evt.reply("You can only log in as your own Matrix user.")
-    elif resp == pu.PuppetError.InvalidAccessToken:
+    except InvalidAccessToken:
         return await evt.reply("Failed to verify access token.")
-    assert resp == pu.PuppetError.Success, "Encountered an unhandled PuppetError."
-    return await evt.reply(
-        f"Replaced your Telegram account's Matrix puppet with {puppet.custom_mxid}.")
+    return await evt.reply("Replaced your Telegram account's Matrix puppet "
+                           f"with {puppet.custom_mxid}.")

mautrix_telegram/commands/meta.py

@@ -1,71 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2019 Tulir Asokan
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-#
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict, List, Optional, Tuple
-
-from . import command_handler, CommandEvent, _command_handlers, SECTION_GENERAL
-from .handler import HelpSection
-
-
-@command_handler(needs_auth=False, needs_puppeting=False,
-                 help_section=SECTION_GENERAL,
-                 help_text="Cancel an ongoing action (such as login)")
-async def cancel(evt: CommandEvent) -> Optional[Dict]:
-    if evt.sender.command_status:
-        action = evt.sender.command_status["action"]
-        evt.sender.command_status = None
-        return await evt.reply(f"{action} cancelled.")
-    else:
-        return await evt.reply("No ongoing command.")
-
-
-@command_handler(needs_auth=False, needs_puppeting=False)
-async def unknown_command(evt: CommandEvent) -> Optional[Dict]:
-    return await evt.reply("Unknown command. Try `$cmdprefix+sp help` for help.")
-
-
-help_cache = {}  # type: Dict[Tuple[bool, bool, bool, bool, bool], str]
-
-
-async def _get_help_text(evt: CommandEvent) -> str:
-    cache_key = (evt.is_management, evt.sender.puppet_whitelisted,
-                 evt.sender.matrix_puppet_whitelisted, evt.sender.is_admin,
-                 await evt.sender.is_logged_in())
-    if cache_key not in help_cache:
-        help_sections = {}  # type: Dict[HelpSection, List[str]]
-        for handler in _command_handlers.values():
-            if handler.has_help and handler.has_permission(*cache_key):
-                help_sections.setdefault(handler.help_section, [])
-                help_sections[handler.help_section].append(handler.help + "  ")
-        help_sorted = sorted(help_sections.items(), key=lambda item: item[0].order)
-        helps = ["#### {}\n{}\n".format(key.name, "\n".join(value)) for key, value in help_sorted]
-        help_cache[cache_key] = "\n".join(helps)
-    return help_cache[cache_key]
-
-
-def _get_management_status(evt: CommandEvent) -> str:
-    if evt.is_management:
-        return "This is a management room: prefixing commands with `$cmdprefix` is not required."
-    elif evt.is_portal:
-        return ("**This is a portal room**: you must always prefix commands with `$cmdprefix`.\n"
-                "Management commands will not be sent to Telegram.")
-    return "**This is not a management room**: you must prefix commands with `$cmdprefix`."
-
-
-@command_handler(name="help", needs_auth=False, needs_puppeting=False,
-                 help_section=SECTION_GENERAL,
-                 help_text="Show this help message.")
-async def help_cmd(evt: CommandEvent) -> Optional[Dict]:
-    return await evt.reply(_get_management_status(evt) + "\n" + await _get_help_text(evt))

mautrix_telegram/commands/portal/admin.py

@@ -13,10 +13,10 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict
 import asyncio
 
-from mautrix_appservice import MatrixRequestError
+from mautrix.errors import MatrixRequestError
+from mautrix.types import EventID
 
 from ... import portal as po, puppet as pu, user as u
 from .. import command_handler, CommandEvent, SECTION_ADMIN
@@ -26,7 +26,7 @@ from .. import command_handler, CommandEvent, SECTION_ADMIN
                  help_section=SECTION_ADMIN,
                  help_args="<_level_> [_mxid_]",
                  help_text="Set a temporary power level without affecting Telegram.")
-async def set_power_level(evt: CommandEvent) -> Dict:
+async def set_power_level(evt: CommandEvent) -> EventID:
     try:
         level = int(evt.args[0])
     except KeyError:
@@ -35,20 +35,19 @@ async def set_power_level(evt: CommandEvent) -> Dict:
         return await evt.reply("The level must be an integer.")
     levels = await evt.az.intent.get_power_levels(evt.room_id)
     mxid = evt.args[1] if len(evt.args) > 1 else evt.sender.mxid
-    levels["users"][mxid] = level
+    levels.users[mxid] = level
     try:
-        await evt.az.intent.set_power_levels(evt.room_id, levels)
+        return await evt.az.intent.set_power_levels(evt.room_id, levels)
     except MatrixRequestError:
         evt.log.exception("Failed to set power level.")
         return await evt.reply("Failed to set power level.")
-    return {}
 
 
 @command_handler(needs_admin=True, needs_auth=False,
                  help_section=SECTION_ADMIN,
                  help_args="<`portal`|`puppet`|`user`>",
                  help_text="Clear internal bridge caches")
-async def clear_db_cache(evt: CommandEvent) -> Dict:
+async def clear_db_cache(evt: CommandEvent) -> EventID:
     try:
         section = evt.args[0].lower()
     except IndexError:
@@ -62,9 +61,8 @@ async def clear_db_cache(evt: CommandEvent) -> Dict:
         for puppet in pu.Puppet.by_custom_mxid.values():
             puppet.sync_task.cancel()
         pu.Puppet.by_custom_mxid = {}
-        await asyncio.gather(
-            *[puppet.init_custom_mxid() for puppet in pu.Puppet.all_with_custom_mxid()],
-            loop=evt.loop)
+        await asyncio.gather(*[puppet.start() for puppet in pu.Puppet.all_with_custom_mxid()],
+                             loop=evt.loop)
         await evt.reply("Cleared puppet cache and restarted custom puppet syncers")
     elif section == "user":
         u.User.by_mxid = {
@@ -80,7 +78,7 @@ async def clear_db_cache(evt: CommandEvent) -> Dict:
                  help_section=SECTION_ADMIN,
                  help_args="[_mxid_]",
                  help_text="Reload and reconnect a user")
-async def reload_user(evt: CommandEvent) -> Dict:
+async def reload_user(evt: CommandEvent) -> EventID:
     if len(evt.args) > 0:
         mxid = evt.args[0]
     else:
@@ -96,5 +94,5 @@ async def reload_user(evt: CommandEvent) -> Dict:
     user = u.User.get_by_mxid(mxid)
     await user.ensure_started()
     if puppet:
-        await puppet.init_custom_mxid()
-    await evt.reply(f"Reloaded and reconnected {user.mxid} (telegram: {user.human_tg_id})")
+        await puppet.start()
+    return await evt.reply(f"Reloaded and reconnected {user.mxid} (telegram: {user.human_tg_id})")

mautrix_telegram/commands/portal/bridge.py

@@ -13,13 +13,14 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict, Optional, Tuple, Coroutine
+from typing import Optional, Tuple, Coroutine
 import asyncio
 
 from telethon.tl.types import ChatForbidden, ChannelForbidden
 
-from ...types import MatrixRoomID, TelegramID
-from ...util import ignore_coro
+from mautrix.types import EventID, RoomID
+
+from ...types import TelegramID
 from ... import portal as po
 from .. import command_handler, CommandEvent, SECTION_CREATING_PORTALS
 from .util import user_has_power_level, get_initial_state
@@ -31,7 +32,7 @@ from .util import user_has_power_level, get_initial_state
                  help_text="Bridge the current Matrix room to the Telegram chat with the given "
                            "ID. The ID must be the prefixed version that you get with the `/id` "
                            "command of the Telegram-side bot.")
-async def bridge(evt: CommandEvent) -> Dict:
+async def bridge(evt: CommandEvent) -> EventID:
     if len(evt.args) == 0:
         return await evt.reply("**Usage:** "
                                "`$cmdprefix+sp bridge <Telegram chat ID> [Matrix room ID]`")
@@ -39,7 +40,7 @@ async def bridge(evt: CommandEvent) -> Dict:
     if evt.args[0] == "--usebot" and evt.sender.is_admin:
         force_use_bot = True
         evt.args = evt.args[1:]
-    room_id = MatrixRoomID(evt.args[1]) if len(evt.args) > 1 else evt.room_id
+    room_id = RoomID(evt.args[1]) if len(evt.args) > 1 else evt.room_id
     that_this = "This" if room_id == evt.room_id else "That"
 
     portal = po.Portal.get_by_mxid(room_id)
@@ -104,7 +105,8 @@ async def bridge(evt: CommandEvent) -> Dict:
 
 
 async def cleanup_old_portal_while_bridging(evt: CommandEvent, portal: "po.Portal"
-                                            ) -> Tuple[bool, Optional[Coroutine[None, None, None]]]:
+                                            ) -> Tuple[
+    bool, Optional[Coroutine[None, None, None]]]:
     if not portal.mxid:
         await evt.reply("The portal seems to have lost its Matrix room between you"
                         "calling `$cmdprefix+sp bridge` and this command.\n\n"
@@ -127,7 +129,7 @@ async def cleanup_old_portal_while_bridging(evt: CommandEvent, portal: "po.Porta
         return False, None
 
 
-async def confirm_bridge(evt: CommandEvent) -> Optional[Dict]:
+async def confirm_bridge(evt: CommandEvent) -> Optional[EventID]:
     status = evt.sender.command_status
     try:
         portal = po.Portal.get_by_tgid(status["tgid"], peer_type=status["peer_type"])
@@ -142,7 +144,7 @@ async def confirm_bridge(evt: CommandEvent) -> Optional[Dict]:
         if not ok:
             return None
         elif coro:
-            ignore_coro(asyncio.ensure_future(coro, loop=evt.loop))
+            asyncio.ensure_future(coro, loop=evt.loop)
             await evt.reply("Cleaning up previous portal room...")
     elif portal.mxid:
         evt.sender.command_status = None
@@ -179,8 +181,7 @@ async def confirm_bridge(evt: CommandEvent) -> Optional[Dict]:
     portal.photo_id = ""
     portal.save()
 
-    ignore_coro(asyncio.ensure_future(portal.update_matrix_room(user, entity, direct,
-                                                                levels=levels),
-                                      loop=evt.loop))
+    asyncio.ensure_future(portal.update_matrix_room(user, entity, direct, levels=levels),
+                          loop=evt.loop)
 
     return await evt.reply("Bridging complete. Portal synchronization should begin momentarily.")

mautrix_telegram/commands/portal/config.py

@@ -13,10 +13,12 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict, Awaitable
+from typing import Awaitable
 from io import StringIO
 
-from ...config import yaml
+from mautrix.util.config import yaml
+from mautrix.types import EventID
+
 from ... import portal as po, util
 from .. import command_handler, CommandEvent, SECTION_PORTAL_MANAGEMENT
 
@@ -54,7 +56,7 @@ async def config(evt: CommandEvent) -> None:
     portal.save()
 
 
-def config_help(evt: CommandEvent) -> Awaitable[Dict]:
+def config_help(evt: CommandEvent) -> Awaitable[EventID]:
     return evt.reply("""**Usage:** `$cmdprefix config <subcommand> [...]`. Subcommands:
 
 * **help** - View this help text.
@@ -67,13 +69,13 @@ def config_help(evt: CommandEvent) -> Awaitable[Dict]:
 """)
 
 
-def config_view(evt: CommandEvent, portal: po.Portal) -> Awaitable[Dict]:
+def config_view(evt: CommandEvent, portal: po.Portal) -> Awaitable[EventID]:
     stream = StringIO()
     yaml.dump(portal.local_config, stream)
     return evt.reply(f"Room-specific config:\n\n```yaml\n{stream.getvalue()}```")
 
 
-def config_defaults(evt: CommandEvent) -> Awaitable[Dict]:
+def config_defaults(evt: CommandEvent) -> Awaitable[EventID]:
     stream = StringIO()
     yaml.dump({
         "bridge_notices": {
@@ -89,7 +91,7 @@ def config_defaults(evt: CommandEvent) -> Awaitable[Dict]:
     return evt.reply(f"Bridge instance wide config:\n\n```yaml\n{stream.getvalue()}```")
 
 
-def config_set(evt: CommandEvent, portal: po.Portal, key: str, value: str) -> Awaitable[Dict]:
+def config_set(evt: CommandEvent, portal: po.Portal, key: str, value: str) -> Awaitable[EventID]:
     if not key or value is None:
         return evt.reply(f"**Usage:** `$cmdprefix+sp config set <key> <value>`")
     elif util.recursive_set(portal.local_config, key, value):
@@ -99,7 +101,7 @@ def config_set(evt: CommandEvent, portal: po.Portal, key: str, value: str) -> Aw
                          "Does the path contain non-map types?")
 
 
-def config_unset(evt: CommandEvent, portal: po.Portal, key: str) -> Awaitable[Dict]:
+def config_unset(evt: CommandEvent, portal: po.Portal, key: str) -> Awaitable[EventID]:
     if not key:
         return evt.reply(f"**Usage:** `$cmdprefix+sp config unset <key>`")
     elif util.recursive_del(portal.local_config, key):
@@ -109,7 +111,7 @@ def config_unset(evt: CommandEvent, portal: po.Portal, key: str) -> Awaitable[Di
 
 
 def config_add_del(evt: CommandEvent, portal: po.Portal, key: str, value: str, cmd: str
-                   ) -> Awaitable[Dict]:
+                   ) -> Awaitable[EventID]:
     if not key or value is None:
         return evt.reply(f"**Usage:** `$cmdprefix+sp config {cmd} <key> <value>`")
 

mautrix_telegram/commands/portal/create_chat.py

@@ -13,7 +13,7 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict
+from mautrix.types import EventID
 
 from ... import portal as po
 from ...types import TelegramID
@@ -26,7 +26,7 @@ from .util import user_has_power_level, get_initial_state
                  help_text="Create a Telegram chat of the given type for the current Matrix room. "
                            "The type is either `group`, `supergroup` or `channel` (defaults to "
                            "`group`).")
-async def create(evt: CommandEvent) -> Dict:
+async def create(evt: CommandEvent) -> EventID:
     type = evt.args[0] if len(evt.args) > 0 else "group"
     if type not in {"chat", "group", "supergroup", "channel"}:
         return await evt.reply(

mautrix_telegram/commands/portal/filter.py

@@ -13,7 +13,7 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict, Optional
+from mautrix.types import EventID
 
 from ... import portal as po
 from .. import command_handler, CommandEvent, SECTION_ADMIN
@@ -24,7 +24,7 @@ from .. import command_handler, CommandEvent, SECTION_ADMIN
                  help_args="<`whitelist`|`blacklist`>",
                  help_text="Change whether the bridge will allow or disallow bridging rooms by "
                            "default.")
-async def filter_mode(evt: CommandEvent) -> Dict:
+async def filter_mode(evt: CommandEvent) -> EventID:
     try:
         mode = evt.args[0]
         if mode not in ("whitelist", "blacklist"):
@@ -49,7 +49,7 @@ async def filter_mode(evt: CommandEvent) -> Dict:
                  help_section=SECTION_ADMIN,
                  help_args="<`whitelist`|`blacklist`> <_chat ID_>",
                  help_text="Allow or disallow bridging a specific chat.")
-async def edit_filter(evt: CommandEvent) -> Optional[Dict]:
+async def edit_filter(evt: CommandEvent) -> EventID:
     try:
         action = evt.args[0]
         if action not in ("whitelist", "blacklist", "add", "remove"):
@@ -91,4 +91,5 @@ async def edit_filter(evt: CommandEvent) -> Optional[Dict]:
         filter_id_list.remove(filter_id)
         save()
         return await evt.reply(f"Chat ID removed from {mode}.")
-    return None
+    else:
+        return await evt.reply("**Usage:** `$cmdprefix+sp filter <whitelist/blacklist> <chat ID>`")

mautrix_telegram/commands/portal/misc.py

@@ -13,11 +13,11 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict
-
 from telethon.errors import (ChatAdminRequiredError, UsernameInvalidError,
                              UsernameNotModifiedError, UsernameOccupiedError)
 
+from mautrix.types import EventID
+
 from ... import portal as po
 from .. import command_handler, CommandEvent, SECTION_PORTAL_MANAGEMENT, SECTION_MISC
 from .util import user_has_power_level
@@ -26,7 +26,7 @@ from .util import user_has_power_level
 @command_handler(needs_admin=False, needs_puppeting=False, needs_auth=False,
                  help_section=SECTION_MISC,
                  help_text="Fetch Matrix room state to ensure the bridge has up-to-date info.")
-async def sync_state(evt: CommandEvent) -> Dict:
+async def sync_state(evt: CommandEvent) -> EventID:
     portal = po.Portal.get_by_mxid(evt.room_id)
     if not portal:
         return await evt.reply("This is not a portal room.")
@@ -40,7 +40,7 @@ async def sync_state(evt: CommandEvent) -> Dict:
 @command_handler(name="id", needs_admin=False, needs_puppeting=False, needs_auth=False,
                  help_section=SECTION_MISC,
                  help_text="Get the ID of the Telegram chat where this room is bridged.")
-async def get_id(evt: CommandEvent) -> Dict:
+async def get_id(evt: CommandEvent) -> EventID:
     portal = po.Portal.get_by_mxid(evt.room_id)
     if not portal:
         return await evt.reply("This is not a portal room.")
@@ -54,7 +54,7 @@ async def get_id(evt: CommandEvent) -> Dict:
 
 @command_handler(help_section=SECTION_PORTAL_MANAGEMENT,
                  help_text="Get a Telegram invite link to the current chat.")
-async def invite_link(evt: CommandEvent) -> Dict:
+async def invite_link(evt: CommandEvent) -> EventID:
     portal = po.Portal.get_by_mxid(evt.room_id)
     if not portal:
         return await evt.reply("This is not a portal room.")
@@ -73,7 +73,7 @@ async def invite_link(evt: CommandEvent) -> Dict:
 
 @command_handler(help_section=SECTION_PORTAL_MANAGEMENT,
                  help_text="Upgrade a normal Telegram group to a supergroup.")
-async def upgrade(evt: CommandEvent) -> Dict:
+async def upgrade(evt: CommandEvent) -> EventID:
     portal = po.Portal.get_by_mxid(evt.room_id)
     if not portal:
         return await evt.reply("This is not a portal room.")
@@ -95,7 +95,7 @@ async def upgrade(evt: CommandEvent) -> Dict:
                  help_args="<_name_|`-`>",
                  help_text="Change the username of a supergroup/channel. "
                            "To disable, use a dash (`-`) as the name.")
-async def group_name(evt: CommandEvent) -> Dict:
+async def group_name(evt: CommandEvent) -> EventID:
     if len(evt.args) == 0:
         return await evt.reply("**Usage:** `$cmdprefix+sp group-name <name/->`")
 

mautrix_telegram/commands/portal/unbridge.py

@@ -15,7 +15,8 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 from typing import Dict, Callable, Optional
 
-from ...types import MatrixRoomID
+from mautrix.types import RoomID, EventID
+
 from ... import portal as po
 from .. import command_handler, CommandEvent, SECTION_PORTAL_MANAGEMENT
 from .util import user_has_power_level
@@ -24,7 +25,7 @@ from .util import user_has_power_level
 async def _get_portal_and_check_permission(evt: CommandEvent, permission: str,
                                            action: Optional[str] = None
                                            ) -> Optional[po.Portal]:
-    room_id = MatrixRoomID(evt.args[0]) if len(evt.args) > 0 else evt.room_id
+    room_id = RoomID(evt.args[0]) if len(evt.args) > 0 else evt.room_id
 
     portal = po.Portal.get_by_mxid(room_id)
     if not portal:
@@ -41,7 +42,7 @@ async def _get_portal_and_check_permission(evt: CommandEvent, permission: str,
 
 def _get_portal_murder_function(action: str, room_id: str, function: Callable, command: str,
                                 completed_message: str) -> Dict:
-    async def post_confirm(confirm) -> Optional[Dict]:
+    async def post_confirm(confirm) -> Optional[EventID]:
         confirm.sender.command_status = None
         if len(confirm.args) > 0 and confirm.args[0] == f"confirm-{command}":
             await function()
@@ -62,7 +63,7 @@ def _get_portal_murder_function(action: str, room_id: str, function: Callable, c
                  help_text="Remove all users from the current portal room and forget the portal. "
                            "Only works for group chats; to delete a private chat portal, simply "
                            "leave the room.")
-async def delete_portal(evt: CommandEvent) -> Optional[Dict]:
+async def delete_portal(evt: CommandEvent) -> Optional[EventID]:
     portal = await _get_portal_and_check_permission(evt, "unbridge")
     if not portal:
         return None
@@ -83,7 +84,7 @@ async def delete_portal(evt: CommandEvent) -> Optional[Dict]:
 @command_handler(needs_auth=False, needs_puppeting=False,
                  help_section=SECTION_PORTAL_MANAGEMENT,
                  help_text="Remove puppets from the current portal room and forget the portal.")
-async def unbridge(evt: CommandEvent) -> Optional[Dict]:
+async def unbridge(evt: CommandEvent) -> Optional[EventID]:
     portal = await _get_portal_and_check_permission(evt, "unbridge")
     if not portal:
         return None

mautrix_telegram/commands/portal/util.py

@@ -13,43 +13,48 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict, Tuple
+from typing import Tuple, Optional
 
-from mautrix_appservice import MatrixRequestError, IntentAPI
+from mautrix.errors import MatrixRequestError
+from mautrix.appservice import IntentAPI
+from mautrix.types import RoomID, EventType, PowerLevelStateEventContent
 
 from ... import user as u
 
+OptStr = Optional[str]
 
-async def get_initial_state(intent: IntentAPI, room_id: str) -> Tuple[str, str, Dict]:
-    state = await intent.get_room_state(room_id)
-    title = None
-    about = None
-    levels = None
+
+async def get_initial_state(intent: IntentAPI, room_id: RoomID
+                            ) -> Tuple[OptStr, OptStr, Optional[PowerLevelStateEventContent]]:
+    state = await intent.get_state(room_id)
+    title: OptStr = None
+    about: OptStr = None
+    levels: Optional[PowerLevelStateEventContent] = None
     for event in state:
         try:
-            if event["type"] == "m.room.name":
-                title = event["content"]["name"]
-            elif event["type"] == "m.room.topic":
-                about = event["content"]["topic"]
-            elif event["type"] == "m.room.power_levels":
-                levels = event["content"]
-            elif event["type"] == "m.room.canonical_alias":
-                title = title or event["content"]["alias"]
+            if event.type == EventType.ROOM_NAME:
+                title = event.content.name
+            elif event.type == EventType.ROOM_TOPIC:
+                about = event.content.topic
+            elif event.type == EventType.ROOM_POWER_LEVELS:
+                levels = event.content
+            elif event.type == EventType.ROOM_CANONICAL_ALIAS:
+                title = title or event.content.canonical_alias
         except KeyError:
             # Some state event probably has empty content
             pass
     return title, about, levels
 
 
-async def user_has_power_level(room: str, intent, sender: u.User, event: str, default: int = 50
-                               ) -> bool:
+async def user_has_power_level(room_id: RoomID, intent: IntentAPI, sender: u.User,
+                               event: str) -> bool:
     if sender.is_admin:
         return True
     # Make sure the state store contains the power levels.
     try:
-        await intent.get_power_levels(room)
+        await intent.get_power_levels(room_id)
     except MatrixRequestError:
         return False
-    return intent.state_store.has_power_level(room, sender.mxid,
-                                              event=f"net.maunium.telegram.{event}",
-                                              default=default)
+    event_type = EventType.find(f"net.maunium.telegram.{event}")
+    event_type.t_class = EventType.Class.STATE
+    return intent.state_store.has_power_level(room_id, sender.mxid, event_type)

mautrix_telegram/commands/telegram/account.py

@@ -21,6 +21,8 @@ from telethon.tl.types import Authorization
 from telethon.tl.functions.account import (UpdateUsernameRequest, GetAuthorizationsRequest,
                                            ResetAuthorizationRequest, UpdateProfileRequest)
 
+from mautrix.types import EventID
+
 from .. import command_handler, CommandEvent, SECTION_AUTH