Bump version to 0.6.0rc1

Ignore Riot web brokenness in edits
Fix some errors
2019-09-03 00:23:35 +03:00 · 2019-09-03 00:22:45 +03:00 · 2019-09-03 00:17:52 +03:00
157 changed files with 9784 additions and 17925 deletions
@@ -0,0 +1,8 @@
+engines:
+  sonar-python:
+    enabled: true
+    checks:
+      python:S107:
+        enabled: false
+exclude_patterns:
+- "alembic/"
@@ -2,9 +2,3 @@
 .codeclimate.yml
 *.png
 *.md
-logs
-.venv
-start
-config.yaml
-registration.yaml
-*.db
@@ -8,14 +8,8 @@ charset = utf-8
 trim_trailing_whitespace = true
 insert_final_newline = true

-[*.md]
-trim_trailing_whitespace = false
-
 [*.py]
 max_line_length = 99

 [*.{yaml,yml,py}]
 indent_style = space
-
-[{.gitlab-ci.yml,.pre-commit-config.yaml,mautrix_telegram/web/provisioning/spec.yaml}]
-indent_size = 2
@@ -1,7 +0,0 @@
---
-name: Bug report
-about: If something is definitely wrong in the bridge (rather than just a setup issue),
-  file a bug report. Remember to include relevant logs.
-labels: bug
-
---
@@ -1,7 +0,0 @@
-contact_links:
-  - name: Troubleshooting docs & FAQ
-    url: https://docs.mau.fi/bridges/general/troubleshooting.html
-    about: Check this first if you're having problems setting up the bridge.
-  - name: Support room
-    url: https://matrix.to/#/#telegram:maunium.net
-    about: For setup issues not answered by the troubleshooting docs, ask in the Matrix room.
@@ -1,6 +0,0 @@
---
-name: Enhancement request
-about: Submit a feature request or other suggestion
-labels: enhancement
-
---
@@ -1,26 +0,0 @@
-name: Python lint
-
-on: [push, pull_request]
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-python@v2
-      with:
-        python-version: "3.11"
-    - uses: isort/isort-action@master
-      with:
-        sortPaths: "./mautrix_telegram"
-    - uses: psf/black@stable
-      with:
-        src: "./mautrix_telegram"
-        version: "23.1.0"
-    - name: pre-commit
-      run: |
-        pip install pre-commit
-        pre-commit run -av trailing-whitespace
-        pre-commit run -av end-of-file-fixer
-        pre-commit run -av check-yaml
-        pre-commit run -av check-added-large-files
@@ -1,28 +1,17 @@
-/.idea/
+.idea/

-/.venv
-/env/
+.venv
+env/
 pip-selfcheck.json
 *.pyc
 __pycache__
-/build
-/dist
-/*.egg-info
-/.eggs
-
-*.yaml
-!.pre-commit-config.yaml
-!example-config.yaml
-!/mautrix_telegram/web/provisioning/spec.yaml
-!/.github/workflows/*.yaml
-
-/start
-/mautrix
-/telethon
+build
+dist
+*.egg-info
+.eggs

+config.yaml
+registration.yaml
 *.log*
 *.db
-*.db-*
-/*.pickle
 *.bak
-/*.json
@@ -1,3 +0,0 @@
-include:
- project: 'mautrix/ci'
-  file: '/python.yml'
@@ -1,20 +0,0 @@
-repos:
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
-    hooks:
-      - id: trailing-whitespace
-        exclude_types: [markdown]
-      - id: end-of-file-fixer
-      - id: check-yaml
-      - id: check-added-large-files
-  - repo: https://github.com/psf/black
-    rev: 23.1.0
-    hooks:
-      - id: black
-        language_version: python3
-        files: ^mautrix_telegram/.*\.pyi?$
-  - repo: https://github.com/PyCQA/isort
-    rev: 5.12.0
-    hooks:
-      - id: isort
-        files: ^mautrix_telegram/.*\.pyi?$
@@ -1,57 +1,44 @@
-FROM dock.mau.dev/tulir/lottieconverter:alpine-3.18
+FROM docker.io/alpine:3.10

+ENV UID=1337 \
+    GID=1337 \
+    FFMPEG_BINARY=/usr/bin/ffmpeg
+
+COPY . /opt/mautrix-telegram
+WORKDIR /opt/mautrix-telegram
 RUN apk add --no-cache \
-      python3 py3-pip py3-setuptools py3-wheel \
-      #py3-pillow \
+      py3-virtualenv \
+      py3-pillow \
      py3-aiohttp \
      py3-magic \
+      py3-sqlalchemy \
+      py3-markdown \
+      py3-psycopg2 \
      py3-ruamel.yaml \
-      py3-commonmark \
-      py3-phonenumbers \
-      py3-mako \
-      #py3-prometheus-client \ (pulls in twisted unnecessarily)
      # Indirect dependencies
-      py3-idna \
-      py3-rsa \
-      #py3-telethon \ (outdated)
-        py3-pyaes \
-        # cryptg
-          py3-cffi \
-          py3-qrcode \
-      py3-brotli \
+      #commonmark
+        py3-future \
+      #alembic
+        py3-mako \
+        py3-dateutil \
+        py3-markupsafe \
+      #moviepy
+        py3-decorator \
+        #py3-tqdm \
+        py3-requests \
+        #imageio
+          py3-numpy \
+      #telethon
+        py3-rsa \
      # Other dependencies
+      python3-dev \
+      libffi-dev \
+      build-base \
      ffmpeg \
      ca-certificates \
      su-exec \
-      netcat-openbsd \
-      # encryption
-      py3-olm \
-      py3-pycryptodome \
-      py3-unpaddedbase64 \
-      py3-future \
-      bash \
-      curl \
-      jq \
-      yq \
-  # Temporarily install pillow from edge repo to get up-to-date version
-  && apk add --no-cache py3-pillow --repository=https://dl-cdn.alpinelinux.org/alpine/edge/community
-
-COPY requirements.txt /opt/mautrix-telegram/requirements.txt
-COPY optional-requirements.txt /opt/mautrix-telegram/optional-requirements.txt
-WORKDIR /opt/mautrix-telegram
-RUN apk add --virtual .build-deps python3-dev libffi-dev build-base \
- && pip3 install /cryptg-*.whl \
- && pip3 install --no-cache-dir -r requirements.txt -r optional-requirements.txt \
- && apk del .build-deps \
- && rm -f /cryptg-*.whl
-
-COPY . /opt/mautrix-telegram
-RUN apk add git && pip3 install --no-cache-dir .[all] && apk del git \
-  # This doesn't make the image smaller, but it's needed so that the `version` command works properly
-  && cp mautrix_telegram/example-config.yaml . && rm -rf mautrix_telegram .git build
+ && pip3 install .[all]

 VOLUME /data
-ENV UID=1337 GID=1337 \
-    FFMPEG_BINARY=/usr/bin/ffmpeg

 CMD ["/opt/mautrix-telegram/docker-run.sh"]
@@ -1,5 +0,0 @@
-include README.md
-include CHANGELOG.md
-include LICENSE
-include requirements.txt
-include optional-requirements.txt
@@ -1,30 +1,9 @@
 # mautrix-telegram
-![Languages](https://img.shields.io/github/languages/top/mautrix/telegram.svg)
-[![License](https://img.shields.io/github/license/mautrix/telegram.svg)](LICENSE)
-[![Release](https://img.shields.io/github/release/mautrix/telegram/all.svg)](https://github.com/mautrix/telegram/releases)
-[![GitLab CI](https://mau.dev/mautrix/telegram/badges/master/pipeline.svg)](https://mau.dev/mautrix/telegram/container_registry)
-[![Code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-[![Imports](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
-
 A Matrix-Telegram hybrid puppeting/relaybot bridge.

-## Sponsors
-* [Joel Lehtonen / Zouppen](https://github.com/zouppen)
+### [Wiki](https://github.com/tulir/mautrix-telegram/wiki)

-## Documentation
-All setup and usage instructions are located on
-[docs.mau.fi](https://docs.mau.fi/bridges/python/telegram/index.html).
-Some quick links:
-
-* [Bridge setup](https://docs.mau.fi/bridges/python/setup.html?bridge=telegram)
-  (or [with Docker](https://docs.mau.fi/bridges/general/docker-setup.html?bridge=telegram))
-* Basic usage: [Authentication](https://docs.mau.fi/bridges/python/telegram/authentication.html),
-  [Creating chats](https://docs.mau.fi/bridges/python/telegram/creating-and-managing-chats.html),
-  [Relaybot setup](https://docs.mau.fi/bridges/python/telegram/relay-bot.html)
-
-### Features & Roadmap
-[ROADMAP.md](https://github.com/mautrix/telegram/blob/master/ROADMAP.md)
-contains a general overview of what is supported by the bridge.
+### [Features & Roadmap](https://github.com/tulir/mautrix-telegram/blob/master/ROADMAP.md)

 ## Discussion
 Matrix room: [`#telegram:maunium.net`](https://matrix.to/#/#telegram:maunium.net)
@@ -32,4 +11,4 @@ Matrix room: [`#telegram:maunium.net`](https://matrix.to/#/#telegram:maunium.net
 Telegram chat: [`mautrix_telegram`](https://t.me/mautrix_telegram) (bridged to Matrix room)

 ## Preview
-![Preview](preview.png)
+![Preview](https://raw.githubusercontent.com/tulir/mautrix-telegram/master/preview.png)
@@ -3,7 +3,6 @@
 * Matrix → Telegram
  * [x] Message content (text, formatting, files, etc..)
  * [x] Message redactions
-  * [x] Message reactions
  * [x] Message edits
  * [ ] ‡ Message history
  * [x] Presence
@@ -13,8 +12,8 @@
  * [x] Power level
    * [x] Normal chats
      * [ ] Non-hardcoded PL requirements
-    * [x] Supergroups/channels
-      * [ ] Precise bridging (non-hardcoded PL requirements, bridge specific permissions, etc..)
+	* [x] Supergroups/channels
+	  * [ ] Precise bridging (non-hardcoded PL requirements, bridge specific permissions, etc..)
  * [x] Membership actions (invite/kick/join/leave)
  * [x] Room metadata changes (name, topic, avatar)
  * [x] Initial room metadata
@@ -24,17 +23,12 @@
 * Telegram → Matrix
  * [x] Message content (text, formatting, files, etc..)
  * [ ] Advanced message content/media
-    * [x] Custom emojis
    * [x] Polls
 	* [x] Games
 	* [ ] Buttons
  * [x] Message deletions
-  * [x] Message reactions
  * [x] Message edits
-  * [x] Message history
-    * [x] Manually (`!tg backfill`)
-    * [x] Automatically when creating portal
-    * [x] Automatically for missed messages
+  * [ ] Message history
  * [x] Avatars
  * [x] Presence
  * [x] Typing notifications
@@ -55,12 +49,12 @@
  * [x] Automatic portal creation
    * [x] At startup
    * [x] When receiving invite or message
-  * [x] Portal creation by inviting Matrix puppet of Telegram user to new room
-  * [x] Option to use bot to relay messages for unauthenticated Matrix users (relaybot)
-  * [x] Option to use own Matrix account for messages sent from other Telegram clients (double puppeting)
+  * [x] Private chat creation by inviting Matrix puppet of Telegram user to new room
+  * [x] Option to use bot to relay messages for unauthenticated Matrix users
+  * [x] Option to use own Matrix account for messages sent from other Telegram clients
  * [ ] ‡ Calls (hard, not yet supported by Telethon)
-  * [ ] ‡ Secret chats (i.e. End-to-bridge encryption on Telegram)
-  * [x] End-to-bridge encryption in Matrix rooms (see [docs](https://docs.mau.fi/bridges/general/end-to-bridge-encryption.html))
+  * [ ] ‡ Secret chats (not yet supported by Telethon)
+  * [ ] ‡ E2EE in Matrix rooms (not yet supported 

 † Information not automatically sent from source, i.e. implementation may not be possible  
 ‡ Maybe, i.e. this feature may or may not be implemented at some point
@@ -0,0 +1,71 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = alembic
+
+# template used to generate migration files
+# file_template = %%(rev)s_%%(slug)s
+
+# timezone to use when rendering the date
+# within the migration file as well as the filename.
+# string value is passed to dateutil.tz.gettz()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+#truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; this defaults
+# to alembic/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path
+# version_locations = %(here)s/bar %(here)s/bat alembic/versions
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S
@@ -0,0 +1 @@
+Generic single-database configuration.
@@ -0,0 +1,95 @@
+from alembic import context
+from sqlalchemy import engine_from_config, pool
+from logging.config import fileConfig
+
+import sys
+from os.path import abspath, dirname
+
+sys.path.insert(0, dirname(dirname(abspath(__file__))))
+
+from mautrix_telegram.db import Base
+from mautrix_telegram.config import Config
+from alchemysession import AlchemySessionContainer
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+mxtg_config_path = context.get_x_argument(as_dictionary=True).get("config", "config.yaml")
+mxtg_config = Config(mxtg_config_path, None, None)
+mxtg_config.load()
+config.set_main_option("sqlalchemy.url",
+                       mxtg_config.get("appservice.database", "sqlite:///mautrix-telegram.db"))
+
+
+class FakeDB:
+    @staticmethod
+    def query_property():
+        return None
+
+
+AlchemySessionContainer.create_table_classes(FakeDB(), "telethon_", Base)
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = Base.metadata
+
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline():
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url, target_metadata=target_metadata, literal_binds=True)
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online():
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section),
+        prefix='sqlalchemy.',
+        poolclass=pool.NullPool)
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()
@@ -0,0 +1,24 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade():
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade():
+    ${downgrades if downgrades else "pass"}
@@ -0,0 +1,27 @@
+"""Add disable_updates field for puppets
+
+Revision ID: 17574c57f3f8
+Revises: a9119be92164
+Create Date: 2019-05-15 00:24:46.967529
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '17574c57f3f8'
+down_revision = 'a9119be92164'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table("puppet") as batch_op:
+        batch_op.add_column(sa.Column("disable_updates", sa.Boolean(), nullable=False,
+                                      server_default=sa.sql.expression.false()))
+
+
+def downgrade():
+    with op.batch_alter_table("puppet") as batch_op:
+        batch_op.drop_column("disable_updates")
@@ -0,0 +1,28 @@
+"""Add TelegramFile table
+
+Revision ID: 1b241f7e8530
+Revises: 97d2a942bcf8
+Create Date: 2018-02-19 23:52:06.605741
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = '1b241f7e8530'
+down_revision = '97d2a942bcf8'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.create_table('telegram_file',
+                    sa.Column('id', sa.String(), nullable=False),
+                    sa.Column('mxc', sa.String(), nullable=True),
+                    sa.Column('mime_type', sa.String(), nullable=True),
+                    sa.Column('was_converted', sa.Boolean(), nullable=True),
+                    sa.PrimaryKeyConstraint('id'))
+
+
+def downgrade():
+    op.drop_table('telegram_file')
@@ -0,0 +1,26 @@
+"""Add is_bot field to puppets
+
+Revision ID: 1fa46383a9d3
+Revises: 30eca60587f1
+Create Date: 2018-04-29 23:44:40.102333
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '1fa46383a9d3'
+down_revision = '30eca60587f1'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table("puppet") as batch_op:
+        batch_op.add_column(sa.Column('is_bot', sa.Boolean(), nullable=True))
+
+
+def downgrade():
+    with op.batch_alter_table("puppet") as batch_op:
+        batch_op.drop_column('is_bot')
@@ -0,0 +1,41 @@
+"""Add cascade rules to UserPortal
+
+Revision ID: 2228d49c383f
+Revises: bcfefa1f1299
+Create Date: 2018-05-31 11:11:59.482112
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = '2228d49c383f'
+down_revision = 'bcfefa1f1299'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    try:
+        with op.batch_alter_table("user_portal") as batch_op:
+            batch_op.drop_constraint("user_portal_user_fkey", type_="foreignkey")
+            batch_op.drop_constraint("user_portal_portal_fkey", type_="foreignkey")
+            batch_op.create_foreign_key("user_portal_user_fkey", "user", ["user"], ["tgid"],
+                                        onupdate="CASCADE", ondelete="CASCADE")
+            batch_op.create_foreign_key("user_portal_portal_fkey", "portal",
+                                        ["portal", "portal_receiver"], ["tgid", "tg_receiver"],
+                                        onupdate="CASCADE", ondelete="CASCADE")
+    except ValueError:
+        return
+
+
+def downgrade():
+    try:
+        with op.batch_alter_table("user_portal") as batch_op:
+                batch_op.drop_constraint("user_portal_user_fkey", type_="foreignkey")
+                batch_op.drop_constraint("user_portal_portal_fkey", type_="foreignkey")
+                batch_op.create_foreign_key("user_portal_user_fkey", "portal",
+                                            ["portal", "portal_receiver"], ["tgid", "tg_receiver"])
+                batch_op.create_foreign_key("user_portal_portal_fkey", "user", ["user"], ["tgid"])
+    except ValueError:
+        return
@@ -0,0 +1,25 @@
+"""Add megagroup field to portals
+
+Revision ID: 30eca60587f1
+Revises: cfc972368e50
+Create Date: 2018-04-29 15:51:04.656605
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = '30eca60587f1'
+down_revision = 'cfc972368e50'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table("portal") as batch_op:
+        batch_op.add_column(sa.Column('megagroup', sa.Boolean()))
+
+
+def downgrade():
+    with op.batch_alter_table("portal") as batch_op:
+        batch_op.drop_column('megagroup')
@@ -0,0 +1,111 @@
+"""Move sessions to main database
+
+Revision ID: 501dad2868bc
+Revises: 7d47d84380b6
+Create Date: 2018-03-02 19:15:53.826985
+
+"""
+from alembic import op
+import sqlalchemy as sa
+import sqlite3
+import os
+
+# revision identifiers, used by Alembic.
+revision = '501dad2868bc'
+down_revision = '7d47d84380b6'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    Session = op.create_table('telethon_sessions',
+                              sa.Column('session_id', sa.String, nullable=False),
+                              sa.Column('dc_id', sa.Integer, nullable=False),
+                              sa.Column('server_address', sa.String, nullable=True),
+                              sa.Column('port', sa.Integer, nullable=True),
+                              sa.Column('auth_key', sa.LargeBinary, nullable=True),
+                              sa.PrimaryKeyConstraint('session_id', 'dc_id'))
+    SentFile = op.create_table('telethon_sent_files',
+                               sa.Column('session_id', sa.String, nullable=False),
+                               sa.Column('md5_digest', sa.LargeBinary, nullable=False),
+                               sa.Column('file_size', sa.Integer, nullable=False),
+                               sa.Column('type', sa.Integer, nullable=False),
+                               sa.Column('id', sa.BigInteger, nullable=True),
+                               sa.Column('hash', sa.BigInteger, nullable=True),
+                               sa.PrimaryKeyConstraint('session_id', 'md5_digest', 'file_size',
+                                                       'type'))
+    Entity = op.create_table('telethon_entities',
+                             sa.Column('session_id', sa.String, nullable=False),
+                             sa.Column('id', sa.Integer, nullable=False),
+                             sa.Column('hash', sa.Integer, nullable=False),
+                             sa.Column('username', sa.String, nullable=True),
+                             sa.Column('phone', sa.Integer, nullable=True),
+                             sa.Column('name', sa.String, nullable=True),
+                             sa.PrimaryKeyConstraint('session_id', 'id'))
+    Version = op.create_table('telethon_version',
+                              sa.Column('version', sa.Integer, nullable=False),
+                              sa.PrimaryKeyConstraint('version'))
+    conn = op.get_bind()
+    sessions = [os.path.basename(f) for f in os.listdir(".") if f.endswith(".session")]
+    for session in sessions:
+        session_to_sqlalchemy(conn, session, Session, SentFile, Entity)
+
+
+def session_to_sqlalchemy(conn, path, Session, SentFile, Entity):
+    session_conn = sqlite3.connect(path)
+    session_id = os.path.splitext(path)[0]
+    c = session_conn.cursor()
+
+    auth_data_tuples = c.execute("SELECT * FROM sessions").fetchall()
+    auth_data_dicts = []
+    for row in auth_data_tuples:
+        dc_id, server_address, port, auth_key = row
+        auth_data_dicts.append({
+            "session_id": session_id,
+            "dc_id": dc_id,
+            "server_address": server_address,
+            "port": port,
+            "auth_key": auth_key,
+        })
+    if auth_data_dicts:
+        conn.execute(Session.insert().values(auth_data_dicts))
+
+    sent_file_tuples = c.execute("SELECT * FROM sent_files").fetchall()
+    sent_file_dicts = []
+    for row in sent_file_tuples:
+        md5_digest, file_size, type, id, hash = row
+        sent_file_dicts.append({
+            "session_id": session_id,
+            "md5_digest": md5_digest,
+            "file_size": file_size,
+            "type": type,
+            "id": id,
+            "hash": hash,
+        })
+    if sent_file_dicts:
+        conn.execute(SentFile.insert().values(sent_file_dicts))
+
+    entity_tuples = c.execute("SELECT * FROM entities").fetchall()
+    entity_dicts = []
+    for row in entity_tuples:
+        id, hash, username, phone, name = row
+        entity_dicts.append({
+            "session_id": session_id,
+            "id": id,
+            "hash": hash,
+            "username": username,
+            "phone": phone,
+            "name": name,
+        })
+    if entity_dicts:
+        conn.execute(Entity.insert().values(entity_dicts))
+
+    c.close()
+    session_conn.close()
+
+
+def downgrade():
+    op.drop_table('telethon_version')
+    op.drop_table('telethon_entities')
+    op.drop_table('telethon_sent_files')
+    op.drop_table('telethon_sessions')
@@ -0,0 +1,137 @@
+"""Move state store to main database
+
+Revision ID: 6ca3d74d51e4
+Revises: 2228d49c383f
+Create Date: 2018-06-26 21:31:26.911307
+
+"""
+from alembic import context, op
+import sqlalchemy.orm as orm
+import sqlalchemy as sa
+import json
+import re
+
+from mautrix_telegram.config import Config
+from mautrix_telegram.db import Base
+
+# revision identifiers, used by Alembic.
+revision = "6ca3d74d51e4"
+down_revision = "2228d49c383f"
+branch_labels = None
+depends_on = None
+
+
+class RoomState(Base):
+    query = None
+    __tablename__ = "mx_room_state"
+    __table_args__ = {"extend_existing": True}
+
+    room_id = sa.Column(sa.String, primary_key=True)
+    power_levels = sa.Column("power_levels", sa.Text, nullable=True)
+
+
+class UserProfile(Base):
+    query = None
+    __tablename__ = "mx_user_profile"
+    __table_args__ = {"extend_existing": True}
+
+    room_id = sa.Column(sa.String, primary_key=True)
+    user_id = sa.Column(sa.String, primary_key=True)
+    membership = sa.Column(sa.String, nullable=False, default="leave")
+    displayname = sa.Column(sa.String, nullable=True)
+    avatar_url = sa.Column(sa.String, nullable=True)
+
+
+class Puppet(Base):
+    query = None
+    __tablename__ = "puppet"
+    __table_args__ = {"extend_existing": True}
+
+    id = sa.Column(sa.Integer, primary_key=True)
+    displayname = sa.Column(sa.String, nullable=True)
+    displayname_source = sa.Column(sa.Integer, nullable=True)
+    username = sa.Column(sa.String, nullable=True)
+    photo_id = sa.Column(sa.String, nullable=True)
+    is_bot = sa.Column(sa.Boolean, nullable=True)
+    matrix_registered = sa.Column(sa.Boolean, nullable=False, default=False)
+
+
+def upgrade():
+    with op.batch_alter_table("puppet") as batch_op:
+        batch_op.add_column(sa.Column("matrix_registered", sa.Boolean(), nullable=False,
+                                      server_default=sa.sql.expression.false()))
+    op.create_table("mx_room_state",
+                    sa.Column("room_id", sa.String(), nullable=False),
+                    sa.Column("power_levels", sa.Text(), nullable=True),
+                    sa.PrimaryKeyConstraint("room_id"))
+    op.create_table("mx_user_profile",
+                    sa.Column("room_id", sa.String(), nullable=False),
+                    sa.Column("user_id", sa.String(), nullable=False),
+                    sa.Column("membership", sa.String(), nullable=False,
+                              default="leave"),
+                    sa.Column("displayname", sa.String(), nullable=True),
+                    sa.Column("avatar_url", sa.String(), nullable=True),
+                    sa.PrimaryKeyConstraint("room_id", "user_id"))
+
+    try:
+        migrate_state_store()
+    except Exception as e:
+        print("Failed to migrate state store:", e)
+        print("Migrating the state store isn't required, but you can retry by alembic downgrading "
+              "to revision 2228d49c383f and upgrading again.")
+
+
+def migrate_state_store():
+    conn = op.get_bind()
+    session = orm.sessionmaker(bind=conn)()  # type: orm.Session
+
+    try:
+        with open("mx-state.json") as file:
+            data = json.load(file)
+    except FileNotFoundError:
+        return
+    if not data:
+        return
+    registrations = data.get("registrations", [])
+
+    mxtg_config_path = context.get_x_argument(as_dictionary=True).get("config", "config.yaml")
+    mxtg_config = Config(mxtg_config_path, None, None)
+    mxtg_config.load()
+
+    username_template = mxtg_config.get("bridge.username_template", "telegram_{userid}")
+    hs_domain = mxtg_config["homeserver.domain"]
+    localpart = username_template.format(userid="(.+)")
+    mxid_regex = re.compile("@{}:{}".format(localpart, hs_domain))
+    for user in registrations:
+        match = mxid_regex.match(user)
+        if not match:
+            continue
+
+        puppet = session.query(Puppet).get(match.group(1))
+        if not puppet:
+            continue
+
+        puppet.matrix_registered = True
+        session.merge(puppet)
+    session.commit()
+
+    user_profiles = [UserProfile(room_id=room, user_id=user,
+                                 membership=member.get("membership", "leave"),
+                                 displayname=member.get("displayname", None),
+                                 avatar_url=member.get("avatar_url", None))
+                     for room, members in data.get("members", {}).items()
+                     for user, member in members.items()]
+    session.add_all(user_profiles)
+    session.commit()
+
+    room_state = [RoomState(room_id=room, power_levels=json.dumps(levels))
+                  for room, levels in data.get("power_levels", {}).items()]
+    session.add_all(room_state)
+    session.commit()
+
+
+def downgrade():
+    op.drop_table("mx_user_profile")
+    op.drop_table("mx_room_state")
+    with op.batch_alter_table("puppet") as batch_op:
+        batch_op.drop_column("matrix_registered")
@@ -0,0 +1,26 @@
+"""Add timestamp to TelegramFile
+
+Revision ID: 7d47d84380b6
+Revises: 1b241f7e8530
+Create Date: 2018-02-19 23:53:18.050871
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = '7d47d84380b6'
+down_revision = '1b241f7e8530'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.add_column('telegram_file',
+                  sa.Column('timestamp', sa.BigInteger(), nullable=True, default=0,
+                            server_default="0"))
+
+
+def downgrade():
+    with op.batch_alter_table("telegram_file") as batch_op:
+        batch_op.drop_column('timestamp')
@@ -0,0 +1,80 @@
+"""initial revision
+
+Revision ID: 97d2a942bcf8
+Revises:
+Create Date: 2018-02-11 18:40:55.483842
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = '97d2a942bcf8'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.create_table('portal',
+                    sa.Column('tgid', sa.Integer),
+                    sa.Column('tg_receiver', sa.Integer),
+                    sa.Column('peer_type', sa.String, nullable=False, default=""),
+                    sa.Column('mxid', sa.String, nullable=True),
+                    sa.Column('username', sa.String, nullable=True),
+                    sa.Column('title', sa.String, nullable=True),
+                    sa.Column('about', sa.String, nullable=True),
+                    sa.Column('photo_id', sa.String, nullable=True),
+                    sa.PrimaryKeyConstraint('tgid', 'tg_receiver'),
+                    sa.UniqueConstraint('mxid'))
+    op.create_table('user',
+                    sa.Column('mxid', sa.String),
+                    sa.Column('tgid', sa.Integer, nullable=True, unique=True),
+                    sa.Column('tg_username', sa.String, nullable=True),
+                    sa.Column('saved_contacts', sa.Integer, nullable=False, default=0),
+                    sa.PrimaryKeyConstraint('mxid'))
+    op.create_table('puppet',
+                    sa.Column('id', sa.Integer),
+                    sa.Column('displayname', sa.String, nullable=True),
+                    sa.Column('username', sa.String, nullable=True),
+                    sa.Column('photo_id', sa.String, nullable=True),
+                    sa.PrimaryKeyConstraint('id'))
+    op.create_table('contact',
+                    sa.Column('user', sa.Integer),
+                    sa.Column('contact', sa.Integer),
+                    sa.ForeignKeyConstraint(("user",), ("user.tgid",)),
+                    sa.ForeignKeyConstraint(("contact",), ("puppet.id",)),
+                    sa.PrimaryKeyConstraint('user', 'contact'))
+    op.create_table('user_portal',
+                    sa.Column('user', sa.Integer),
+                    sa.Column('portal', sa.Integer),
+                    sa.Column('portal_receiver', sa.Integer),
+                    sa.PrimaryKeyConstraint('user', 'portal', 'portal_receiver'),
+                    sa.ForeignKeyConstraint(("user",), ("user.tgid",),
+                                            name="user_portal_user_fkey",
+                                            onupdate="CASCADE", ondelete="CASCADE"),
+                    sa.ForeignKeyConstraint(("portal", "portal_receiver"),
+                                            ("portal.tgid", "portal.tg_receiver"),
+                                            name="user_portal_portal_fkey",
+                                            onupdate="CASCADE", ondelete="CASCADE"))
+    op.create_table('message',
+                    sa.Column('mxid', sa.String),
+                    sa.Column('mx_room', sa.String),
+                    sa.Column('tgid', sa.Integer),
+                    sa.Column('tg_space', sa.Integer),
+                    sa.PrimaryKeyConstraint('tgid', 'tg_space'),
+                    sa.UniqueConstraint("mxid", "mx_room", "tg_space", name="_mx_id_room"))
+    op.create_table('bot_chat',
+                    sa.Column('id', sa.Integer),
+                    sa.Column('type', sa.String, nullable=False, default=""),
+                    sa.PrimaryKeyConstraint('id'))
+
+
+def downgrade():
+    op.drop_table('bot_chat')
+    op.drop_table('message')
+    op.drop_table('user_portal')
+    op.drop_table('contact')
+    op.drop_table('puppet')
+    op.drop_table('user')
+    op.drop_table('portal')
@@ -0,0 +1,48 @@
+"""Add edit index to messages
+
+Revision ID: 9e9c89b0b877
+Revises: 17574c57f3f8
+Create Date: 2019-05-29 15:28:23.128377
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = '9e9c89b0b877'
+down_revision = '17574c57f3f8'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.create_table('_message_temp',
+                    sa.Column('mxid', sa.String),
+                    sa.Column('mx_room', sa.String),
+                    sa.Column('tgid', sa.Integer),
+                    sa.Column('tg_space', sa.Integer),
+                    sa.Column('edit_index', sa.Integer),
+                    sa.PrimaryKeyConstraint('tgid', 'tg_space', 'edit_index'),
+                    sa.UniqueConstraint("mxid", "mx_room", "tg_space", name="_mx_id_room_2"))
+    c = op.get_bind()
+    c.execute("INSERT INTO _message_temp (mxid, mx_room, tgid, tg_space, edit_index) "
+              "SELECT message.mxid, message.mx_room, message.tgid, message.tg_space, 0 "
+              "FROM message")
+    c.execute("DROP TABLE message")
+    c.execute("ALTER TABLE _message_temp RENAME TO message")
+
+
+def downgrade():
+    op.create_table('_message_temp',
+                    sa.Column('mxid', sa.String),
+                    sa.Column('mx_room', sa.String),
+                    sa.Column('tgid', sa.Integer),
+                    sa.Column('tg_space', sa.Integer),
+                    sa.PrimaryKeyConstraint('tgid', 'tg_space'),
+                    sa.UniqueConstraint("mxid", "mx_room", "tg_space", name="_mx_id_room"))
+    c = op.get_bind()
+    c.execute("INSERT INTO _message_temp (mxid, mx_room, tgid, tg_space) "
+              "SELECT message.mxid, message.mx_room, message.tgid, message.tg_space "
+              "FROM message")
+    c.execute("DROP TABLE message")
+    c.execute("ALTER TABLE _message_temp RENAME TO message")
@@ -0,0 +1,25 @@
+"""Add phone number field to users
+
+Revision ID: a9119be92164
+Revises: b54929c22c86
+Create Date: 2018-09-28 02:38:40.626282
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = "a9119be92164"
+down_revision = "b54929c22c86"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.add_column("user", sa.Column("tg_phone", sa.String(), nullable=True))
+
+
+def downgrade():
+    with op.batch_alter_table("user") as batch_op:
+        batch_op.drop_column("tg_phone")
@@ -0,0 +1,25 @@
+"""Add portal-specific config
+
+Revision ID: b54929c22c86
+Revises: d5f7b8b4b456
+Create Date: 2018-09-24 23:40:33.528710
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = "b54929c22c86"
+down_revision = "d5f7b8b4b456"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.add_column("portal", sa.Column("config", sa.Text(), nullable=True))
+
+
+def downgrade():
+    with op.batch_alter_table("portal") as batch_op:
+        batch_op.drop_column("config")
@@ -0,0 +1,24 @@
+"""Add displayname source fields for puppets
+
+Revision ID: bcfefa1f1299
+Revises: bdadd173ee02
+Create Date: 2018-05-19 17:00:21.078098
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = 'bcfefa1f1299'
+down_revision = 'bdadd173ee02'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.add_column('puppet', sa.Column('displayname_source', sa.Integer(), nullable=True))
+
+
+def downgrade():
+    with op.batch_alter_table("puppet") as batch_op:
+        batch_op.drop_column('displayname_source')
@@ -0,0 +1,43 @@
+"""Update telethon update state table
+
+Revision ID: bdadd173ee02
+Revises: eeaf0dae87ce
+Create Date: 2018-05-13 10:42:59.395597
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = 'bdadd173ee02'
+down_revision = 'eeaf0dae87ce'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table("telethon_entities") as batch_op:
+        batch_op.alter_column("id", existing_type=sa.Integer, type_=sa.BigInteger)
+        batch_op.alter_column("hash", existing_type=sa.Integer, type_=sa.BigInteger)
+
+    with op.batch_alter_table("telethon_update_state") as batch_op:
+        batch_op.alter_column("entity_id", existing_type=sa.Integer, type_=sa.BigInteger)
+        batch_op.alter_column("pts", existing_type=sa.Integer, type_=sa.BigInteger)
+        batch_op.alter_column("qts", existing_type=sa.Integer, type_=sa.BigInteger)
+        batch_op.alter_column("date", existing_type=sa.Integer, type_=sa.BigInteger)
+        batch_op.alter_column("seq", existing_type=sa.Integer, type_=sa.BigInteger)
+        batch_op.add_column(sa.Column("unread_count", sa.Integer))
+
+
+def downgrade():
+    with op.batch_alter_table("telethon_entities") as batch_op:
+        batch_op.alter_column("id", existing_type=sa.BigInteger, type_=sa.Integer)
+        batch_op.alter_column("hash", existing_type=sa.BigInteger, type_=sa.Integer)
+
+    with op.batch_alter_table("telethon_update_state") as batch_op:
+        batch_op.alter_column("entity_id", existing_type=sa.BigInteger, type_=sa.Integer)
+        batch_op.alter_column("pts", existing_type=sa.BigInteger, type_=sa.Integer)
+        batch_op.alter_column("qts", existing_type=sa.BigInteger, type_=sa.Integer)
+        batch_op.alter_column("date", existing_type=sa.BigInteger, type_=sa.Integer)
+        batch_op.alter_column("seq", existing_type=sa.BigInteger, type_=sa.Integer)
+        batch_op.drop_column("unread_count")
@@ -0,0 +1,35 @@
+"""Add metadata to TelegramFile
+
+Revision ID: cfc972368e50
+Revises: 501dad2868bc
+Create Date: 2018-03-09 16:07:01.236712
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = 'cfc972368e50'
+down_revision = '501dad2868bc'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table("telegram_file") as batch_op:
+        batch_op.add_column(sa.Column('size', sa.Integer(), nullable=True))
+        batch_op.add_column(sa.Column('width', sa.Integer(), nullable=True))
+        batch_op.add_column(sa.Column('height', sa.Integer(), nullable=True))
+        batch_op.add_column(sa.Column('thumbnail', sa.String(), nullable=True))
+        batch_op.create_foreign_key(constraint_name="fk_file_thumbnail",
+                                    referent_table="telegram_file",
+                                    local_cols=['thumbnail'],
+                                    remote_cols=['id'])
+
+
+def downgrade():
+    with op.batch_alter_table("telegram_file") as batch_op:
+        batch_op.drop_column('size')
+        batch_op.drop_column('width')
+        batch_op.drop_column('height')
+        batch_op.drop_column('thumbnail')
@@ -0,0 +1,26 @@
+"""Add access_token and custom_mxid fields for puppets
+
+Revision ID: d5f7b8b4b456
+Revises: 6ca3d74d51e4
+Create Date: 2018-07-20 12:09:30.277960
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = "d5f7b8b4b456"
+down_revision = "6ca3d74d51e4"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.add_column("puppet", sa.Column("access_token", sa.String(), nullable=True))
+    op.add_column("puppet", sa.Column("custom_mxid", sa.String(), nullable=True))
+
+
+def downgrade():
+    with op.batch_alter_table("puppet") as batch_op:
+        batch_op.drop_column("custom_mxid")
+        batch_op.drop_column("access_token")
@@ -0,0 +1,34 @@
+"""Add telethon update state table
+
+Revision ID: eeaf0dae87ce
+Revises: 1fa46383a9d3
+Create Date: 2018-04-30 17:30:59.610885
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = 'eeaf0dae87ce'
+down_revision = '1fa46383a9d3'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table("telethon_entities") as batch_op:
+        batch_op.alter_column('phone', existing_type=sa.Integer, type_=sa.BigInteger)
+    op.create_table('telethon_update_state',
+                    sa.Column('session_id', sa.String, nullable=False),
+                    sa.Column('entity_id', sa.Integer, nullable=False),
+                    sa.Column('pts', sa.Integer, nullable=True),
+                    sa.Column('qts', sa.Integer, nullable=True),
+                    sa.Column('date', sa.Integer, nullable=True),
+                    sa.Column('seq', sa.Integer, nullable=True),
+                    sa.PrimaryKeyConstraint('session_id', 'entity_id'))
+
+
+def downgrade():
+    with op.batch_alter_table("telethon_entities") as batch_op:
+        batch_op.alter_column('phone', existing_type=sa.BigInteger, type_=sa.Integer)
+    op.drop_table('telethon_update_state')
@@ -1,3 +0,0 @@
-pre-commit>=2.10.1,<3
-isort>=5.10.1,<6
-black>=23,<24
@@ -1,32 +1,21 @@
 #!/bin/sh
-if [ ! -z "$MAUTRIX_DIRECT_STARTUP" ]; then
-	if [ $(id -u) == 0 ]; then
-		echo "|------------------------------------------|"
-		echo "| Warning: running bridge unsafely as root |"
-		echo "|------------------------------------------|"
-	fi
-	exec python3 -m mautrix_telegram -c /data/config.yaml
-elif [ $(id -u) != 0 ]; then
-	echo "The startup script must run as root. It will use su-exec to drop permissions before running the bridge."
-	echo "To bypass the startup script, either set the `MAUTRIX_DIRECT_STARTUP` environment variable,"
-	echo "or just use `python3 -m mautrix_telegram -c /data/config.yaml` as the run command."
-	echo "Note that the config and registration will not be auto-generated when bypassing the startup script."
-	exit 1
-fi

 # Define functions.
 function fixperms {
-	chown -R $UID:$GID /data
-
-	# /opt/mautrix-telegram is read-only, so disable file logging if it's pointing there.
-	if [[ "$(yq e '.logging.handlers.file.filename' /data/config.yaml)" == "./mautrix-telegram.log" ]]; then
-		yq -I4 e -i 'del(.logging.root.handlers[] | select(. == "file"))' /data/config.yaml
-		yq -I4 e -i 'del(.logging.handlers.file)' /data/config.yaml
-	fi
+	chown -R $UID:$GID /data /opt/mautrix-telegram
 }

 cd /opt/mautrix-telegram

+# Replace database path in config.
+sed -i "s#sqlite:///mautrix-telegram.db#sqlite:////data/mautrix-telegram.db#" /data/config.yaml
+
+if [ -f /data/mx-state.json ]; then
+	ln -s /data/mx-state.json
+fi
+# Check that database is in the right state
+alembic -x config=/data/config.yaml upgrade head
+
 if [ ! -f /data/config.yaml ]; then
 	cp example-config.yaml /data/config.yaml
 	echo "Didn't find a config file."
@@ -38,10 +27,10 @@ if [ ! -f /data/config.yaml ]; then
 fi

 if [ ! -f /data/registration.yaml ]; then
-	python3 -m mautrix_telegram -g -c /data/config.yaml -r /data/registration.yaml || exit $?
+	python3 -m mautrix_telegram -g -c /data/config.yaml -r /data/registration.yaml
 	echo "Didn't find a registration file."
 	echo "Generated one for you."
-	echo "See https://docs.mau.fi/bridges/general/registering-appservices.html on how to use it."
+	echo "Copy that over to synapses app service directory."
 	fixperms
 	exit
 fi
@@ -0,0 +1,349 @@
+# Homeserver details
+homeserver:
+    # The address that this appservice can use to connect to the homeserver.
+    address: https://matrix.org
+    # The domain of the homeserver (for MXIDs, etc).
+    domain: matrix.org
+    # Whether or not to verify the SSL certificate of the homeserver.
+    # Only applies if address starts with https://
+    verify_ssl: true
+
+# Application service host/registration related details
+# Changing these values requires regeneration of the registration.
+appservice:
+    # The address that the homeserver can use to connect to this appservice.
+    address: http://localhost:8080
+
+    # The hostname and port where this appservice should listen.
+    hostname: 0.0.0.0
+    port: 8080
+    # The maximum body size of appservice API requests (from the homeserver) in mebibytes
+    # Usually 1 is enough, but on high-traffic bridges you might need to increase this to avoid 413s
+    max_body_size: 1
+
+    # The full URI to the database. SQLite and Postgres are fully supported.
+    # Other DBMSes supported by SQLAlchemy may or may not work.
+    # Format examples:
+    #   SQLite:   sqlite:///filename.db
+    #   Postgres: postgres://username:password@hostname/dbname
+    database: sqlite:///mautrix-telegram.db
+
+    # Public part of web server for out-of-Matrix interaction with the bridge.
+    # Used for things like login if the user wants to make sure the 2FA password isn't stored in
+    # the HS database.
+    public:
+        # Whether or not the public-facing endpoints should be enabled.
+        enabled: true
+        # The prefix to use in the public-facing endpoints.
+        prefix: /public
+        # The base URL where the public-facing endpoints are available. The prefix is not added
+        # implicitly.
+        external: https://example.com/public
+
+    # Provisioning API part of the web server for automated portal creation and fetching information.
+    # Used by things like Dimension (https://dimension.t2bot.io/).
+    provisioning:
+        # Whether or not the provisioning API should be enabled.
+        enabled: true
+        # The prefix to use in the provisioning API endpoints.
+        prefix: /_matrix/provision/v1
+        # The shared secret to authorize users of the API.
+        # Set to "generate" to generate and save a new token.
+        shared_secret: generate
+
+    # The unique ID of this appservice.
+    id: telegram
+    # Username of the appservice bot.
+    bot_username: telegrambot
+    # Display name and avatar for bot. Set to "remove" to remove display name/avatar, leave empty
+    # to leave display name/avatar as-is.
+    bot_displayname: Telegram bridge bot
+    bot_avatar: mxc://maunium.net/tJCRmUyJDsgRNgqhOgoiHWbX
+
+    # Community ID for bridged users (changes registration file) and rooms.
+    # Must be created manually.
+    community_id: false
+
+    # Authentication tokens for AS <-> HS communication. Autogenerated; do not modify.
+    as_token: "This value is generated when generating the registration"
+    hs_token: "This value is generated when generating the registration"
+
+# Prometheus telemetry config. Requires prometheus-client to be installed.
+metrics:
+    enabled: false
+    listen_port: 8000
+
+# Bridge config
+bridge:
+    # Localpart template of MXIDs for Telegram users.
+    # {userid} is replaced with the user ID of the Telegram user.
+    username_template: "telegram_{userid}"
+    # Localpart template of room aliases for Telegram portal rooms.
+    # {groupname} is replaced with the name part of the public channel/group invite link ( https://t.me/{} )
+    alias_template: "telegram_{groupname}"
+    # Displayname template for Telegram users.
+    # {displayname} is replaced with the display name of the Telegram user.
+    displayname_template: "{displayname} (Telegram)"
+
+    # Set the preferred order of user identifiers which to use in the Matrix puppet display name.
+    # In the (hopefully unlikely) scenario that none of the given keys are found, the numeric user
+    # ID is used.
+    #
+    # If the bridge is working properly, a phone number or an username should always be known, but
+    # the other one can very well be empty.
+    #
+    # Valid keys:
+    #   "full name"          (First and/or last name)
+    #   "full name reversed" (Last and/or first name)
+    #   "first name"
+    #   "last name"
+    #   "username"
+    #   "phone number"
+    displayname_preference:
+    - full name
+    - username
+    - phone number
+
+    # Maximum number of members to sync per portal when starting up. Other members will be
+    # synced when they send messages. The maximum is 10000, after which the Telegram server
+    # will not send any more members.
+    # Defaults to no local limit (-> limited to 10000 by server)
+    max_initial_member_sync: -1
+    # Whether or not to sync the member list in channels.
+    # If no channel admins have logged into the bridge, the bridge won't be able to sync the member
+    # list regardless of this setting.
+    sync_channel_members: true
+    # Whether or not to skip deleted members when syncing members.
+    skip_deleted_members: true
+    # Whether or not to automatically synchronize contacts and chats of Matrix users logged into
+    # their Telegram account at startup.
+    startup_sync: true
+    # Number of most recently active dialogs to check when syncing chats.
+    # Dialogs include groups and private chats, but only groups are synced.
+    # Set to 0 to remove limit.
+    sync_dialog_limit: 30
+    # The maximum number of simultaneous Telegram deletions to handle.
+    # A large number of simultaneous redactions could put strain on your homeserver.
+    max_telegram_delete: 10
+    # Whether or not to automatically sync the Matrix room state (mostly unpuppeted displaynames)
+    # at startup and when creating a bridge.
+    sync_matrix_state: true
+    # Allow logging in within Matrix. If false, the only way to log in is using the out-of-Matrix
+    # login website (see appservice.public config section)
+    allow_matrix_login: true
+    # Whether or not to bridge plaintext highlights.
+    # Only enable this if your displayname_template has some static part that the bridge can use to
+    # reliably identify what is a plaintext highlight.
+    plaintext_highlights: false
+    # Whether or not to make portals of publicly joinable channels/supergroups publicly joinable on Matrix.
+    public_portals: true
+    # Whether or not to fetch and handle Telegram updates at startup from the time the bridge was down.
+    # Currently only works for private chats and normal groups.
+    # WARNING: This feature seems to be broken in the telegram library.
+    catch_up: false
+    # Whether or not to use /sync to get presence, read receipts and typing notifications when using
+    # your own Matrix account as the Matrix puppet for your Telegram account.
+    sync_with_custom_puppets: true
+    # Set to false to disable link previews in messages sent to Telegram.
+    telegram_link_preview: true
+    # Use inline images instead of a separate message for the caption.
+    # N.B. Inline images are not supported on all clients (e.g. Riot iOS).
+    inline_images: false
+    # Maximum size of image in megabytes before sending to Telegram as a document.
+    image_as_file_size: 10
+    # Maximum size of Telegram documents in megabytes to bridge.
+    max_document_size: 100
+
+    # Whether to bridge Telegram bot messages as m.notices or m.texts.
+    bot_messages_as_notices: true
+    bridge_notices:
+        # Whether or not Matrix bot messages (type m.notice) should be bridged.
+        default: false
+        # List of user IDs for whom the previous flag is flipped.
+        # e.g. if bridge_notices.default is false, notices from other users will not be bridged, but
+        #      notices from users listed here will be bridged.
+        exceptions:
+        - "@importantbot:example.com"
+
+    # Some config options related to Telegram message deduplication.
+    # The default values are usually fine, but some debug messages/warnings might recommend you
+    # change these.
+    deduplication:
+        # Whether or not to check the database if the message about to be sent is a duplicate.
+        pre_db_check: false
+        # The number of latest events to keep when checking for duplicates.
+        # You might need to increase this on high-traffic bridge instances.
+        cache_queue_length: 20
+
+
+    # The formats to use when sending messages to Telegram via the relay bot.
+    #
+    # Telegram doesn't have built-in emotes, so the m.emote format is also used for non-relaybot users.
+    #
+    # Available variables:
+    #   $sender_displayname    - The display name of the sender (e.g. Example User)
+    #   $sender_username       - The username (Matrix ID localpart) of the sender (e.g. exampleuser)
+    #   $sender_mxid           - The Matrix ID of the sender (e.g. @exampleuser:example.com)
+    #   $message               - The message content as HTML
+    message_formats:
+        m.text: "<b>$sender_displayname</b>: $message"
+        m.emote: "* <b>$sender_displayname</b> $message"
+        m.file: "<b>$sender_displayname</b> sent a file: $message"
+        m.image: "<b>$sender_displayname</b> sent an image: $message"
+        m.audio: "<b>$sender_displayname</b> sent an audio file: $message"
+        m.video: "<b>$sender_displayname</b> sent a video: $message"
+        m.location: "<b>$sender_displayname</b> sent a location: $message"
+
+    # The formats to use when sending state events to Telegram via the relay bot.
+    #
+    # Variables from `message_formats` that have the `sender_` prefix are available without the prefix.
+    # In name_change events, `$prev_displayname` is the previous displayname.
+    #
+    # Set format to an empty string to disable the messages for that event.
+    state_event_formats:
+        join: "<b>$displayname</b> joined the room."
+        leave: "<b>$displayname</b> left the room."
+        name_change: "<b>$prev_displayname</b> changed their name to <b>$displayname</b>"
+
+    # Filter rooms that can/can't be bridged. Can also be managed using the `filter` and
+    # `filter-mode` management commands.
+    #
+    # Filters do not affect direct chats.
+    # An empty blacklist will essentially disable the filter.
+    filter:
+        # Filter mode to use. Either "blacklist" or "whitelist".
+        # If the mode is "blacklist", the listed chats will never be bridged.
+        # If the mode is "whitelist", only the listed chats can be bridged.
+        mode: blacklist
+        # The list of group/channel IDs to filter.
+        list: []
+
+    # The prefix for commands. Only required in non-management rooms.
+    command_prefix: "!tg"
+
+    # Permissions for using the bridge.
+    # Permitted values:
+    #   relaybot - Only use the bridge via the relaybot, no access to commands.
+    #       user - Relaybot level + access to commands to create bridges.
+    #  puppeting - User level + logging in with a Telegram account.
+    #       full - Full access to use the bridge, i.e. previous levels + Matrix login.
+    #      admin - Full access to use the bridge and some extra administration commands.
+    # Permitted keys:
+    #        * - All Matrix users
+    #   domain - All users on that homeserver
+    #     mxid - Specific user
+    permissions:
+        "*": "relaybot"
+        "public.example.com": "user"
+        "example.com": "full"
+        "@admin:example.com": "admin"
+
+    # Options related to the message relay Telegram bot.
+    relaybot:
+        # Whether or not to allow creating portals from Telegram.
+        authless_portals: true
+        # Whether or not to allow Telegram group admins to use the bot commands.
+        whitelist_group_admins: true
+        # Whether or not to ignore incoming events sent by the relay bot.
+        ignore_own_incoming_events: true
+        # List of usernames/user IDs who are also allowed to use the bot commands.
+        whitelist:
+        - myusername
+        - 12345678
+
+# Telegram config
+telegram:
+    # Get your own API keys at https://my.telegram.org/apps
+    api_id: 12345
+    api_hash: tjyd5yge35lbodk1xwzw2jstp90k55qz
+    # (Optional) Create your own bot at https://t.me/BotFather
+    bot_token: disabled
+
+    # Telethon connection options.
+    connection:
+        # The timeout in seconds to be used when connecting.
+        timeout: 120
+        # How many times the reconnection should retry, either on the initial connection or when
+        # Telegram disconnects us. May be set to a negative or null value for infinite retries, but
+        # this is not recommended, since the program can get stuck in an infinite loop.
+        retries: 5
+        # The delay in seconds to sleep between automatic reconnections.
+        retry_delay: 1
+        # The threshold below which the library should automatically sleep on flood wait errors
+        # (inclusive). For instance, if a FloodWaitError for 17s occurs and flood_sleep_threshold
+        # is 20s, the library will sleep automatically. If the error was for 21s, it would raise
+        # the error instead. Values larger than a day (86400) will be changed to a day.
+        flood_sleep_threshold: 60
+        # How many times a request should be retried. Request are retried when Telegram is having
+        # internal issues, when there is a FloodWaitError less than flood_sleep_threshold, or when
+        # there's a migrate error. May take a negative or null value for infinite retries, but this
+        # is not recommended, since some requests can always trigger a call fail (such as searching
+        # for messages).
+        request_retries: 5
+
+    # Device info sent to Telegram.
+    device_info:
+        # "auto" = OS name+version.
+        device_model: auto
+        # "auto" = Telethon version.
+        system_version: auto
+        # "auto" = mautrix-telegram version.
+        app_version: auto
+        lang_code: en
+        system_lang_code: en
+
+    # Custom server to connect to.
+    server:
+        # Set to true to use these server settings. If false, will automatically
+        # use production server assigned by Telegram. Set to false in production.
+        enabled: false
+        # The DC ID to connect to.
+        dc: 2
+        # The IP to connect to.
+        ip: 149.154.167.40
+        # The port to connect to. 443 may not work, 80 is better and both are equally secure.
+        port: 80
+
+    # Telethon proxy configuration.
+    # You must install PySocks from pip for proxies to work.
+    proxy:
+        # Allowed types: disabled, socks4, socks5, http
+        type: disabled
+        # Proxy IP address and port.
+        address: 127.0.0.1
+        port: 1080
+        # Whether or not to perform DNS resolving remotely.
+        rdns: true
+        # Proxy authentication (optional).
+        username: ""
+        password: ""
+
+# Python logging configuration.
+#
+# See section 16.7.2 of the Python documentation for more info:
+# https://docs.python.org/3.6/library/logging.config.html#configuration-dictionary-schema
+logging:
+    version: 1
+    formatters:
+        precise:
+            format: "[%(asctime)s] [%(levelname)s@%(name)s] %(message)s"
+    handlers:
+        file:
+            class: logging.handlers.RotatingFileHandler
+            formatter: precise
+            filename: ./mautrix-telegram.log
+            maxBytes: 10485760
+            backupCount: 10
+        console:
+            class: logging.StreamHandler
+            formatter: precise
+    loggers:
+        mau:
+            level: DEBUG
+        telethon:
+            level: DEBUG
+        aiohttp:
+            level: INFO
+    root:
+        level: DEBUG
+        handlers: [file, console]
@@ -1,2 +1,2 @@
-__version__ = "0.15.0"
+__version__ = "0.6.1rc1"
 __author__ = "Tulir Asokan <tulir@maunium.net>"
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,133 +14,150 @@
 #
 # 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 __future__ import annotations
+from typing import Awaitable, List, Any
+from time import time
+import argparse
+import asyncio
+import logging.config
+import sys
+import copy
+import signal
+import os

-from typing import Any
+import sqlalchemy as sql

-from telethon import __version__ as __telethon_version__
+from mautrix_appservice import AppService
+from alchemysession import AlchemySessionContainer

-from mautrix.bridge import Bridge
-from mautrix.types import RoomID, UserID
-
-from .bot import Bot
-from .config import Config
-from .db import init as init_db, upgrade_table
-from .matrix import MatrixHandler
-from .portal import Portal
-from .puppet import Puppet
-from .user import User
-from .version import linkified_version, version
 from .web.provisioning import ProvisioningAPI
 from .web.public import PublicBridgeWebsite
+from .abstract_user import init as init_abstract_user
+from .bot import init as init_bot
+from .config import Config
+from .context import Context
+from .db import Base, init as init_db
+from .formatter import init as init_formatter
+from .matrix import MatrixHandler
+from .portal import init as init_portal
+from .puppet import init as init_puppet
+from .sqlstatestore import SQLStateStore
+from .user import User, init as init_user
+from . import __version__

-from .abstract_user import AbstractUser  # isort: skip
+try:
+    import prometheus_client as prometheus
+except ImportError:
+    prometheus = None

+parser = argparse.ArgumentParser(
+    description="A Matrix-Telegram puppeting bridge.",
+    prog="python -m mautrix-telegram")
+parser.add_argument("-c", "--config", type=str, default="config.yaml",
+                    metavar="<path>", help="the path to your config file")
+parser.add_argument("-b", "--base-config", type=str, default="example-config.yaml",
+                    metavar="<path>", help="the path to the example config "
+                                           "(for automatic config updates)")
+parser.add_argument("-g", "--generate-registration", action="store_true",
+                    help="generate registration and quit")
+parser.add_argument("-r", "--registration", type=str, default="registration.yaml",
+                    metavar="<path>", help="the path to save the generated registration to")
+args = parser.parse_args()

-class TelegramBridge(Bridge):
-    module = "mautrix_telegram"
-    name = "mautrix-telegram"
-    beeper_service_name = "telegram"
-    beeper_network_name = "telegram"
-    command = "python -m mautrix-telegram"
-    description = "A Matrix-Telegram puppeting bridge."
-    repo_url = "https://github.com/mautrix/telegram"
-    version = version
-    markdown_version = linkified_version
-    config_class = Config
-    matrix_class = MatrixHandler
-    upgrade_table = upgrade_table
+config = Config(args.config, args.registration, args.base_config, os.environ)
+config.load()
+config.update()

-    config: Config
-    bot: Bot | None
-    matrix: MatrixHandler
-    public_website: PublicBridgeWebsite | None
-    provisioning_api: ProvisioningAPI | None
+if args.generate_registration:
+    config.generate_registration()
+    config.save()
+    print(f"Registration generated and saved to {config.registration_path}")
+    sys.exit(0)

-    def prepare_db(self) -> None:
-        super().prepare_db()
-        init_db(self.db)
+logging.config.dictConfig(copy.deepcopy(config["logging"]))
+log = logging.getLogger("mau.init")  # type: logging.Logger
+log.debug(f"Initializing mautrix-telegram {__version__}")

-    def _prepare_website(self) -> None:
-        if self.config["appservice.provisioning.enabled"]:
-            self.provisioning_api = ProvisioningAPI(self)
-            self.az.app.add_subapp(
-                self.config["appservice.provisioning.prefix"], self.provisioning_api.app
-            )
-        else:
-            self.provisioning_api = None
+db_engine = sql.create_engine(config["appservice.database"] or "sqlite:///mautrix-telegram.db")
+Base.metadata.bind = db_engine

-        if self.config["appservice.public.enabled"]:
-            self.public_website = PublicBridgeWebsite(self.loop)
-            self.az.app.add_subapp(
-                self.config["appservice.public.prefix"], self.public_website.app
-            )
-        else:
-            self.public_website = None
+session_container = AlchemySessionContainer(engine=db_engine, table_base=Base, session=False,
+                                            table_prefix="telethon_", manage_tables=False)
+session_container.core_mode = True

-    def prepare_bridge(self) -> None:
-        self._prepare_website()
-        AbstractUser.init_cls(self)
-        bot_token: str = self.config["telegram.bot_token"]
-        if bot_token and not bot_token.lower().startswith("disable"):
-            self.bot = AbstractUser.relaybot = Bot(bot_token)
-        else:
-            self.bot = AbstractUser.relaybot = None
-        self.matrix = MatrixHandler(self)
-        Portal.init_cls(self)
-        self.add_startup_actions(Puppet.init_cls(self))
-        self.add_startup_actions(User.init_cls(self))
-        self.add_startup_actions(Portal.restart_scheduled_disappearing())
-        if self.bot:
-            self.add_startup_actions(self.bot.start())
-        if self.config["bridge.resend_bridge_info"]:
-            self.add_startup_actions(self.resend_bridge_info())
+try:
+    import uvloop

-    async def resend_bridge_info(self) -> None:
-        self.config["bridge.resend_bridge_info"] = False
-        self.config.save()
-        self.log.info("Re-sending bridge info state event to all portals")
-        async for portal in Portal.all():
-            await portal.update_bridge_info()
-        self.log.info("Finished re-sending bridge info state events")
+    asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
+    log.debug("Using uvloop for asyncio")
+except ImportError:
+    pass

-    def prepare_stop(self) -> None:
-        self.add_shutdown_actions(user.stop() for user in User.by_tgid.values())
-        if self.bot:
-            self.add_shutdown_actions(self.bot.stop())
+loop = asyncio.get_event_loop()  # type: asyncio.AbstractEventLoop

-    async def get_user(self, user_id: UserID, create: bool = True) -> User | None:
-        user = await User.get_by_mxid(user_id, create=create)
-        if user:
-            await user.ensure_started()
-        return user
+state_store = SQLStateStore()
+mebibyte = 1024 ** 2
+appserv = AppService(config["homeserver.address"], config["homeserver.domain"],
+                     config["appservice.as_token"], config["appservice.hs_token"],
+                     config["appservice.bot_username"], log="mau.as", loop=loop,
+                     verify_ssl=config["homeserver.verify_ssl"], state_store=state_store,
+                     real_user_content_key="net.maunium.telegram.puppet",
+                     aiohttp_params={
+                         "client_max_size": config["appservice.max_body_size"] * mebibyte
+                     })
+bot = init_bot(config)
+context = Context(appserv, config, loop, session_container, bot)

-    async def get_portal(self, room_id: RoomID) -> Portal | None:
-        return await Portal.get_by_mxid(room_id)
+if config["appservice.public.enabled"]:
+    public_website = PublicBridgeWebsite(loop)
+    appserv.app.add_subapp(config["appservice.public.prefix"] or "/public", public_website.app)
+    context.public_website = public_website

-    async def get_puppet(self, user_id: UserID, create: bool = False) -> Puppet | None:
-        return await Puppet.get_by_mxid(user_id, create=create)
+if config["appservice.provisioning.enabled"]:
+    provisioning_api = ProvisioningAPI(context)
+    appserv.app.add_subapp(config["appservice.provisioning.prefix"] or "/_matrix/provisioning",
+                           provisioning_api.app)
+    context.provisioning_api = provisioning_api

-    async def get_double_puppet(self, user_id: UserID) -> Puppet | None:
-        return await Puppet.get_by_custom_mxid(user_id)
+context.mx = MatrixHandler(context)

-    def is_bridge_ghost(self, user_id: UserID) -> bool:
-        return bool(Puppet.get_id_from_mxid(user_id))
+if config["metrics.enabled"]:
+    if prometheus:
+        prometheus.start_http_server(config["metrics.listen_port"])
+    else:
+        log.warn("Metrics are enabled in the config, but prometheus-async is not installed.")

-    async def count_logged_in_users(self) -> int:
-        return len([user for user in User.by_tgid.values() if user.tgid])
+with appserv.run(config["appservice.hostname"], config["appservice.port"]) as start:
+    start_ts = time()
+    init_db(db_engine)
+    init_abstract_user(context)
+    init_formatter(context)
+    init_portal(context)
+    startup_actions = (init_puppet(context) +
+                       init_user(context) +
+                       [start, context.mx.init_as_bot()])  # type: List[Awaitable[Any]]

-    async def manhole_global_namespace(self, user_id: UserID) -> dict[str, Any]:
-        return {
-            **await super().manhole_global_namespace(user_id),
-            "User": User,
-            "Portal": Portal,
-            "Puppet": Puppet,
-        }
+    if context.bot:
+        startup_actions.append(context.bot.start())

-    @property
-    def manhole_banner_program_version(self) -> str:
-        return f"{super().manhole_banner_program_version} and Telethon {__telethon_version__}"
+    signal.signal(signal.SIGINT, signal.default_int_handler)
+    signal.signal(signal.SIGTERM, signal.default_int_handler)

-
-TelegramBridge().run()
+    end_ts = time()
+    try:
+        log.debug(f"Initialization complete in {round(end_ts - start_ts, 2)} seconds,"
+                  " running startup actions")
+        start_ts = time()
+        loop.run_until_complete(asyncio.gather(*startup_actions, loop=loop))
+        end_ts = time()
+        log.debug(f"Startup actions complete in {round(end_ts - start_ts, 2)} seconds,"
+                  " now running forever")
+        loop.run_forever()
+    except KeyboardInterrupt:
+        log.debug("Interrupt received, stopping clients")
+        loop.run_until_complete(
+            asyncio.gather(*[user.stop() for user in User.by_tgid.values()], loop=loop))
+        log.debug("Clients stopped, shutting down")
+        sys.exit(0)
+    except Exception as e:
+        log.exception("Unexpected error")
+        sys.exit(1)
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 Tulir Asokan
+# 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
@@ -13,252 +14,135 @@
 #
 # 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 __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Union
+from typing import Tuple, Optional, List, Union, Dict, TYPE_CHECKING
 from abc import ABC, abstractmethod
 import asyncio
 import logging
 import platform
 import time

-from telethon.errors import AuthKeyError, UnauthorizedError
-from telethon.network import (
-    Connection,
-    ConnectionTcpFull,
-    ConnectionTcpMTProxyRandomizedIntermediate,
-)
-from telethon.sessions import Session
-from telethon.tl.patched import Message, MessageService
+from telethon.tl.patched import MessageService, Message
 from telethon.tl.types import (
-    Channel,
-    Chat,
-    MessageActionChannelMigrateFrom,
-    MessageEmpty,
-    PeerChannel,
-    PeerChat,
-    PeerUser,
-    PhoneCallRequested,
-    TypeUpdate,
-    UpdateChannel,
-    UpdateChannelUserTyping,
-    UpdateChatDefaultBannedRights,
-    UpdateChatParticipantAdmin,
-    UpdateChatParticipants,
-    UpdateChatUserTyping,
-    UpdateDeleteChannelMessages,
-    UpdateDeleteMessages,
-    UpdateEditChannelMessage,
-    UpdateEditMessage,
-    UpdateFolderPeers,
-    UpdateMessageReactions,
-    UpdateNewChannelMessage,
-    UpdateNewMessage,
-    UpdateNotifySettings,
-    UpdatePhoneCall,
-    UpdatePinnedChannelMessages,
-    UpdatePinnedDialogs,
-    UpdatePinnedMessages,
-    UpdateReadChannelInbox,
-    UpdateReadHistoryInbox,
-    UpdateReadHistoryOutbox,
-    UpdateShort,
-    UpdateShortChatMessage,
-    UpdateShortMessage,
-    UpdateUser,
-    UpdateUserName,
-    UpdateUserStatus,
-    UpdateUserTyping,
-    User,
-    UserStatusOffline,
-    UserStatusOnline,
-)
+    Channel, ChannelForbidden, Chat, ChatForbidden, MessageActionChannelMigrateFrom, PeerUser,
+    TypeUpdate, UpdateChannelPinnedMessage, UpdateChatPinnedMessage, UpdateChatParticipantAdmin,
+    UpdateChatParticipants, UpdateChatUserTyping, UpdateDeleteChannelMessages, UpdateDeleteMessages,
+    UpdateEditChannelMessage, UpdateEditMessage, UpdateNewChannelMessage, UpdateNewMessage,
+    UpdateReadHistoryOutbox, UpdateShortChatMessage, UpdateShortMessage, UpdateUserName,
+    UpdateUserPhoto, UpdateUserStatus, UpdateUserTyping, User, UserStatusOffline, UserStatusOnline)

-from mautrix.appservice import AppService
-from mautrix.errors import MatrixError
-from mautrix.types import PresenceState, UserID
-from mautrix.util import background_task
-from mautrix.util.logging import TraceLogger
-from mautrix.util.opt_prometheus import Counter, Histogram
+from mautrix_appservice import MatrixRequestError, AppService
+from alchemysession import AlchemySessionContainer

-from . import __version__, portal as po, puppet as pu
-from .config import Config
-from .db import Message as DBMessage, PgSession
+from . import portal as po, puppet as pu, __version__
+from .db import Message as DBMessage
+from .types import TelegramID, MatrixUserID
 from .tgclient import MautrixTelegramClient
-from .types import TelegramID

 if TYPE_CHECKING:
-    from .__main__ import TelegramBridge
+    from .context import Context
+    from .config import Config
    from .bot import Bot

-UpdateMessage = Union[
-    UpdateShortChatMessage,
-    UpdateShortMessage,
-    UpdateNewChannelMessage,
-    UpdateNewMessage,
-    UpdateEditMessage,
-    UpdateEditChannelMessage,
-]
-UpdateMessageContent = Union[
-    UpdateShortMessage, UpdateShortChatMessage, Message, MessageService, MessageEmpty
-]
+config = None  # type: Config
+# Value updated from config in init()
+MAX_DELETIONS = 10  # type: int

-UPDATE_TIME = Histogram(
-    name="bridge_telegram_update",
-    documentation="Time spent processing Telegram updates",
-    labelnames=("update_type",),
-)
-UPDATE_ERRORS = Counter(
-    name="bridge_telegram_update_error",
-    documentation="Number of fatal errors while handling Telegram updates",
-    labelnames=("update_type",),
-)
+UpdateMessage = Union[UpdateShortChatMessage, UpdateShortMessage, UpdateNewChannelMessage,
+                      UpdateNewMessage, UpdateEditMessage, UpdateEditChannelMessage]
+UpdateMessageContent = Union[UpdateShortMessage, UpdateShortChatMessage, Message, MessageService]

+try:
+    from prometheus_client import Histogram
+
+    UPDATE_TIME = Histogram("telegram_update", "Time spent processing Telegram updates",
+                            ["update_type"])
+except ImportError:
+    Histogram = None
+    UPDATE_TIME = None

 class AbstractUser(ABC):
-    loop: asyncio.AbstractEventLoop = None
-    log: TraceLogger
-    az: AppService
-    bridge: "TelegramBridge"
-    config: Config
-    relaybot: "Bot"
-    ignore_incoming_bot_events: bool = True
-    max_deletions: int = 10
-
-    client: MautrixTelegramClient | None
-    mxid: UserID | None
-
-    tgid: TelegramID | None
-    username: str | None
-    is_bot: bool
-
-    is_relaybot: bool
-
-    puppet_whitelisted: bool
-    whitelisted: bool
-    relaybot_whitelisted: bool
-    matrix_puppet_whitelisted: bool
-    is_admin: bool
+    session_container = None  # type: AlchemySessionContainer
+    loop = None  # type: asyncio.AbstractEventLoop
+    log = None  # type: logging.Logger
+    az = None  # type: AppService
+    bot = None  # type: Bot
+    ignore_incoming_bot_events = True  # type: bool

    def __init__(self) -> None:
-        self.is_admin = False
-        self.matrix_puppet_whitelisted = False
-        self.puppet_whitelisted = False
-        self.whitelisted = False
-        self.relaybot_whitelisted = False
-        self.client = None
-        self.is_relaybot = False
-        self.is_bot = False
+        self.is_admin = False  # type: bool
+        self.matrix_puppet_whitelisted = False  # type: bool
+        self.puppet_whitelisted = False  # type: bool
+        self.whitelisted = False  # type: bool
+        self.relaybot_whitelisted = False  # type: bool
+        self.client = None  # type: MautrixTelegramClient
+        self.tgid = None  # type: TelegramID
+        self.mxid = None  # type: MatrixUserID
+        self.is_relaybot = False  # type: bool
+        self.is_bot = False  # type: bool
+        self.relaybot = None  # type: Optional[Bot]

    @property
    def connected(self) -> bool:
        return self.client and self.client.is_connected()

    @property
-    def _proxy_settings(self) -> tuple[type[Connection], tuple[Any, ...] | None]:
-        proxy_type = self.config["telegram.proxy.type"].lower()
-        connection = ConnectionTcpFull
-        connection_data = (
-            self.config["telegram.proxy.address"],
-            self.config["telegram.proxy.port"],
-            self.config["telegram.proxy.rdns"],
-            self.config["telegram.proxy.username"],
-            self.config["telegram.proxy.password"],
-        )
+    def _proxy_settings(self) -> Optional[Tuple[int, str, str, str, str, str]]:
+        proxy_type = config["telegram.proxy.type"].lower()
        if proxy_type == "disabled":
-            connection_data = None
+            return None
        elif proxy_type == "socks4":
-            connection_data = (1,) + connection_data
+            proxy_type = 1
        elif proxy_type == "socks5":
-            connection_data = (2,) + connection_data
+            proxy_type = 2
        elif proxy_type == "http":
-            connection_data = (3,) + connection_data
-        elif proxy_type == "mtproxy":
-            connection = ConnectionTcpMTProxyRandomizedIntermediate
-            connection_data = (connection_data[0], connection_data[1], connection_data[4])
+            proxy_type = 3

-        return connection, connection_data
+        return (proxy_type,
+                config["telegram.proxy.address"], config["telegram.proxy.port"],
+                config["telegram.proxy.rdns"],
+                config["telegram.proxy.username"], config["telegram.proxy.password"])

-    @classmethod
-    def init_cls(cls, bridge: "TelegramBridge") -> None:
-        cls.bridge = bridge
-        cls.config = bridge.config
-        cls.loop = bridge.loop
-        cls.az = bridge.az
-        cls.ignore_incoming_bot_events = cls.config["bridge.relaybot.ignore_own_incoming_events"]
-        cls.max_deletions = cls.config["bridge.max_telegram_delete"]
-
-    async def _init_client(self) -> None:
+    def _init_client(self) -> None:
        self.log.debug(f"Initializing client for {self.name}")

-        session = await PgSession.get(self.name)
-        if self.config["telegram.server.enabled"]:
-            session.set_dc(
-                self.config["telegram.server.dc"],
-                self.config["telegram.server.ip"],
-                self.config["telegram.server.port"],
-            )
+        self.session = self.session_container.new_session(self.name)
+        if config["telegram.server.enabled"]:
+            self.session.set_dc(config["telegram.server.dc"],
+                                config["telegram.server.ip"],
+                                config["telegram.server.port"])

        if self.is_relaybot:
            base_logger = logging.getLogger("telethon.relaybot")
        else:
            base_logger = logging.getLogger(f"telethon.{self.tgid or -hash(self.mxid)}")

-        device = self.config["telegram.device_info.device_model"]
-        sysversion = self.config["telegram.device_info.system_version"]
-        appversion = self.config["telegram.device_info.app_version"]
-        connection, proxy = self._proxy_settings
-        if proxy:
-            self.log.debug(f"Using proxy setting: {proxy}")
-
-        assert isinstance(session, Session)
+        device = config["telegram.device_info.device_model"]
+        sysversion = config["telegram.device_info.system_version"]
+        appversion = config["telegram.device_info.app_version"]

        self.client = MautrixTelegramClient(
-            session=session,
-            api_id=self.config["telegram.api_id"],
-            api_hash=self.config["telegram.api_hash"],
+            session=self.session,
+
+            api_id=config["telegram.api_id"],
+            api_hash=config["telegram.api_hash"],
+
            app_version=__version__ if appversion == "auto" else appversion,
-            system_version=(
-                MautrixTelegramClient.__version__ if sysversion == "auto" else sysversion
-            ),
-            device_model=(
-                f"{platform.system()} {platform.release()}" if device == "auto" else device
-            ),
-            timeout=self.config["telegram.connection.timeout"],
-            connection_retries=self.config["telegram.connection.retries"],
-            retry_delay=self.config["telegram.connection.retry_delay"],
-            flood_sleep_threshold=self.config["telegram.connection.flood_sleep_threshold"],
-            request_retries=self.config["telegram.connection.request_retries"],
-            connection=connection,
-            proxy=proxy,
-            raise_last_call_error=True,
-            catch_up=self.config["telegram.catch_up"],
-            sequential_updates=self.config["telegram.sequential_updates"],
+            system_version=MautrixTelegramClient.__version__ if sysversion == "auto" else sysversion,
+            device_model=f"{platform.system()} {platform.release()}" if device == "auto" else device,
+
+            timeout=config["telegram.connection.timeout"],
+            connection_retries=config["telegram.connection.retries"],
+            retry_delay=config["telegram.connection.retry_delay"],
+            flood_sleep_threshold=config["telegram.connection.flood_sleep_threshold"],
+            request_retries=config["telegram.connection.request_retries"],
+
+            proxy=self._proxy_settings,
+
            loop=self.loop,
-            base_logger=base_logger,
-            update_error_callback=self._telethon_update_error_callback,
-            use_ipv6=self.config["telegram.connection.use_ipv6"],
+            base_logger=base_logger
        )
        self.client.add_event_handler(self._update_catch)

-    @abstractmethod
-    async def on_signed_out(self, err: UnauthorizedError | AuthKeyError) -> None:
-        pass
-
-    async def _telethon_update_error_callback(self, err: Exception) -> None:
-        if isinstance(err, (UnauthorizedError, AuthKeyError)):
-            background_task.create(self.on_signed_out(err))
-            return
-        if self.config["telegram.exit_on_update_error"]:
-            self.log.critical(f"Stopping due to update handling error {type(err).__name__}")
-            self.bridge.manual_stop(50)
-        else:
-            self.log.info("Recreating Telethon connection in 60 seconds")
-            await asyncio.sleep(60)
-            self.log.debug("Now recreating Telethon connection")
-            await self.stop()
-            await self.start()
-
    @abstractmethod
    async def update(self, update: TypeUpdate) -> bool:
        return False
@@ -268,23 +152,31 @@ class AbstractUser(ABC):
        raise NotImplementedError()

    @abstractmethod
-    async def register_portal(self, portal: po.Portal) -> None:
+    def register_portal(self, portal: po.Portal) -> None:
        raise NotImplementedError()

    @abstractmethod
-    async def unregister_portal(self, tgid: int, tg_receiver: int) -> None:
+    def unregister_portal(self, portal: po.Portal) -> None:
        raise NotImplementedError()

    async def _update_catch(self, update: TypeUpdate) -> None:
        start_time = time.time()
-        update_type = type(update).__name__
        try:
            if not await self.update(update):
                await self._update(update)
        except Exception:
            self.log.exception("Failed to handle Telegram update")
-            UPDATE_ERRORS.labels(update_type=update_type).inc()
-        UPDATE_TIME.labels(update_type=update_type).observe(time.time() - start_time)
+        if UPDATE_TIME:
+            UPDATE_TIME.labels(update_type=type(update).__name__).observe(time.time() - start_time)
+
+    async def get_dialogs(self, limit: int = None) -> List[Union[Chat, Channel]]:
+        if self.is_bot:
+            return []
+        dialogs = await self.client.get_dialogs(limit=limit)
+        return [dialog.entity for dialog in dialogs if (
+            not isinstance(dialog.entity, (User, ChatForbidden, ChannelForbidden))
+            and not (isinstance(dialog.entity, Chat)
+                     and (dialog.entity.deactivated or dialog.entity.left)))]

    @property
    @abstractmethod
@@ -292,78 +184,45 @@ class AbstractUser(ABC):
        raise NotImplementedError()

    async def is_logged_in(self) -> bool:
-        return (
-            self.client and self.client.is_connected() and await self.client.is_user_authorized()
-        )
+        return self.client and self.client.is_connected() and await self.client.is_user_authorized()

    async def has_full_access(self, allow_bot: bool = False) -> bool:
-        return (
-            self.puppet_whitelisted
-            and (not self.is_bot or allow_bot)
-            and await self.is_logged_in()
-        )
+        return (self.puppet_whitelisted
+                and (not self.is_bot or allow_bot)
+                and await self.is_logged_in())

-    async def start(self, delete_unless_authenticated: bool = False) -> AbstractUser:
+    async def start(self, delete_unless_authenticated: bool = False) -> 'AbstractUser':
        if not self.client:
-            await self._init_client()
-        attempts = 1
-        while True:
-            try:
-                await self.client.connect()
-            except Exception:
-                attempts += 1
-                if attempts > 10:
-                    raise
-                self.log.exception("Exception connecting to Telegram, retrying in 5s...")
-                await asyncio.sleep(5)
-            else:
-                break
-        self.log.debug(f"{'Bot' if self.is_relaybot else self.mxid} connected: {self.connected}")
+            self._init_client()
+        await self.client.connect()
+        self.log.debug("%s connected: %s", self.mxid, self.connected)
        return self

-    async def ensure_started(self, even_if_no_session=False) -> AbstractUser:
-        if self.connected:
+    async def ensure_started(self, even_if_no_session=False) -> 'AbstractUser':
+        if not self.puppet_whitelisted or self.connected:
            return self
-        session_exists = await PgSession.has(self.mxid)
-        if even_if_no_session or session_exists:
-            self.log.debug(
-                f"Starting client due to ensure_started({even_if_no_session=}, {session_exists=})"
-            )
+        self.log.debug("ensure_started(%s, even_if_no_session=%s)", self.mxid, even_if_no_session)
+        if even_if_no_session or self.session_container.has_session(self.mxid):
            await self.start(delete_unless_authenticated=not even_if_no_session)
        return self

    async def stop(self) -> None:
-        if self.client:
-            await self.client.disconnect()
-            self.client = None
+        await self.client.disconnect()
+        self.client = None

    # region Telegram update handling

    async def _update(self, update: TypeUpdate) -> None:
-        if isinstance(update, UpdateShort):
-            update = update.update
-        background_task.create(self._handle_entity_updates(getattr(update, "_entities", {})))
-        if isinstance(
-            update,
-            (
-                UpdateShortChatMessage,
-                UpdateShortMessage,
-                UpdateNewChannelMessage,
-                UpdateNewMessage,
-                UpdateEditMessage,
-                UpdateEditChannelMessage,
-            ),
-        ):
+        asyncio.ensure_future(self._handle_entity_updates(getattr(update, "_entities", {})),
+                              loop=self.loop)
+        if isinstance(update, (UpdateShortChatMessage, UpdateShortMessage, UpdateNewChannelMessage,
+                               UpdateNewMessage, UpdateEditMessage, UpdateEditChannelMessage)):
            await self.update_message(update)
        elif isinstance(update, UpdateDeleteMessages):
            await self.delete_message(update)
        elif isinstance(update, UpdateDeleteChannelMessages):
            await self.delete_channel_message(update)
-        elif isinstance(update, UpdatePhoneCall):
-            await self.update_phone_call(update)
-        elif isinstance(update, UpdateMessageReactions):
-            await self.update_reactions(update)
-        elif isinstance(update, (UpdateChatUserTyping, UpdateChannelUserTyping, UpdateUserTyping)):
+        elif isinstance(update, (UpdateChatUserTyping, UpdateUserTyping)):
            await self.update_typing(update)
        elif isinstance(update, UpdateUserStatus):
            await self.update_status(update)
@@ -371,399 +230,194 @@ class AbstractUser(ABC):
            await self.update_admin(update)
        elif isinstance(update, UpdateChatParticipants):
            await self.update_participants(update)
-        elif isinstance(update, UpdateChatDefaultBannedRights):
-            await self.update_default_banned_rights(update)
-        elif isinstance(update, (UpdatePinnedMessages, UpdatePinnedChannelMessages)):
+        elif isinstance(update, (UpdateChannelPinnedMessage, UpdateChatPinnedMessage)):
            await self.update_pinned_messages(update)
-        elif isinstance(update, (UpdateUserName, UpdateUser)):
+        elif isinstance(update, (UpdateUserName, UpdateUserPhoto)):
            await self.update_others_info(update)
        elif isinstance(update, UpdateReadHistoryOutbox):
            await self.update_read_receipt(update)
-        elif isinstance(update, (UpdateReadHistoryInbox, UpdateReadChannelInbox)):
-            await self.update_own_read_receipt(update)
-        elif isinstance(update, UpdateFolderPeers):
-            await self.update_folder_peers(update)
-        elif isinstance(update, UpdatePinnedDialogs):
-            await self.update_pinned_dialogs(update)
-        elif isinstance(update, UpdateNotifySettings):
-            await self.update_notify_settings(update)
-        elif isinstance(update, UpdateChannel):
-            await self.update_channel(update)
        else:
-            self.log.trace("Unhandled update: %s", update)
+            self.log.debug("Unhandled update: %s", update)

-    async def update_folder_peers(self, update: UpdateFolderPeers) -> None:
-        pass
-
-    async def update_pinned_dialogs(self, update: UpdatePinnedDialogs) -> None:
-        pass
-
-    async def update_notify_settings(self, update: UpdateNotifySettings) -> None:
-        pass
-
-    async def update_pinned_messages(
-        self, update: UpdatePinnedMessages | UpdatePinnedChannelMessages
-    ) -> None:
-        if isinstance(update, UpdatePinnedMessages):
-            portal = await po.Portal.get_by_entity(update.peer, tg_receiver=self.tgid)
+    async def update_pinned_messages(self, update: Union[UpdateChannelPinnedMessage,
+                                                         UpdateChatPinnedMessage]) -> None:
+        if isinstance(update, UpdateChatPinnedMessage):
+            portal = po.Portal.get_by_tgid(TelegramID(update.chat_id))
        else:
-            portal = await po.Portal.get_by_tgid(TelegramID(update.channel_id))
+            portal = po.Portal.get_by_tgid(TelegramID(update.channel_id))
        if portal and portal.mxid:
-            await portal.receive_telegram_pin_ids(
-                update.messages, self.tgid, remove=not update.pinned
-            )
+            await portal.receive_telegram_pin_id(update.id, self.tgid)

    @staticmethod
    async def update_participants(update: UpdateChatParticipants) -> None:
-        portal = await po.Portal.get_by_tgid(TelegramID(update.participants.chat_id))
+        portal = po.Portal.get_by_tgid(TelegramID(update.participants.chat_id))
        if portal and portal.mxid:
-            await portal.update_power_levels(update.participants.participants)
-
-    @staticmethod
-    async def update_default_banned_rights(update: UpdateChatDefaultBannedRights) -> None:
-        portal = await po.Portal.get_by_entity(update.peer)
-        if portal and portal.mxid:
-            await portal.update_default_banned_rights(update.default_banned_rights)
+            await portal.update_telegram_participants(update.participants.participants)

    async def update_read_receipt(self, update: UpdateReadHistoryOutbox) -> None:
        if not isinstance(update.peer, PeerUser):
            self.log.debug("Unexpected read receipt peer: %s", update.peer)
            return

-        portal = await po.Portal.get_by_tgid(
-            TelegramID(update.peer.user_id), tg_receiver=self.tgid
-        )
+        portal = po.Portal.get_by_tgid(TelegramID(update.peer.user_id), self.tgid)
        if not portal or not portal.mxid:
            return

        # We check that these are user read receipts, so tg_space is always the user ID.
-        message = await DBMessage.get_one_by_tgid(
-            TelegramID(update.max_id), self.tgid, edit_index=-1
-        )
+        message = DBMessage.get_one_by_tgid(TelegramID(update.max_id), self.tgid, edit_index=-1)
        if not message:
            return

-        puppet = await pu.Puppet.get_by_peer(update.peer)
-        await puppet.intent.mark_read(portal.mxid, message.mxid)
-
-    async def update_own_read_receipt(
-        self, update: UpdateReadHistoryInbox | UpdateReadChannelInbox
-    ) -> None:
-        puppet = await pu.Puppet.get_by_tgid(self.tgid)
-        if not puppet.is_real_user:
-            return
-
-        self.log.debug("Handling own read receipt: %s", update)
-        if isinstance(update, UpdateReadChannelInbox):
-            portal = await po.Portal.get_by_tgid(TelegramID(update.channel_id))
-        elif isinstance(update.peer, PeerChat):
-            portal = await po.Portal.get_by_tgid(TelegramID(update.peer.chat_id))
-        elif isinstance(update.peer, PeerUser):
-            portal = await po.Portal.get_by_tgid(
-                TelegramID(update.peer.user_id), tg_receiver=self.tgid
-            )
-        else:
-            self.log.debug("Unexpected own read receipt peer: %s", update.peer)
-            return
-
-        if not portal or not portal.mxid:
-            # TODO This explodes on channels because the field is channel_id
-            self.log.debug(f"Dropping own read receipt in unknown chat ({update.peer})")
-            return
-
-        tg_space = portal.tgid if portal.peer_type == "channel" else self.tgid
-        message = await DBMessage.get_one_by_tgid(
-            TelegramID(update.max_id), tg_space, edit_index=-1
-        )
-        if not message:
-            self.log.debug(
-                f"Dropping own read receipt: unknown message {update.max_id}@{tg_space}"
-            )
-            return
-
+        puppet = pu.Puppet.get(TelegramID(update.peer.user_id))
        await puppet.intent.mark_read(portal.mxid, message.mxid)

    async def update_admin(self, update: UpdateChatParticipantAdmin) -> None:
        # TODO duplication not checked
-        portal = await po.Portal.get_by_tgid(TelegramID(update.chat_id))
+        portal = po.Portal.get_by_tgid(TelegramID(update.chat_id), peer_type="chat")
        if not portal or not portal.mxid:
            return

        await portal.set_telegram_admin(TelegramID(update.user_id))

-    async def update_typing(
-        self, update: UpdateUserTyping | UpdateChatUserTyping | UpdateChannelUserTyping
-    ) -> None:
-        sender = None
+    async def update_typing(self, update: Union[UpdateUserTyping, UpdateChatUserTyping]) -> None:
        if isinstance(update, UpdateUserTyping):
-            portal = await po.Portal.get_by_tgid(
-                TelegramID(update.user_id), tg_receiver=self.tgid, peer_type="user"
-            )
-            sender = await pu.Puppet.get_by_tgid(TelegramID(update.user_id))
-        elif isinstance(update, UpdateChannelUserTyping):
-            portal = await po.Portal.get_by_tgid(TelegramID(update.channel_id))
-        elif isinstance(update, UpdateChatUserTyping):
-            portal = await po.Portal.get_by_tgid(TelegramID(update.chat_id))
+            portal = po.Portal.get_by_tgid(TelegramID(update.user_id), self.tgid, "user")
        else:
+            portal = po.Portal.get_by_tgid(TelegramID(update.chat_id), peer_type="chat")
+
+        if not portal or not portal.mxid:
            return

-        if isinstance(update, (UpdateChannelUserTyping, UpdateChatUserTyping)):
-            sender = await pu.Puppet.get_by_peer(update.from_id)
-
-        if not sender or not portal or not portal.mxid:
-            return
-
+        sender = pu.Puppet.get(TelegramID(update.user_id))
        await portal.handle_telegram_typing(sender, update)

-    async def _handle_entity_updates(self, entities: dict[int, User | Chat | Channel]) -> None:
+    async def _handle_entity_updates(self, entities: Dict[int, Union[User, Chat, Channel]]
+                                     ) -> None:
        try:
-            users = (entity for entity in entities.values() if isinstance(entity, (User, Channel)))
-            puppets = ((await pu.Puppet.get_by_peer(user), user) for user in users)
-            await asyncio.gather(
-                *[puppet.try_update_info(self, info) async for puppet, info in puppets if puppet]
-            )
+            users = (entity for entity in entities.values() if isinstance(entity, User))
+            puppets = ((pu.Puppet.get(TelegramID(user.id)), user) for user in users)
+            await asyncio.gather(*[puppet.update_info(self, info)
+                                   for puppet, info in puppets if puppet])
        except Exception:
            self.log.exception("Failed to handle entity updates")

-    async def update_others_info(self, update: UpdateUserName | UpdateUser) -> None:
+    async def update_others_info(self, update: Union[UpdateUserName, UpdateUserPhoto]) -> None:
        # TODO duplication not checked
-        puppet = await pu.Puppet.get_by_tgid(TelegramID(update.user_id))
+        puppet = pu.Puppet.get(TelegramID(update.user_id))
        if isinstance(update, UpdateUserName):
-            if len(update.usernames) > 1:
-                self.log.warning(
-                    "Got update with multiple usernames (%s) for %s, only saving first one",
-                    update.usernames,
-                    update.user_id,
-                )
-            puppet.username = update.usernames[0].username if update.usernames else None
+            puppet.username = update.username
            if await puppet.update_displayname(self, update):
-                await puppet.save()
-                await puppet.update_portals_meta()
-        elif isinstance(update, UpdateUser):
-            info = await self.client.get_entity(puppet.peer)
-            await puppet.update_info(self, info)
+                puppet.save()
+        elif isinstance(update, UpdateUserPhoto):
+            if await puppet.update_avatar(self, update.photo):
+                puppet.save()
        else:
-            self.log.warning(f"Unexpected other user info update: {type(update)}")
+            self.log.warning("Unexpected other user info update: %s", update)

    async def update_status(self, update: UpdateUserStatus) -> None:
-        puppet = await pu.Puppet.get_by_tgid(TelegramID(update.user_id))
+        puppet = pu.Puppet.get(TelegramID(update.user_id))
        if isinstance(update.status, UserStatusOnline):
-            await puppet.default_mxid_intent.set_presence(PresenceState.ONLINE)
+            await puppet.default_mxid_intent.set_presence("online")
        elif isinstance(update.status, UserStatusOffline):
-            await puppet.default_mxid_intent.set_presence(PresenceState.OFFLINE)
+            await puppet.default_mxid_intent.set_presence("offline")
        else:
-            self.log.warning(f"Unexpected user status update: type({update})")
+            self.log.warning("Unexpected user status update: %s", update)
        return

-    async def get_message_details(
-        self, update: UpdateMessage
-    ) -> tuple[UpdateMessageContent, pu.Puppet | None, po.Portal | None]:
+    def get_message_details(self, update: UpdateMessage) -> Tuple[UpdateMessageContent,
+                                                                  Optional[pu.Puppet],
+                                                                  Optional[po.Portal]]:
        if isinstance(update, UpdateShortChatMessage):
-            portal = await po.Portal.get_by_tgid(TelegramID(update.chat_id), peer_type="chat")
-            sender = await pu.Puppet.get_by_tgid(TelegramID(update.from_id))
+            portal = po.Portal.get_by_tgid(TelegramID(update.chat_id), peer_type="chat")
+            sender = pu.Puppet.get(TelegramID(update.from_id))
        elif isinstance(update, UpdateShortMessage):
-            portal = await po.Portal.get_by_tgid(
-                TelegramID(update.user_id), tg_receiver=self.tgid, peer_type="user"
-            )
-            sender = await pu.Puppet.get_by_tgid(self.tgid if update.out else update.user_id)
-        elif isinstance(
-            update,
-            (
-                UpdateNewMessage,
-                UpdateNewChannelMessage,
-                UpdateEditMessage,
-                UpdateEditChannelMessage,
-            ),
-        ):
+            portal = po.Portal.get_by_tgid(TelegramID(update.user_id), self.tgid, "user")
+            sender = pu.Puppet.get(self.tgid if update.out else update.user_id)
+        elif isinstance(update, (UpdateNewMessage, UpdateNewChannelMessage,
+                                 UpdateEditMessage, UpdateEditChannelMessage)):
            update = update.message
-            if isinstance(update, MessageEmpty):
-                return update, None, None
-            portal = await po.Portal.get_by_entity(update.peer_id, tg_receiver=self.tgid)
-            if update.out:
-                sender = await pu.Puppet.get_by_tgid(self.tgid)
-            elif isinstance(update.from_id, (PeerUser, PeerChannel)):
-                sender = await pu.Puppet.get_by_peer(update.from_id)
-            elif isinstance(update.peer_id, PeerUser):
-                sender = await pu.Puppet.get_by_peer(update.peer_id)
+            if isinstance(update.to_id, PeerUser) and not update.out:
+                portal = po.Portal.get_by_tgid(update.from_id, peer_type="user",
+                                               tg_receiver=self.tgid)
            else:
-                sender = None
+                portal = po.Portal.get_by_entity(update.to_id, receiver_id=self.tgid)
+            sender = pu.Puppet.get(update.from_id) if update.from_id else None
        else:
            self.log.warning(
-                f"Unexpected message type in User#get_message_details: {type(update)}"
-            )
+                f"Unexpected message type in User#get_message_details: {type(update)}")
            return update, None, None
        return update, sender, portal

    @staticmethod
    async def _try_redact(message: DBMessage) -> None:
-        portal = await po.Portal.get_by_mxid(message.mx_room)
+        portal = po.Portal.get_by_mxid(message.mx_room)
        if not portal:
            return
        try:
            await portal.main_intent.redact(message.mx_room, message.mxid)
-        except MatrixError:
+        except MatrixRequestError:
            pass

    async def delete_message(self, update: UpdateDeleteMessages) -> None:
-        if len(update.messages) > self.max_deletions:
+        if len(update.messages) > MAX_DELETIONS:
            return

        for message_id in update.messages:
-            for message in await DBMessage.get_all_by_tgid(TelegramID(message_id), self.tgid):
-                if message.redacted:
-                    continue
-                await message.delete()
-                number_left = await DBMessage.count_spaces_by_mxid(message.mxid, message.mx_room)
+            messages = DBMessage.get_all_by_tgid(TelegramID(message_id), self.tgid)
+            for message in messages:
+                message.delete()
+                number_left = DBMessage.count_spaces_by_mxid(message.mxid, message.mx_room)
                if number_left == 0:
+                    portal = po.Portal.get_by_mxid(message.mx_room)
                    await self._try_redact(message)

    async def delete_channel_message(self, update: UpdateDeleteChannelMessages) -> None:
-        if len(update.messages) > self.max_deletions:
+        if len(update.messages) > MAX_DELETIONS:
            return

        channel_id = TelegramID(update.channel_id)

        for message_id in update.messages:
-            for message in await DBMessage.get_all_by_tgid(TelegramID(message_id), channel_id):
-                if message.redacted:
-                    continue
-                await message.delete()
+            messages = DBMessage.get_all_by_tgid(TelegramID(message_id), channel_id)
+            for message in messages:
+                message.delete()
                await self._try_redact(message)

-    async def update_reactions(self, update: UpdateMessageReactions) -> None:
-        portal = await po.Portal.get_by_entity(update.peer, tg_receiver=self.tgid)
-        if not portal or not portal.mxid or not portal.allow_bridging:
-            return
-        await portal.handle_telegram_reactions(self, TelegramID(update.msg_id), update.reactions)
-
-    async def update_phone_call(self, update: UpdatePhoneCall) -> None:
-        self.log.debug("Phone call update %s", update)
-        if not isinstance(update.phone_call, PhoneCallRequested):
-            return
-        tgid = TelegramID(update.phone_call.participant_id)
-        if tgid == self.tgid:
-            tgid = update.phone_call.admin_id
-        portal = await po.Portal.get_by_tgid(tgid, tg_receiver=self.tgid, peer_type="user")
-        if not portal or not portal.mxid or not portal.allow_bridging:
-            return
-        sender = await pu.Puppet.get_by_tgid(TelegramID(update.phone_call.admin_id))
-        await portal.handle_telegram_direct_call(self, sender, update)
-
-    async def update_channel(self, update: UpdateChannel) -> None:
-        portal = await po.Portal.get_by_tgid(TelegramID(update.channel_id))
-        if not portal:
-            return
-        if getattr(update, "mau_telethon_is_leave", False):
-            self.log.debug("UpdateChannel has mau_telethon_is_leave, leaving portal")
-            await portal.delete_telegram_user(self.tgid, sender=None)
-        elif chan := getattr(update, "mau_channel", None):
-            if not portal.mxid:
-                background_task.create(self._delayed_create_channel(chan))
-            else:
-                self.log.debug("Updating channel info with data fetched by Telethon")
-                await portal.update_info(self, chan)
-                await portal.invite_to_matrix(self.mxid)
-
-    async def _delayed_create_channel(self, chan: Channel) -> None:
-        self.log.debug(
-            f"Waiting 5 seconds before handling UpdateChannel for non-existent portal {chan.id}"
-        )
-        await asyncio.sleep(5)
-        portal = await po.Portal.get_by_tgid(TelegramID(chan.id))
-        if portal.mxid:
-            self.log.debug(
-                "Portal started existing after waiting 5 seconds, "
-                f"dropping UpdateChannel for {portal.tgid}"
-            )
-            return
-        else:
-            self.log.info(
-                f"Creating Matrix room for {portal.tgid}"
-                " with data fetched by Telethon due to UpdateChannel"
-            )
-            await portal.create_matrix_room(self, chan, invites=[self.mxid])
-
-    async def _check_server_notice_edit(self, message: Message) -> None:
-        pass
-
    async def update_message(self, original_update: UpdateMessage) -> None:
-        update, sender, portal = await self.get_message_details(original_update)
-        if not portal:
-            return
-        elif portal and not portal.allow_bridging:
-            self.log.debug(
-                f"Ignoring message {update.id} in portal {portal.tgid_log} (bridging disallowed)"
-            )
+        update, sender, portal = self.get_message_details(original_update)
+
+        if self.is_bot and not portal.mxid:
+            self.log.debug(f"Ignoring message received by bot in unbridged chat %s",
+                           portal.tgid_log)
            return

-        if not portal.mxid and getattr(original_update, "mau_left_channel", False):
-            self.log.debug(
-                f"Ignoring message {update.id} in portal {portal.tgid_log} because user isn't in the chat"
-            )
+        if self.ignore_incoming_bot_events and self.bot and sender.id == self.bot.tgid:
+            self.log.debug(f"Ignoring relaybot-sent message %s to %s", update, portal.tgid_log)
            return

-        if self.is_relaybot:
-            if update.is_private:
-                if not self.config["bridge.relaybot.private_chat.invite"]:
-                    if sender:
-                        self.log.debug(f"Ignoring private message to bot from {sender.id}")
-                    return
-            elif not portal.mxid and self.config["bridge.relaybot.ignore_unbridged_group_chat"]:
-                self.log.debug(
-                    f"Ignoring message received by bot in unbridged chat {portal.tgid_log}"
-                )
-                return
-
-        if (
-            self.ignore_incoming_bot_events
-            and self.relaybot
-            and sender
-            and sender.id == self.relaybot.tgid
-        ):
-            self.log.debug("Ignoring relaybot-sent message %s to %s", update.id, portal.tgid_log)
-            return
-
-        task = self._call_portal_message_handler(update, original_update, portal, sender)
-        if portal.backfill_lock.locked:
-            self.log.debug(
-                f"{portal.tgid_log} is backfill locked, moving incoming message to async task"
-            )
-            background_task.create(task)
-        else:
-            await task
-
-    async def _call_portal_message_handler(
-        self,
-        update: UpdateMessageContent,
-        original_update: UpdateMessage,
-        portal: po.Portal,
-        sender: pu.Puppet,
-    ) -> None:
-        await portal.backfill_lock.wait(f"update {update.id}")
-
        if isinstance(update, MessageService):
            if isinstance(update.action, MessageActionChannelMigrateFrom):
-                self.log.debug(
-                    "Received %s in %s by %d, unregistering portal...",
-                    update.action,
-                    portal.tgid_log,
-                    sender.id,
-                )
-                await self.unregister_portal(update.action.chat_id, update.action.chat_id)
-                await self.register_portal(portal)
+                self.log.debug(f"Ignoring action %s to %s by %d", update.action,
+                               portal.tgid_log,
+                               sender.id)
                return
-            self.log.debug(
-                "Handling action %s to %s by %d",
-                update.action,
-                portal.tgid_log,
-                (sender.id if sender else 0),
-            )
+            self.log.debug("Handling action %s to %s by %d", update.action, portal.tgid_log,
+                           sender.id)
            return await portal.handle_telegram_action(self, sender, update)

+        user = sender.tgid if sender else "admin"
        if isinstance(original_update, (UpdateEditMessage, UpdateEditChannelMessage)):
-            if sender and sender.tgid == 777000:
-                await self._check_server_notice_edit(update)
            return await portal.handle_telegram_edit(self, sender, update)
+
+        self.log.debug("Handling message %s to %s by %s", update, portal.tgid_log, user)
        return await portal.handle_telegram_message(self, sender, update)

    # endregion
+
+
+def init(context: "Context") -> None:
+    global config, MAX_DELETIONS
+    AbstractUser.az, config, AbstractUser.loop, AbstractUser.relaybot = context.core
+    AbstractUser.ignore_incoming_bot_events = config["bridge.relaybot.ignore_own_incoming_events"]
+    AbstractUser.session_container = context.session_container
+    MAX_DELETIONS = config.get("bridge.max_telegram_delete", 10)
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 Tulir Asokan
+# 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
@@ -13,125 +14,63 @@
 #
 # 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 __future__ import annotations
-
-from typing import TYPE_CHECKING, Awaitable, Callable, Literal
+from typing import Awaitable, Callable, Dict, List, Optional, Pattern, Tuple, TYPE_CHECKING
 import logging
-import time
+import re

-from telethon.errors import (
-    AuthKeyError,
-    ChannelInvalidError,
-    ChannelPrivateError,
-    UnauthorizedError,
-)
-from telethon.tl.functions.channels import GetChannelsRequest, GetParticipantRequest
-from telethon.tl.functions.messages import GetChatsRequest, GetFullChatRequest
 from telethon.tl.patched import Message, MessageService
 from telethon.tl.types import (
-    ChannelParticipantAdmin,
-    ChannelParticipantCreator,
-    ChatForbidden,
-    ChatParticipantAdmin,
-    ChatParticipantCreator,
-    ChatParticipantsForbidden,
-    InputChannel,
-    InputUser,
-    MessageActionChatAddUser,
-    MessageActionChatDeleteUser,
-    MessageActionChatMigrateTo,
-    MessageEntityBotCommand,
-    PeerChannel,
-    PeerChat,
-    PeerUser,
-    TypeChannelParticipant,
-    TypeChatParticipant,
-    TypeInputPeer,
-    TypePeer,
-    UpdateNewChannelMessage,
-    UpdateNewMessage,
-    User,
-)
-from telethon.utils import add_surrogate, del_surrogate
+    ChannelParticipantAdmin, ChannelParticipantCreator, ChatForbidden, ChatParticipantAdmin,
+    ChatParticipantCreator, InputChannel, InputUser, MessageActionChatAddUser,
+    MessageActionChatDeleteUser, MessageEntityBotCommand, PeerChannel, PeerChat, TypePeer,
+    UpdateNewChannelMessage, UpdateNewMessage, MessageActionChatMigrateTo, User)
+from telethon.tl.functions.messages import GetChatsRequest, GetFullChatRequest
+from telethon.tl.functions.channels import GetChannelsRequest, GetParticipantRequest
+from telethon.errors import ChannelInvalidError, ChannelPrivateError

-from mautrix.errors import MBadState, MForbidden
-from mautrix.types import RoomID, UserID
-
-from . import portal as po, puppet as pu, user as u
+from .types import MatrixUserID
 from .abstract_user import AbstractUser
-from .db import BotChat, Message as DBMessage
+from .db import BotChat
 from .types import TelegramID
+from . import puppet as pu, portal as po, user as u

 if TYPE_CHECKING:
-    from asyncio import Future
+    from .config import Config
+    from .context import Context
+
+config = None  # type: Config

 ReplyFunc = Callable[[str], Awaitable[Message]]
-BanFunc = Callable[[RoomID, UserID, str], Awaitable[None]]
-TelegramAdminPermission = Literal[
-    "change_info",
-    "post_messages",
-    "edit_messages",
-    "delete_messages",
-    "ban_users",
-    "invite_users",
-    "pin_messages",
-    "add_admins",
-    "anonymous",
-    "manage_call",
-    "other",
-]


 class Bot(AbstractUser):
-    log: logging.Logger = logging.getLogger("mau.user.bot")
-
-    token: str
-    chats: dict[int, str]
-    tg_whitelist: list[int]
-    whitelist_group_admins: bool
-    _me_info: User | None
-    _me_mxid: UserID | None
-    _admin_cache: dict[
-        tuple[int, int],
-        tuple[ChatParticipantAdmin | ChatParticipantCreator | None, float],
-    ]
-    _login_wait_fut: Future | None
-    required_permissions: dict[str, TelegramAdminPermission] = {
-        "portal": None,
-        "invite": "invite_users",
-        "mxban": "ban_users",
-        "mxkick": "ban_users",
-    }
+    log = logging.getLogger("mau.bot")  # type: logging.Logger
+    mxid_regex = re.compile("@.+:.+")  # type: Pattern

    def __init__(self, token: str) -> None:
        super().__init__()
-        self.token = token
-        self.tgid = None
-        self.mxid = None
-        self.puppet_whitelisted = True
-        self.whitelisted = True
-        self.relaybot_whitelisted = True
-        self.tg_username = None
-        self.is_relaybot = True
-        self.is_bot = True
-        self.chats = {}
-        self._admin_cache = {}
-        self.tg_whitelist = []
-        self.whitelist_group_admins = (
-            self.config["bridge.relaybot.whitelist_group_admins"] or False
-        )
-        self._me_info = None
-        self._me_mxid = None
-        self._login_wait_fut = self.loop.create_future()
+        self.token = token  # type: str
+        self.puppet_whitelisted = True  # type: bool
+        self.whitelisted = True  # type: bool
+        self.relaybot_whitelisted = True  # type: bool
+        self.username = None  # type: str
+        self.is_relaybot = True  # type: bool
+        self.is_bot = True  # type: bool
+        self.chats = {}  # type: Dict[int, str]
+        self.tg_whitelist = []  # type: List[int]
+        self.whitelist_group_admins = (config["bridge.relaybot.whitelist_group_admins"]
+                                       or False)  # type: bool
+        self._me_info = None  # type: Optional[User]
+        self._me_mxid = None  # type: Optional[MatrixUserID]

-    async def get_me(self, use_cache: bool = True) -> tuple[User, UserID]:
+    async def get_me(self, use_cache: bool = True) -> Tuple[User, MatrixUserID]:
        if not use_cache or not self._me_mxid:
            self._me_info = await self.client.get_me()
            self._me_mxid = pu.Puppet.get_mxid_from_id(TelegramID(self._me_info.id))
        return self._me_info, self._me_mxid

    async def init_permissions(self) -> None:
-        whitelist = self.config["bridge.relaybot.whitelist"] or []
+        whitelist = config["bridge.relaybot.whitelist"] or []
        for user_id in whitelist:
            if isinstance(user_id, str):
                entity = await self.client.get_input_entity(user_id)
@@ -142,311 +81,204 @@ class Bot(AbstractUser):
            if isinstance(user_id, int):
                self.tg_whitelist.append(user_id)

-    async def start(self, delete_unless_authenticated: bool = False) -> Bot:
-        self.chats = {chat.id: chat.type for chat in await BotChat.all()}
+    async def start(self, delete_unless_authenticated: bool = False) -> 'Bot':
+        self.chats = {chat.id: chat.type for chat in BotChat.all()}
        await super().start(delete_unless_authenticated)
        if not await self.is_logged_in():
            await self.client.sign_in(bot_token=self.token)
        await self.post_login()
        return self

-    async def on_signed_out(self, err: UnauthorizedError | AuthKeyError) -> None:
-        self.log.fatal("Relay bot got signed out, crashing bridge", exc_info=err)
-        self.bridge.manual_stop(51)
-
    async def post_login(self) -> None:
        await self.init_permissions()
        info = await self.client.get_me()
-        self.tgid = TelegramID(info.id)
-        self.tg_username = info.username
+        self.tgid = info.id
+        self.username = info.username
        self.mxid = pu.Puppet.get_mxid_from_id(self.tgid)
-        if self._login_wait_fut:
-            self._login_wait_fut.set_result(None)
-            self._login_wait_fut = None

        chat_ids = [chat_id for chat_id, chat_type in self.chats.items() if chat_type == "chat"]
        response = await self.client(GetChatsRequest(chat_ids))
        for chat in response.chats:
            if isinstance(chat, ChatForbidden) or chat.left or chat.deactivated:
-                await self.remove_chat(TelegramID(chat.id))
+                self.remove_chat(TelegramID(chat.id))

-        channel_ids = [
-            InputChannel(chat_id, 0)
-            for chat_id, chat_type in self.chats.items()
-            if chat_type == "channel"
-        ]
+        channel_ids = [InputChannel(chat_id, 0)
+                       for chat_id, chat_type in self.chats.items()
+                       if chat_type == "channel"]
        for channel_id in channel_ids:
            try:
                await self.client(GetChannelsRequest([channel_id]))
            except (ChannelPrivateError, ChannelInvalidError):
-                await self.remove_chat(TelegramID(channel_id.channel_id))
+                self.remove_chat(TelegramID(channel_id.channel_id))

-    async def register_portal(self, portal: po.Portal) -> None:
-        await self.add_chat(portal.tgid, portal.peer_type)
+        if config["bridge.catch_up"]:
+            try:
+                await self.client.catch_up()
+            except Exception:
+                self.log.exception("Failed to run catch_up() for bot")

-    async def unregister_portal(self, tgid: TelegramID, tg_receiver: TelegramID) -> None:
-        await self.remove_chat(tgid)
+    def register_portal(self, portal: po.Portal) -> None:
+        self.add_chat(portal.tgid, portal.peer_type)

-    async def add_chat(self, chat_id: TelegramID, chat_type: str) -> None:
+    def unregister_portal(self, portal: po.Portal) -> None:
+        self.remove_chat(portal.tgid)
+
+    def add_chat(self, chat_id: TelegramID, chat_type: str) -> None:
        if chat_id not in self.chats:
            self.chats[chat_id] = chat_type
-            await BotChat(id=chat_id, type=chat_type).insert()
+            BotChat(id=TelegramID(chat_id), type=chat_type).insert()

-    async def remove_chat(self, chat_id: TelegramID) -> None:
+    def remove_chat(self, chat_id: TelegramID) -> None:
        try:
            del self.chats[chat_id]
        except KeyError:
            pass
-        await BotChat.delete_by_id(chat_id)
+        BotChat.delete(chat_id)

-    async def _get_admin_participant(
-        self, chat: TypePeer | TypeInputPeer, tgid: TelegramID
-    ) -> TypeChatParticipant | TypeChannelParticipant | None:
-        chan_id = chat.channel_id if isinstance(chat, PeerChannel) else chat.chat_id
-        try:
-            cached, created = self._admin_cache[chan_id, tgid]
-            if created + 60 < time.time():
-                return cached
-        except KeyError:
-            pass
-        if isinstance(chat, PeerChannel):
-            p = await self.client(GetParticipantRequest(chat, tgid))
-            pcp = p.participant
-            self._admin_cache[chat.channel_id, tgid] = (pcp, time.time())
-            return pcp
-        elif isinstance(chat, PeerChat):
-            chat = await self.client(GetFullChatRequest(chat.chat_id))
-            if isinstance(chat.full_chat.participants, ChatParticipantsForbidden):
-                return None
-            participants = chat.full_chat.participants.participants
-            for p in participants:
-                self._admin_cache[chat.channel_id, tgid] = (p, time.time())
-                if p.user_id == tgid:
-                    return p
-        return None
-
-    @staticmethod
-    def _has_participant_permission(
-        pcp: TypeChatParticipant | TypeChannelParticipant | None,
-        permission: TelegramAdminPermission | None,
-    ) -> bool:
-        if isinstance(pcp, (ChannelParticipantCreator, ChannelParticipantAdmin)):
-            return permission is None or getattr(pcp.admin_rights, permission, False)
-        elif isinstance(pcp, (ChatParticipantCreator, ChatParticipantAdmin)):
-            return True
-        return False
-
-    async def _can_use_commands(
-        self, chat: TypePeer, tgid: TelegramID, permission: TelegramAdminPermission | None = None
-    ) -> bool:
+    async def _can_use_commands(self, chat: TypePeer, tgid: TelegramID) -> bool:
        if tgid in self.tg_whitelist:
            return True

-        user = await u.User.get_by_tgid(tgid)
+        user = u.User.get_by_tgid(tgid)
        if user and user.is_admin:
            self.tg_whitelist.append(user.tgid)
            return True

        if self.whitelist_group_admins:
-            pcp = await self._get_admin_participant(chat, tgid)
-            return self._has_participant_permission(pcp, permission)
+            if isinstance(chat, PeerChannel):
+                p = await self.client(GetParticipantRequest(chat, tgid))
+                return isinstance(p, (ChannelParticipantCreator, ChannelParticipantAdmin))
+            elif isinstance(chat, PeerChat):
+                chat = await self.client(GetFullChatRequest(chat.chat_id))
+                participants = chat.full_chat.participants.participants
+                for p in participants:
+                    if p.user_id == tgid:
+                        return isinstance(p, (ChatParticipantCreator, ChatParticipantAdmin))
        return False

-    async def check_can_use_command(self, event: Message, reply: ReplyFunc, command: str) -> bool:
-        if command not in self.required_permissions:
-            # Unknown command
-            return False
-        elif not isinstance(event.from_id, PeerUser):
-            await reply("Channels can't use commands")
-            return False
-        elif not await self._can_use_commands(
-            event.to_id, TelegramID(event.from_id.user_id), self.required_permissions[command]
-        ):
+    async def check_can_use_commands(self, event: Message, reply: ReplyFunc) -> bool:
+        if not await self._can_use_commands(event.to_id, event.from_id):
            await reply("You do not have the permission to use that command.")
            return False
        return True

    async def handle_command_portal(self, portal: po.Portal, reply: ReplyFunc) -> Message:
-        if not self.config["bridge.relaybot.authless_portals"]:
+        if not config["bridge.relaybot.authless_portals"]:
            return await reply("This bridge doesn't allow portal creation from Telegram.")

-        if not portal.allow_bridging:
+        if not portal.allow_bridging():
            return await reply("This bridge doesn't allow bridging this chat.")

        await portal.create_matrix_room(self)
        if portal.mxid:
            if portal.username:
                return await reply(
-                    f"Portal is public: [{portal.alias}](https://matrix.to/#/{portal.alias})"
-                )
+                    f"Portal is public: [{portal.alias}](https://matrix.to/#/{portal.alias})")
            else:
-                return await reply("Portal is not public. Use `/invite <mxid>` to get an invite.")
-        else:
-            return await reply("Couldn't create portal room")
+                return await reply(
+                    "Portal is not public. Use `/invite <mxid>` to get an invite.")

-    async def handle_command_invite(
-        self, portal: po.Portal, reply: ReplyFunc, mxid_input: UserID
-    ) -> Message:
+    async def handle_command_invite(self, portal: po.Portal, reply: ReplyFunc,
+                                    mxid_input: MatrixUserID) -> Message:
        if len(mxid_input) == 0:
            return await reply("Usage: `/invite <mxid>`")
        elif not portal.mxid:
-            return await reply("Portal does not have Matrix room. Create one with /portal first.")
-        if mxid_input[0] != "@" or mxid_input.find(":") < 2:
+            return await reply("Portal does not have Matrix room. "
+                               "Create one with /portal first.")
+        if not self.mxid_regex.match(mxid_input):
            return await reply("That doesn't look like a Matrix ID.")
-        user = await u.User.get_and_start_by_mxid(mxid_input)
+        user = await u.User.get_by_mxid(MatrixUserID(mxid_input)).ensure_started()
        if not user.relaybot_whitelisted:
            return await reply("That user is not whitelisted to use the bridge.")
        elif await user.is_logged_in():
-            displayname = f"@{user.tg_username}" if user.tg_username else user.displayname
-            return await reply(
-                "That user seems to be logged in. "
-                f"Just invite [{displayname}](tg://user?id={user.tgid})"
-            )
+            displayname = f"@{user.username}" if user.username else user.displayname
+            return await reply("That user seems to be logged in. "
+                               f"Just invite [{displayname}](tg://user?id={user.tgid})")
        else:
-            try:
-                await portal.invite_to_matrix(user.mxid)
-            except MBadState:
-                try:
-                    await portal.main_intent.unban_user(
-                        portal.mxid, user.mxid, reason="Invited from Telegram"
-                    )
-                except Exception:
-                    return await reply(f"Failed to unban `{user.mxid}` from the portal.")
-                await portal.invite_to_matrix(user.mxid)
-                return await reply(f"Unbanned and invited `{user.mxid}` to the portal.")
+            await portal.main_intent.invite(portal.mxid, user.mxid)
            return await reply(f"Invited `{user.mxid}` to the portal.")

-    async def handle_command_ban(
-        self,
-        message: Message,
-        portal: po.Portal,
-        reply: ReplyFunc,
-        reason: str,
-        action: Literal["kick", "ban"] = "ban",
-    ) -> Message:
-        if not message.reply_to:
-            return await reply("You must reply to a relaybot message when using that command")
-        reply_to_id = TelegramID(message.reply_to.reply_to_msg_id)
-        tg_space = portal.tgid if portal.peer_type == "channel" else self.tgid
-        msg = await DBMessage.get_one_by_tgid(reply_to_id, tg_space)
-        if not msg or msg.sender != self.tgid or not msg.sender_mxid:
-            return await reply("Target message is not a relayed message")
-        puppet = await pu.Puppet.get_by_peer(message.from_id)
-        actioned = "Banned" if action == "ban" else "Kicked"
-        try:
-            intent = puppet.intent_for(portal)
-            func: BanFunc = intent.ban_user if action == "ban" else intent.kick_user
-            await func(portal.mxid, msg.sender_mxid, reason)
-        except MForbidden as e:
-            self.log.warning(
-                f"Failed to {action} {msg.sender_mxid} from {portal.mxid} as {puppet.mxid}: {e}, "
-                f"falling back to bridge bot"
-            )
-            reason_prefix = f"{actioned} by {puppet.displayname or puppet.tgid}"
-            reason = f"{reason_prefix}: {reason}" if reason else reason_prefix
-            try:
-                func: BanFunc = (
-                    self.az.intent.ban_user if action == "ban" else self.az.intent.kick_user
-                )
-                await func(portal.mxid, msg.sender_mxid, reason)
-            except MForbidden as e:
-                self.log.warning(
-                    f"Failed to {action} {msg.sender_mxid} from {portal.mxid} as bridge bot: {e}"
-                )
-                return await reply(f"Failed to {action} `{msg.sender_mxid}`")
-        return await reply(f"Successfully {actioned.lower()} `{msg.sender_mxid}`")
-
    @staticmethod
    def handle_command_id(message: Message, reply: ReplyFunc) -> Awaitable[Message]:
        # Provide the prefixed ID to the user so that the user wouldn't need to specify whether the
        # chat is a normal group or a supergroup/channel when using the ID.
        if isinstance(message.to_id, PeerChannel):
            return reply(f"-100{message.to_id.channel_id}")
-        elif isinstance(message.to_id, PeerChat):
-            return reply(str(-message.to_id.chat_id))
-        elif isinstance(message.to_id, PeerUser):
-            return reply(
-                f"Your user ID is {message.to_id.user_id}.\n\n"
-                f"If you're trying to bridge a group chat to Matrix, you must run the command in "
-                f"the group, not here. **The ID above will not work** with `!tg bridge`."
-            )
-        else:
-            return reply("Failed to find chat ID.")
+        return reply(str(-message.to_id.chat_id))

-    def parse_command(self, message: Message) -> tuple[str | None, str | None]:
-        if not message.entities or len(message.entities) < 1 or not message.message:
-            return None, None
-        cmd_entity = message.entities[0]
-        if not isinstance(cmd_entity, MessageEntityBotCommand) or cmd_entity.offset != 0:
-            return None, None
-        surrogated_text = add_surrogate(message.message)
-        command: str = del_surrogate(surrogated_text[: cmd_entity.length]).lower()
-        rest_of_message: str = ""
-        if len(surrogated_text) > cmd_entity.length + 1:
-            rest_of_message: str = del_surrogate(surrogated_text[cmd_entity.length + 1 :])
-        command, *target = command.split("@", 1)
-        if not command.startswith("/"):
-            return None, None
-        elif target and target[0] != self.tg_username.lower():
-            return None, None
-        return command[1:], rest_of_message
+    def match_command(self, text: str, command: str) -> bool:
+        text = text.lower()
+        command = f"/{command.lower()}"
+        command_targeted = f"{command}@{self.username.lower()}"

-    async def handle_command(self, message: Message, command: str, args: str) -> None:
+        is_plain_command = text == command or text == command_targeted
+        if is_plain_command:
+            return True
+
+        is_arg_command = text.startswith(command + " ") or text.startswith(command_targeted + " ")
+        if is_arg_command:
+            return True
+
+        return False
+
+    async def handle_command(self, message: Message) -> None:
        def reply(reply_text: str) -> Awaitable[Message]:
-            return self.client.send_message(message.chat_id, reply_text, reply_to=message.id)
+            return self.client.send_message(message.to_id, reply_text, reply_to=message.id)

-        if command == "start" and message.is_private:
-            pcm = self.config["bridge.relaybot.private_chat.message"]
-            if pcm:
-                await reply(pcm)
-        elif command == "id":
+        text = message.message
+
+        if self.match_command(text, "id"):
            await self.handle_command_id(message, reply)
-        elif not message.is_private:
-            if not await self.check_can_use_command(message, reply, command):
-                return
-            portal = await po.Portal.get_by_entity(message.to_id)
-            if command == "portal":
-                await self.handle_command_portal(portal, reply)
-            elif command == "invite":
-                await self.handle_command_invite(portal, reply, mxid_input=UserID(args))
-            elif command == "mxban":
-                await self.handle_command_ban(message, portal, reply, reason=args)
-            elif command == "mxkick":
-                await self.handle_command_ban(message, portal, reply, reason=args, action="kick")
+            return

-    async def handle_service_message(self, message: MessageService) -> None:
-        to_peer = message.to_id
-        if isinstance(to_peer, PeerChannel):
-            to_id = TelegramID(to_peer.channel_id)
+        portal = po.Portal.get_by_entity(message.to_id)
+
+        if self.match_command(text, "portal"):
+            if not await self.check_can_use_commands(message, reply):
+                return
+            await self.handle_command_portal(portal, reply)
+        elif self.match_command(text, "invite"):
+            if not await self.check_can_use_commands(message, reply):
+                return
+            try:
+                mxid = text[text.index(" ") + 1:]
+            except ValueError:
+                mxid = ""
+            await self.handle_command_invite(portal, reply, mxid_input=mxid)
+
+    def handle_service_message(self, message: MessageService) -> None:
+        to_id = message.to_id  # type: TelegramID
+        if isinstance(to_id, PeerChannel):
+            to_id = to_id.channel_id
            chat_type = "channel"
-        elif isinstance(to_peer, PeerChat):
-            to_id = TelegramID(to_peer.chat_id)
+        elif isinstance(to_id, PeerChat):
+            to_id = to_id.chat_id
            chat_type = "chat"
        else:
            return

        action = message.action
        if isinstance(action, MessageActionChatAddUser) and self.tgid in action.users:
-            await self.add_chat(to_id, chat_type)
+            self.add_chat(to_id, chat_type)
        elif isinstance(action, MessageActionChatDeleteUser) and action.user_id == self.tgid:
-            await self.remove_chat(to_id)
+            self.remove_chat(to_id)
        elif isinstance(action, MessageActionChatMigrateTo):
-            await self.remove_chat(to_id)
-            await self.add_chat(TelegramID(action.channel_id), "channel")
+            self.remove_chat(to_id)
+            self.add_chat(TelegramID(action.channel_id), "channel")

    async def update(self, update) -> bool:
-        if self._login_wait_fut:
-            await self._login_wait_fut
        if not isinstance(update, (UpdateNewMessage, UpdateNewChannelMessage)):
            return False
        if isinstance(update.message, MessageService):
-            await self.handle_service_message(update.message)
+            self.handle_service_message(update.message)
            return False

-        if isinstance(update.message, Message):
-            command, args = self.parse_command(update.message)
-            if command:
-                await self.handle_command(update.message, command, args)
+        is_command = (isinstance(update.message, Message)
+                      and update.message.entities and len(update.message.entities) > 0
+                      and isinstance(update.message.entities[0], MessageEntityBotCommand))
+        if is_command:
+            await self.handle_command(update.message)
+            return True
        return False

    def is_in_chat(self, peer_id) -> bool:
@@ -455,3 +287,12 @@ class Bot(AbstractUser):
    @property
    def name(self) -> str:
        return "bot"
+
+
+def init(cfg: 'Config') -> Optional[Bot]:
+    global config
+    config = cfg
+    token = config["telegram.bot_token"]
+    if token and not token.lower().startswith("disable"):
+        return Bot(token)
+    return None
@@ -1,26 +1,5 @@
-from .handler import (
-    SECTION_ADMIN,
-    SECTION_AUTH,
-    SECTION_CREATING_PORTALS,
-    SECTION_MISC,
-    SECTION_PORTAL_MANAGEMENT,
-    CommandEvent,
-    CommandHandler,
-    CommandProcessor,
-    command_handler,
-)
-
-# This has to happen after the handler imports
-from . import matrix_auth, portal, telegram  # isort: skip
-
-__all__ = [
-    "command_handler",
-    "CommandHandler",
-    "CommandProcessor",
-    "CommandEvent",
-    "SECTION_AUTH",
-    "SECTION_MISC",
-    "SECTION_ADMIN",
-    "SECTION_CREATING_PORTALS",
-    "SECTION_PORTAL_MANAGEMENT",
-]
+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
@@ -0,0 +1,178 @@
+# -*- coding: future_fstrings -*-
+# 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, NewType, Optional, Tuple, Union
+
+from mautrix_appservice import MatrixRequestError, IntentAPI
+
+from ..types import MatrixRoomID, MatrixUserID
+from . import command_handler, CommandEvent, SECTION_ADMIN
+from .. import puppet as pu, portal as po
+
+ManagementRoom = NewType('ManagementRoom', Tuple[MatrixRoomID, MatrixUserID])
+
+
+async def _find_rooms(intent: IntentAPI) -> Tuple[List[ManagementRoom], List[MatrixRoomID],
+                                                  List['po.Portal'], List['po.Portal']]:
+    management_rooms = []  # type: List[ManagementRoom]
+    unidentified_rooms = []  # type: List[MatrixRoomID]
+    portals = []  # type: List[po.Portal]
+    empty_portals = []  # type: List[po.Portal]
+
+    rooms = await intent.get_joined_rooms()
+    for room_str in rooms:
+        room = MatrixRoomID(room_str)
+        portal = po.Portal.get_by_mxid(room)
+        if not portal:
+            try:
+                members = await intent.get_room_members(room)
+            except MatrixRequestError:
+                members = []
+            if len(members) == 2:
+                other_member = MatrixUserID(members[0] if members[0] != intent.mxid else members[1])
+                if pu.Puppet.get_id_from_mxid(other_member):
+                    unidentified_rooms.append(room)
+                else:
+                    management_rooms.append(ManagementRoom((room, other_member)))
+            else:
+                unidentified_rooms.append(room)
+        else:
+            members = await portal.get_authenticated_matrix_users()
+            if len(members) == 0:
+                empty_portals.append(portal)
+            else:
+                portals.append(portal)
+
+    return management_rooms, unidentified_rooms, portals, empty_portals
+
+
+@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]:
+    management_rooms, unidentified_rooms, portals, empty_portals = await _find_rooms(evt.az.intent)
+
+    reply = ["#### Management rooms (M)"]
+    reply += ([f"{n+1}. [M{n+1}](https://matrix.to/#/{room}) (with {other_member}"
+               for n, (room, other_member) in enumerate(management_rooms)]
+              or ["No management rooms found."])
+    reply.append("#### Active portal rooms (A)")
+    reply += ([f"{n+1}. [A{n+1}](https://matrix.to/#/{portal.mxid}) "
+               f"(to Telegram chat \"{portal.title}\")"
+               for n, portal in enumerate(portals)]
+              or ["No active portal rooms found."])
+    reply.append("#### Unidentified rooms (U)")
+    reply += ([f"{n+1}. [U{n+1}](https://matrix.to/#/{room})"
+               for n, room in enumerate(unidentified_rooms)]
+              or ["No unidentified rooms found."])
+    reply.append("#### Inactive portal rooms (I)")
+    reply += ([f"{n}. [I{n}](https://matrix.to/#/{portal.mxid}) "
+               f"(to Telegram chat \"{portal.title}\")"
+               for n, portal in enumerate(empty_portals)]
+              or ["No inactive portal rooms found."])
+
+    reply += ["#### Usage",
+              ("To clean the recommended set of rooms (unidentified & inactive portals), "
+               "type `$cmdprefix+sp clean-recommended`"),
+              "",
+              ("To clean other groups of rooms, type `$cmdprefix+sp clean-groups <letters>` "
+               "where `letters` are the first letters of the group names (M, A, U, I)"),
+              "",
+              ("To clean specific rooms, type `$cmdprefix+sp clean-range <range>` "
+               "where `range` is the range (e.g. `5-21`) prefixed with the first letter of"
+               "the group name. (e.g. `I2-6`)"),
+              "",
+              ("Please note that you will have to re-run `$cmdprefix+sp clean-rooms` "
+               "between each use of the commands above.")]
+
+    evt.sender.command_status = {
+        "next": lambda clean_evt: set_rooms_to_clean(clean_evt, management_rooms,
+                                                     unidentified_rooms, portals, empty_portals),
+        "action": "Room cleaning",
+    }
+
+    return await evt.reply("\n".join(reply))
+
+
+async def set_rooms_to_clean(evt, management_rooms: List[ManagementRoom],
+                             unidentified_rooms: List[MatrixRoomID], portals: List["po.Portal"],
+                             empty_portals: List["po.Portal"]) -> None:
+    command = evt.args[0]
+    rooms_to_clean = []  # type: List[Union[po.Portal, MatrixRoomID]]
+    if command == "clean-recommended":
+        rooms_to_clean += empty_portals
+        rooms_to_clean += unidentified_rooms
+    elif command == "clean-groups":
+        if len(evt.args) < 2:
+            return await evt.reply("**Usage:** `$cmdprefix+sp clean-groups [M][A][U][I]")
+        groups_to_clean = evt.args[1].upper()
+        if "M" in groups_to_clean:
+            rooms_to_clean += [room_id for (room_id, user_id) in management_rooms]
+        if "A" in groups_to_clean:
+            rooms_to_clean += portals
+        if "U" in groups_to_clean:
+            rooms_to_clean += unidentified_rooms
+        if "I" in groups_to_clean:
+            rooms_to_clean += empty_portals
+    elif command == "clean-range":
+        try:
+            clean_range = evt.args[1]
+            group, clean_range = clean_range[0], clean_range[1:]
+            start, end = clean_range.split("-")
+            start, end = int(start), int(end)
+            if group == "M":
+                group = [room_id for (room_id, user_id) in management_rooms]
+            elif group == "A":
+                group = portals
+            elif group == "U":
+                group = unidentified_rooms
+            elif group == "I":
+                group = empty_portals
+            else:
+                raise ValueError("Unknown group")
+            rooms_to_clean = group[start - 1:end]
+        except (KeyError, ValueError):
+            return await evt.reply(
+                "**Usage:** `$cmdprefix+sp clean-groups <_M|A|U|I_><range>")
+    else:
+        return await evt.reply(f"Unknown room cleaning action `{command}`. "
+                               "Use `$cmdprefix+sp cancel` to cancel room "
+                               "cleaning.")
+
+    evt.sender.command_status = {
+        "next": lambda confirm: execute_room_cleanup(confirm, rooms_to_clean),
+        "action": "Room cleaning",
+    }
+    await evt.reply(f"To confirm cleaning up {len(rooms_to_clean)} rooms, type"
+                    "`$cmdprefix+sp confirm-clean`.")
+
+
+async def execute_room_cleanup(evt, rooms_to_clean: List[Union[po.Portal, MatrixRoomID]]) -> 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.")
+        cleaned = 0
+        for room in rooms_to_clean:
+            if isinstance(room, po.Portal):
+                await room.cleanup_and_delete()
+                cleaned += 1
+            elif isinstance(room, str):  # str is aliased by MatrixRoomID
+                await po.Portal.cleanup_room(evt.az.intent, room, message="Room deleted")
+                cleaned += 1
+        evt.sender.command_status = None
+        await evt.reply(f"{cleaned} rooms cleaned up successfully.")
+    else:
+        await evt.reply("Room cleaning cancelled.")
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,38 +14,24 @@
 #
 # 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 __future__ import annotations
+"""This module contains classes handling commands issued by Matrix users."""
+from typing import Awaitable, Callable, Dict, List, NamedTuple, Optional
+import logging
+import traceback

-from typing import TYPE_CHECKING, Any, Awaitable, Callable, NamedTuple
+import commonmark

 from telethon.errors import FloodWaitError

-from mautrix.bridge.commands import (
-    CommandEvent as BaseCommandEvent,
-    CommandHandler as BaseCommandHandler,
-    CommandHandlerFunc,
-    CommandProcessor as BaseCommandProcessor,
-    HelpSection,
-    command_handler as base_command_handler,
-)
-from mautrix.types import EventID, MessageEventContent, RoomID
-from mautrix.util.format_duration import format_duration
+from ..types import MatrixRoomID, MatrixEventID
+from ..util import format_duration
+from .. import user as u, context as c

-from .. import portal as po, user as u
-
-if TYPE_CHECKING:
-    from ..__main__ import TelegramBridge
-
-
-class HelpCacheKey(NamedTuple):
-    is_management: bool
-    is_portal: bool
-    puppet_whitelisted: bool
-    matrix_puppet_whitelisted: bool
-    is_admin: bool
-    is_logged_in: bool
+command_handlers = {}  # type: Dict[str, CommandHandler]

+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, "")
@@ -52,145 +39,327 @@ SECTION_MISC = HelpSection("Miscellaneous", 40, "")
 SECTION_ADMIN = HelpSection("Administration", 50, "")


-class CommandEvent(BaseCommandEvent):
-    sender: u.User
-    portal: po.Portal
+class HtmlEscapingRenderer(commonmark.HtmlRenderer):
+    def __init__(self, allow_html: bool = False):
+        super().__init__()
+        self.allow_html = allow_html

-    def __init__(
-        self,
-        processor: CommandProcessor,
-        room_id: RoomID,
-        event_id: EventID,
-        sender: u.User,
-        command: str,
-        args: list[str],
-        content: MessageEventContent,
-        portal: po.Portal | None,
-        is_management: bool,
-        has_bridge_bot: bool,
-    ) -> None:
-        super().__init__(
-            processor,
-            room_id,
-            event_id,
-            sender,
-            command,
-            args,
-            content,
-            portal,
-            is_management,
-            has_bridge_bot,
-        )
-        self.bridge = processor.bridge
+    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: MatrixRoomID, event: MatrixEventID,
+                 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
        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

-    @property
-    def print_error_traceback(self) -> bool:
-        return self.sender.is_admin
+    def reply(self, message: str, allow_html: bool = False, render_markdown: bool = True
+              ) -> Awaitable[Dict]:
+        """Write a reply to the room in which the command was issued.

-    async def get_help_key(self) -> HelpCacheKey:
-        return HelpCacheKey(
-            self.is_management,
-            self.portal is not None,
-            self.sender.puppet_whitelisted,
-            self.sender.matrix_puppet_whitelisted,
-            self.sender.is_admin,
-            await self.sender.is_logged_in(),
+        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} "
        )
-
-
-class CommandHandler(BaseCommandHandler):
-    name: str
-
-    needs_puppeting: bool
-    needs_matrix_puppeting: bool
-
-    def __init__(
-        self,
-        handler: Callable[[CommandEvent], Awaitable[EventID]],
-        management_only: bool,
-        name: str,
-        help_text: str,
-        help_args: str,
-        help_section: HelpSection,
-        needs_auth: bool,
-        needs_puppeting: bool,
-        needs_matrix_puppeting: bool,
-        needs_admin: bool,
-        **kwargs,
-    ) -> None:
-        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,
-            **kwargs,
-        )
-
-    async def get_permission_error(self, evt: CommandEvent) -> str | None:
-        if self.needs_puppeting and not evt.sender.puppet_whitelisted:
-            return "That command is limited to users with puppeting privileges."
-        elif self.needs_matrix_puppeting and not evt.sender.matrix_puppet_whitelisted:
-            return "That command is limited to users with full puppeting privileges."
-        return await super().get_permission_error(evt)
-
-    def has_permission(self, key: HelpCacheKey) -> bool:
-        return (
-            super().has_permission(key)
-            and (not self.needs_puppeting or key.puppet_whitelisted)
-            and (not self.needs_matrix_puppeting or key.matrix_puppet_whitelisted)
-        )
-
-
-def command_handler(
-    _func: CommandHandlerFunc | None = None,
-    *,
-    needs_auth: bool = True,
-    needs_puppeting: bool = True,
-    needs_matrix_puppeting: bool = False,
-    needs_admin: bool = False,
-    management_only: bool = False,
-    name: str | None = None,
-    aliases: list[str] | None = None,
-    help_text: str = "",
-    help_args: str = "",
-    help_section: HelpSection = None,
-) -> Callable[[CommandHandlerFunc], CommandHandler]:
-    return base_command_handler(
-        _func,
-        _handler_class=CommandHandler,
-        name=name,
-        aliases=aliases,
-        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(BaseCommandProcessor):
-    def __init__(self, bridge: "TelegramBridge") -> None:
-        super().__init__(event_class=CommandEvent, bridge=bridge)
-        self.tgbot = bridge.bot
-        self.public_website = bridge.public_website
+        return message.replace("$cmdprefix", self.command_prefix)

    @staticmethod
-    async def _run_handler(
-        handler: Callable[[CommandEvent], Awaitable[Any]], evt: CommandEvent
-    ) -> Any:
+    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
+
+
+class CommandHandler:
+    """A command which can be executed from a Matrix room.
+
+    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.
+    """
+
+    def __init__(self, handler: Callable[[CommandEvent], Awaitable[Dict]], 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
+
+    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.")
+        elif self.needs_puppeting and not evt.sender.puppet_whitelisted:
+            return "This command requires puppeting privileges."
+        elif self.needs_matrix_puppeting and not evt.sender.matrix_puppet_whitelisted:
+            return "This command requires Matrix puppeting privileges."
+        elif self.needs_admin and not evt.sender.is_admin:
+            return "This command requires administrator privileges."
+        elif self.needs_auth and not await evt.sender.is_logged_in():
+            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) -> Dict:
+        """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 command_handler(_func: Optional[Callable[[CommandEvent], Awaitable[Dict]]] = 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[Dict]]]],
+                                  CommandHandler]:
+    def decorator(func: Callable[[CommandEvent], Awaitable[Optional[Dict]]]) -> 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)
+
+
+class CommandProcessor:
+    """Handles the raw commands issued by a user to the Matrix bot."""
+    log = logging.getLogger("mau.commands")
+
+    def __init__(self, context: c.Context) -> None:
+        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: MatrixRoomID, event_id: MatrixEventID, sender: u.User,
+                     command: str, args: List[str], is_management: bool, is_portal: bool
+                     ) -> Optional[Dict]:
+        """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()
        try:
-            return await handler(evt)
+            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)
        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
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,27 +14,33 @@
 #
 # 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 mautrix.bridge import InvalidAccessToken, OnlyLoginSelf
-from mautrix.types import EventID
+from typing import Dict, Optional

+from . import command_handler, CommandEvent, SECTION_AUTH
 from .. import puppet as pu
-from . import SECTION_AUTH, CommandEvent, command_handler


-@command_handler(
-    needs_auth=True,
-    management_only=True,
-    needs_matrix_puppeting=True,
-    help_section=SECTION_AUTH,
-    help_text="Replace your Telegram account's Matrix puppet with your own Matrix account.",
-)
-async def login_matrix(evt: CommandEvent) -> EventID:
-    puppet = await pu.Puppet.get_by_tgid(evt.sender.tgid)
+@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]:
+    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.")
+    await puppet.switch_mxid(None, None)
+    return await evt.reply("Reverted your Telegram account's Matrix puppet back to the default.")
+
+
+@command_handler(needs_auth=True, management_only=True, needs_matrix_puppeting=True,
+                 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]:
+    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."
-        )
+        return await evt.reply("You have already logged in with your Matrix account. "
+                               "Log out with `$cmdprefix+sp logout-matrix` first.")
    allow_matrix_login = evt.config.get("bridge.allow_matrix_login", True)
    if allow_matrix_login:
        evt.sender.command_status = {
@@ -51,35 +58,44 @@ async def login_matrix(evt: CommandEvent) -> EventID:
                "here.\n"
                f"If you would like to log in outside of Matrix, [click here]({url}).\n\n"
                "Logging in outside of Matrix is recommended, because in-Matrix login would save "
-                "your access token in the message history."
-            )
-        return await evt.reply(
-            "This bridge instance does not allow logging in inside Matrix.\n\n"
-            f"Please visit [the login page]({url}) to log in."
-        )
+                "your access token in the message history.")
+        return await evt.reply("This bridge instance does not allow logging in inside Matrix.\n\n"
+                               f"Please visit [the login page]({url}) to log in.")
    elif allow_matrix_login:
        return await evt.reply(
            "This bridge instance does not allow you to log in outside of Matrix.\n\n"
-            "Please send your Matrix access token here to log in."
-        )
+            "Please send your Matrix access token here to log in.")
    return await evt.reply("This bridge instance has been configured to not allow logging in.")


-async def enter_matrix_token(evt: CommandEvent) -> EventID:
+@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]:
+    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:
+        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}.")
+
+
+async def enter_matrix_token(evt: CommandEvent) -> Dict:
    evt.sender.command_status = None

-    puppet = await pu.Puppet.get_by_tgid(evt.sender.tgid)
+    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."
-        )
-    try:
-        await puppet.switch_mxid(" ".join(evt.args), evt.sender.mxid)
-    except OnlyLoginSelf:
+        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:
        return await evt.reply("You can only log in as your own Matrix user.")
-    except InvalidAccessToken:
+    elif resp == pu.PuppetError.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}."
-    )
+        f"Replaced your Telegram account's Matrix puppet with {puppet.custom_mxid}.")
@@ -0,0 +1,72 @@
+# -*- coding: future_fstrings -*-
+# 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))
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,22 +14,42 @@
 #
 # 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.types import EventID
+from mautrix_appservice import MatrixRequestError

 from ... import portal as po, puppet as pu, user as u
-from .. import SECTION_ADMIN, CommandEvent, command_handler
+from .. import command_handler, CommandEvent, SECTION_ADMIN


-@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) -> EventID:
+@command_handler(needs_admin=True, needs_auth=False, name="set-pl",
+                 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:
+    try:
+        level = int(evt.args[0])
+    except KeyError:
+        return await evt.reply("**Usage:** `$cmdprefix+sp set-pl <level> [mxid]`")
+    except ValueError:
+        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
+    try:
+        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:
    try:
        section = evt.args[0].lower()
    except IndexError:
@@ -38,40 +59,43 @@ async def clear_db_cache(evt: CommandEvent) -> EventID:
        po.Portal.by_mxid = {}
        await evt.reply("Cleared portal cache")
    elif section == "puppet":
-        pu.Puppet.by_tgid = {}
+        pu.Puppet.cache = {}
+        for puppet in pu.Puppet.by_custom_mxid.values():
+            puppet.sync_task.cancel()
        pu.Puppet.by_custom_mxid = {}
        await asyncio.gather(
-            *[puppet.try_start() async for puppet in pu.Puppet.all_with_custom_mxid()]
-        )
+            *[puppet.init_custom_mxid() 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 = {user.mxid: user for user in u.User.by_tgid.values()}
+        u.User.by_mxid = {
+            user.mxid: user
+            for user in u.User.by_tgid.values()
+        }
        await evt.reply("Cleared non-logged-in user cache")
    else:
        return await evt.reply("**Usage:** `$cmdprefix+sp clear-db-cache <section>`")


-@command_handler(
-    needs_admin=True,
-    needs_auth=False,
-    help_section=SECTION_ADMIN,
-    help_args="[_mxid_]",
-    help_text="Reload and reconnect a user",
-)
-async def reload_user(evt: CommandEvent) -> EventID:
+@command_handler(needs_admin=True, needs_auth=False,
+                 help_section=SECTION_ADMIN,
+                 help_args="[_mxid_]",
+                 help_text="Reload and reconnect a user")
+async def reload_user(evt: CommandEvent) -> Dict:
    if len(evt.args) > 0:
        mxid = evt.args[0]
    else:
        mxid = evt.sender.mxid
-    user = await u.User.get_by_mxid(mxid, create=False)
+    user = u.User.get_by_mxid(mxid, create=False)
    if not user:
        return await evt.reply("User not found")
-    puppet = await pu.Puppet.get_by_custom_mxid(mxid)
+    puppet = pu.Puppet.get_by_custom_mxid(mxid)
+    if puppet:
+        puppet.sync_task.cancel()
    await user.stop()
-    del u.User.by_tgid[user.tgid]
-    del u.User.by_mxid[user.mxid]
-    user = await u.User.get_by_mxid(mxid)
+    user.delete(delete_db=False)
+    user = u.User.get_by_mxid(mxid)
    await user.ensure_started()
    if puppet:
-        await puppet.start()
-    return await evt.reply(f"Reloaded and reconnected {user.mxid} (telegram: {user.human_tg_id})")
+        await puppet.init_custom_mxid()
+    await evt.reply(f"Reloaded and reconnected {user.mxid} (telegram: {user.human_tg_id})")
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,249 +14,174 @@
 #
 # 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 __future__ import annotations
-
-from typing import Awaitable
+from typing import Dict, Optional, Tuple, Coroutine
 import asyncio

-from telethon.tl.types import ChannelForbidden, ChatForbidden
-
-from mautrix.types import EventID, RoomID
-from mautrix.util import background_task
+from telethon.tl.types import ChatForbidden, ChannelForbidden

+from ...types import MatrixRoomID, TelegramID
+from ...util import ignore_coro
 from ... import portal as po
-from ...types import TelegramID
-from .. import SECTION_CREATING_PORTALS, CommandEvent, command_handler
-from .util import get_initial_state, user_has_power_level, warn_missing_power
+from .. import command_handler, CommandEvent, SECTION_CREATING_PORTALS
+from .util import user_has_power_level, get_initial_state


-@command_handler(
-    needs_auth=False,
-    needs_puppeting=False,
-    help_section=SECTION_CREATING_PORTALS,
-    help_args="[_id_]",
-    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) -> EventID:
+@command_handler(needs_auth=False, needs_puppeting=False,
+                 help_section=SECTION_CREATING_PORTALS,
+                 help_args="[_id_]",
+                 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:
    if len(evt.args) == 0:
-        return await evt.reply(
-            "**Usage:** `$cmdprefix+sp bridge <Telegram chat ID> [Matrix room ID]`"
-        )
+        return await evt.reply("**Usage:** "
+                               "`$cmdprefix+sp bridge <Telegram chat ID> [Matrix room ID]`")
    force_use_bot = False
    if evt.args[0] == "--usebot" and evt.sender.is_admin:
        force_use_bot = True
        evt.args = evt.args[1:]
-    room_id = RoomID(evt.args[1]) if len(evt.args) > 1 else evt.room_id
+    room_id = MatrixRoomID(evt.args[1]) if len(evt.args) > 1 else evt.room_id
    that_this = "This" if room_id == evt.room_id else "That"

-    portal = await po.Portal.get_by_mxid(room_id)
+    portal = po.Portal.get_by_mxid(room_id)
    if portal:
        return await evt.reply(f"{that_this} room is already a portal room.")

    if not await user_has_power_level(room_id, evt.az.intent, evt.sender, "bridge"):
-        return await evt.reply(
-            f"You do not have the permissions to bridge {that_this.lower()} room."
-        )
+        return await evt.reply(f"You do not have the permissions to bridge {that_this} room.")

    # The /id bot command provides the prefixed ID, so we assume
    tgid_str = evt.args[0]
-    tgid = None
-    try:
-        if tgid_str.startswith("-100"):
-            tgid = TelegramID(int(tgid_str[4:]))
-            peer_type = "channel"
-        elif tgid_str.startswith("-"):
-            tgid = TelegramID(-int(tgid_str))
-            peer_type = "chat"
-    except ValueError:
-        # Invalid integer
-        pass
-    if not tgid:
-        return await evt.reply(
-            "That doesn't seem like a prefixed Telegram chat ID.\n\n"
-            "If you did not get the ID using the `/id` bot command, please prefix"
-            "channel/supergroup IDs with `-100` and non-super group IDs with `-`.\n\n"
-            "Bridging private chats to existing rooms is not allowed."
-        )
+    if tgid_str.startswith("-100"):
+        tgid = TelegramID(int(tgid_str[4:]))
+        peer_type = "channel"
+    elif tgid_str.startswith("-"):
+        tgid = TelegramID(-int(tgid_str))
+        peer_type = "chat"
+    else:
+        return await evt.reply("That doesn't seem like a prefixed Telegram chat ID.\n\n"
+                               "If you did not get the ID using the `/id` bot command, please "
+                               "prefix channel IDs with `-100` and normal group IDs with `-`.\n\n"
+                               "Bridging private chats to existing rooms is not allowed.")

-    portal = await po.Portal.get_by_tgid(tgid, peer_type=peer_type)
-    if not portal.allow_bridging:
-        return await evt.reply(
-            "This bridge doesn't allow bridging that Telegram chat.\n"
-            "If you're the bridge admin, try "
-            "`$cmdprefix+sp filter whitelist <Telegram chat ID>` first."
-        )
-    elif portal.mxid:
+    portal = po.Portal.get_by_tgid(tgid, peer_type=peer_type)
+    if not portal.allow_bridging():
+        return await evt.reply("This bridge doesn't allow bridging that Telegram chat.\n"
+                               "If you're the bridge admin, try "
+                               "`$cmdprefix+sp filter whitelist <Telegram chat ID>` first.")
+    if portal.mxid:
        has_portal_message = (
            "That Telegram chat already has a portal at "
-            f"[{portal.alias or portal.mxid}](https://matrix.to/#/{portal.mxid}). "
-        )
+            f"[{portal.alias or portal.mxid}](https://matrix.to/#/{portal.mxid}). ")
        if not await user_has_power_level(portal.mxid, evt.az.intent, evt.sender, "unbridge"):
-            return await evt.reply(
-                f"{has_portal_message}"
-                "Additionally, you do not have the permissions to unbridge that room."
-            )
+            return await evt.reply(f"{has_portal_message}"
+                                   "Additionally, you do not have the permissions to unbridge "
+                                   "that room.")
        evt.sender.command_status = {
            "next": confirm_bridge,
            "action": "Room bridging",
            "mxid": portal.mxid,
            "bridge_to_mxid": room_id,
            "tgid": portal.tgid,
-            "peer_type": peer_type,
+            "peer_type": portal.peer_type,
            "force_use_bot": force_use_bot,
        }
-        return await evt.reply(
-            f"{has_portal_message}"
-            "However, you have the permissions to unbridge that room.\n\n"
-            "To delete that portal completely and continue bridging, use "
-            "`$cmdprefix+sp delete-and-continue`. To unbridge the portal "
-            "without kicking Matrix users, use `$cmdprefix+sp unbridge-and-"
-            "continue`. To cancel, use `$cmdprefix+sp cancel`"
-        )
+        return await evt.reply(f"{has_portal_message}"
+                               "However, you have the permissions to unbridge that room.\n\n"
+                               "To delete that portal completely and continue bridging, use "
+                               "`$cmdprefix+sp delete-and-continue`. To unbridge the portal "
+                               "without kicking Matrix users, use `$cmdprefix+sp unbridge-and-"
+                               "continue`. To cancel, use `$cmdprefix+sp cancel`")
    evt.sender.command_status = {
        "next": confirm_bridge,
        "action": "Room bridging",
        "bridge_to_mxid": room_id,
        "tgid": portal.tgid,
-        "peer_type": peer_type,
+        "peer_type": portal.peer_type,
        "force_use_bot": force_use_bot,
    }
-    return await evt.reply(
-        "That Telegram chat has no existing portal. To confirm bridging the "
-        "chat to this room, use `$cmdprefix+sp continue`"
-    )
+    return await evt.reply("That Telegram chat has no existing portal. To confirm bridging the "
+                           "chat to this room, use `$cmdprefix+sp continue`")


-async def cleanup_old_portal_while_bridging(
-    evt: CommandEvent, portal: po.Portal
-) -> tuple[bool, Awaitable[None] | None]:
+async def cleanup_old_portal_while_bridging(evt: CommandEvent, portal: "po.Portal"
+                                            ) -> 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"
-            "Continuing without touching previous Matrix room..."
-        )
+        await evt.reply("The portal seems to have lost its Matrix room between you"
+                        "calling `$cmdprefix+sp bridge` and this command.\n\n"
+                        "Continuing without touching previous Matrix room...")
        return True, None
    elif evt.args[0] == "delete-and-continue":
-        return True, portal.cleanup_portal("Portal deleted (moving to another room)", delete=False)
+        return True, portal.cleanup_room(portal.main_intent, portal.mxid,
+                                         message="Portal deleted (moving to another room)")
    elif evt.args[0] == "unbridge-and-continue":
-        return True, portal.cleanup_portal(
-            "Room unbridged (portal moving to another room)", puppets_only=True, delete=False
-        )
+        return True, portal.cleanup_room(portal.main_intent, portal.mxid,
+                                         message="Room unbridged (portal moving to another room)",
+                                         puppets_only=True)
    else:
        await evt.reply(
            "The chat you were trying to bridge already has a Matrix portal room.\n\n"
            "Please use `$cmdprefix+sp delete-and-continue` or `$cmdprefix+sp unbridge-and-"
            "continue` to either delete or unbridge the existing room (respectively) and "
            "continue with the bridging.\n\n"
-            "If you changed your mind, use `$cmdprefix+sp cancel` to cancel."
-        )
+            "If you changed your mind, use `$cmdprefix+sp cancel` to cancel.")
        return False, None


-async def confirm_bridge(evt: CommandEvent) -> EventID | None:
+async def confirm_bridge(evt: CommandEvent) -> Optional[Dict]:
    status = evt.sender.command_status
    try:
-        portal = await po.Portal.get_by_tgid(status["tgid"], peer_type=status["peer_type"])
+        portal = po.Portal.get_by_tgid(status["tgid"], peer_type=status["peer_type"])
        bridge_to_mxid = status["bridge_to_mxid"]
    except KeyError:
        evt.sender.command_status = None
-        return await evt.reply(
-            "Fatal error: tgid or peer_type missing from command_status. "
-            "This shouldn't happen unless you're messing with the command handler code."
-        )
-
-    is_logged_in = await evt.sender.is_logged_in() and not status["force_use_bot"]
-
+        return await evt.reply("Fatal error: tgid or peer_type missing from command_status. "
+                               "This shouldn't happen unless you're messing with the command "
+                               "handler code.")
    if "mxid" in status:
-        if portal.peer_type != status["peer_type"]:
-            evt.log.warning(
-                "Portal %d in database has mismatching peer type %s (expected %s),"
-                " trusting database as a room already existed",
-                portal.tgid,
-                portal.peer_type,
-                status["peer_type"],
-            )
-            await evt.reply(
-                "Mismatching peer type in command and portal table, "
-                "trusting portal as room already existed"
-            )
        ok, coro = await cleanup_old_portal_while_bridging(evt, portal)
        if not ok:
            return None
        elif coro:
-            background_task.create(coro)
+            ignore_coro(asyncio.ensure_future(coro, loop=evt.loop))
            await evt.reply("Cleaning up previous portal room...")
    elif portal.mxid:
        evt.sender.command_status = None
-        return await evt.reply(
-            "The portal seems to have created a Matrix room between you "
-            "calling `$cmdprefix+sp bridge` and this command.\n\n"
-            "Please start over by calling the bridge command again."
-        )
+        return await evt.reply("The portal seems to have created a Matrix room between you "
+                               "calling `$cmdprefix+sp bridge` and this command.\n\n"
+                               "Please start over by calling the bridge command again.")
    elif evt.args[0] != "continue":
-        return await evt.reply(
-            "Please use `$cmdprefix+sp continue` to confirm the bridging or "
-            "`$cmdprefix+sp cancel` to cancel."
-        )
-    elif portal.peer_type != status["peer_type"]:
-        evt.log.warning(
-            "Portal %d in database has mismatching peer type %s (expected %s),"
-            " trusting new peer type as there's no existing room",
-            portal.tgid,
-            portal.peer_type,
-            status["peer_type"],
-        )
-        await evt.reply(
-            "Mismatching peer type in command and portal table, "
-            "trusting you as portal room doesn't exist"
-        )
-        portal.peer_type = status["peer_type"]
+        return await evt.reply("Please use `$cmdprefix+sp continue` to confirm the bridging or "
+                               "`$cmdprefix+sp cancel` to cancel.")

    evt.sender.command_status = None
-    async with portal._room_create_lock:
-        await _locked_confirm_bridge(
-            evt, portal=portal, room_id=bridge_to_mxid, is_logged_in=is_logged_in
-        )
-
-
-async def _locked_confirm_bridge(
-    evt: CommandEvent, portal: po.Portal, room_id: RoomID, is_logged_in: bool
-) -> EventID | None:
+    is_logged_in = await evt.sender.is_logged_in() and not status["force_use_bot"]
    user = evt.sender if is_logged_in else evt.tgbot
    try:
        entity = await user.client.get_entity(portal.peer)
    except Exception:
        evt.log.exception("Failed to get_entity(%s) for manual bridging.", portal.peer)
        if is_logged_in:
-            return await evt.reply(
-                "Failed to get info of telegram chat. You are logged in, are you in that chat?"
-            )
+            return await evt.reply("Failed to get info of telegram chat. "
+                                   "You are logged in, are you in that chat?")
        else:
-            return await evt.reply(
-                "Failed to get info of telegram chat. "
-                "You're not logged in, is the relay bot in the chat?"
-            )
+            return await evt.reply("Failed to get info of telegram chat. "
+                                   "You're not logged in, is the relay bot in the chat?")
    if isinstance(entity, (ChatForbidden, ChannelForbidden)):
        if is_logged_in:
            return await evt.reply("You don't seem to be in that chat.")
        else:
            return await evt.reply("The bot doesn't seem to be in that chat.")

-    portal.mxid = room_id
-    portal.by_mxid[portal.mxid] = portal
-    (portal.title, portal.about, levels, portal.encrypted) = await get_initial_state(
-        evt.az.intent, evt.room_id
-    )
+    direct = False
+
+    portal.mxid = bridge_to_mxid
+    portal.title, portal.about, levels = await get_initial_state(evt.az.intent, evt.room_id)
    portal.photo_id = ""
-    await portal.save()
-    await portal.update_bridge_info()
+    portal.save()

-    background_task.create(portal.update_matrix_room(user, entity, levels=levels))
-
-    await warn_missing_power(levels, evt)
+    ignore_coro(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.")
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,27 +14,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 __future__ import annotations
-
-from typing import Any, Awaitable
+from typing import Dict, Awaitable
 from io import StringIO

-from ruamel.yaml import YAMLError
-
-from mautrix.types import EventID
-from mautrix.util.config import yaml
-
+from ...config import yaml
 from ... import portal as po, util
-from .. import SECTION_PORTAL_MANAGEMENT, CommandEvent, command_handler
+from .. import command_handler, CommandEvent, SECTION_PORTAL_MANAGEMENT


-@command_handler(
-    needs_auth=False,
-    needs_puppeting=False,
-    help_section=SECTION_PORTAL_MANAGEMENT,
-    help_text="View or change per-portal settings.",
-    help_args="<`help`|_subcommand_> [...]",
-)
+@command_handler(help_section=SECTION_PORTAL_MANAGEMENT,
+                 help_text="View or change per-portal settings.",
+                 help_args="<`help`|_subcommand_> [...]")
 async def config(evt: CommandEvent) -> None:
    cmd = evt.args[0].lower() if len(evt.args) > 0 else "help"
    if cmd not in ("view", "defaults", "set", "unset", "add", "del"):
@@ -43,7 +34,7 @@ async def config(evt: CommandEvent) -> None:
        await config_defaults(evt)
        return

-    portal = await po.Portal.get_by_mxid(evt.room_id)
+    portal = po.Portal.get_by_mxid(evt.room_id)
    if not portal:
        await evt.reply("This is not a portal room.")
        return
@@ -51,16 +42,8 @@ async def config(evt: CommandEvent) -> None:
        await config_view(evt, portal)
        return

-    if not await portal.can_user_perform(evt.sender, "config"):
-        await evt.reply("You do not have the permissions to configure this room.")
-        return
-
    key = evt.args[1] if len(evt.args) > 1 else None
-    try:
-        value = yaml.load(" ".join(evt.args[2:])) if len(evt.args) > 2 else None
-    except YAMLError as e:
-        await evt.reply(f"Invalid value provided. Values must be valid YAML.\n{e}")
-        return
+    value = yaml.load(" ".join(evt.args[2:])) if len(evt.args) > 2 else None
    if cmd == "set":
        await config_set(evt, portal, key, value)
    elif cmd == "unset":
@@ -69,12 +52,11 @@ async def config(evt: CommandEvent) -> None:
        await config_add_del(evt, portal, key, value, cmd)
    else:
        return
-    await portal.save()
+    portal.save()


-def config_help(evt: CommandEvent) -> Awaitable[EventID]:
-    return evt.reply(
-        """**Usage:** `$cmdprefix config <subcommand> [...]`. Subcommands:
+def config_help(evt: CommandEvent) -> Awaitable[Dict]:
+    return evt.reply("""**Usage:** `$cmdprefix config <subcommand> [...]`. Subcommands:

 * **help** - View this help text.
 * **view** - View the current config data.
@@ -83,52 +65,42 @@ def config_help(evt: CommandEvent) -> Awaitable[EventID]:
 * **unset** <_key_> - Remove a config value.
 * **add** <_key_> <_value_> - Add a value to an array.
 * **del** <_key_> <_value_> - Remove a value from an array.
-"""
-    )
+""")


-def config_view(evt: CommandEvent, portal: po.Portal) -> Awaitable[EventID]:
-    return evt.reply(f"Room-specific config:\n{_str_value(portal.local_config).rstrip()}")
-
-
-def config_defaults(evt: CommandEvent) -> Awaitable[EventID]:
-    value = _str_value(
-        {
-            "bridge_notices": {
-                "default": evt.config["bridge.bridge_notices.default"],
-                "exceptions": evt.config["bridge.bridge_notices.exceptions"],
-            },
-            "bot_messages_as_notices": evt.config["bridge.bot_messages_as_notices"],
-            "caption_in_message": evt.config["bridge.caption_in_message"],
-            "message_formats": evt.config["bridge.message_formats"],
-            "emote_format": evt.config["bridge.emote_format"],
-            "state_event_formats": evt.config["bridge.state_event_formats"],
-            "telegram_link_preview": evt.config["bridge.telegram_link_preview"],
-        }
-    )
-    return evt.reply(f"Bridge instance wide config:\n{value.rstrip()}")
-
-
-def _str_value(value: Any) -> str:
+def config_view(evt: CommandEvent, portal: po.Portal) -> Awaitable[Dict]:
    stream = StringIO()
-    yaml.dump(value, stream)
-    value_str = stream.getvalue()
-    if "\n" in value_str:
-        return f"\n```yaml\n{value_str}\n```\n"
-    else:
-        return f"`{value_str}`"
+    yaml.dump(portal.local_config, stream)
+    return evt.reply(f"Room-specific config:\n\n```yaml\n{stream.getvalue()}```")


-def config_set(evt: CommandEvent, portal: po.Portal, key: str, value: Any) -> Awaitable[EventID]:
+def config_defaults(evt: CommandEvent) -> Awaitable[Dict]:
+    stream = StringIO()
+    yaml.dump({
+        "bridge_notices": {
+            "default": evt.config["bridge.bridge_notices.default"],
+            "exceptions": evt.config["bridge.bridge_notices.exceptions"],
+        },
+        "bot_messages_as_notices": evt.config["bridge.bot_messages_as_notices"],
+        "inline_images": evt.config["bridge.inline_images"],
+        "message_formats": evt.config["bridge.message_formats"],
+        "state_event_formats": evt.config["bridge.state_event_formats"],
+        "telegram_link_preview": evt.config["bridge.telegram_link_preview"],
+    }, stream)
+    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]:
    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):
-        return evt.reply(f"Successfully set the value of `{key}` to {_str_value(value)}".rstrip())
+        return evt.reply(f"Successfully set the value of `{key}` to `{value}`.")
    else:
-        return evt.reply(f"Failed to set value of `{key}`. Does the path contain non-map types?")
+        return evt.reply(f"Failed to set value of `{key}`. "
+                         "Does the path contain non-map types?")


-def config_unset(evt: CommandEvent, portal: po.Portal, key: str) -> Awaitable[EventID]:
+def config_unset(evt: CommandEvent, portal: po.Portal, key: str) -> Awaitable[Dict]:
    if not key:
        return evt.reply(f"**Usage:** `$cmdprefix+sp config unset <key>`")
    elif util.recursive_del(portal.local_config, key):
@@ -137,26 +109,24 @@ def config_unset(evt: CommandEvent, portal: po.Portal, key: str) -> Awaitable[Ev
        return evt.reply(f"`{key}` not found in config.")


-def config_add_del(
-    evt: CommandEvent, portal: po.Portal, key: str, value: str, cmd: str
-) -> Awaitable[EventID]:
+def config_add_del(evt: CommandEvent, portal: po.Portal, key: str, value: str, cmd: str
+                   ) -> Awaitable[Dict]:
    if not key or value is None:
        return evt.reply(f"**Usage:** `$cmdprefix+sp config {cmd} <key> <value>`")

    arr = util.recursive_get(portal.local_config, key)
    if not arr:
-        return evt.reply(
-            f"`{key}` not found in config. Maybe do `$cmdprefix+sp config set {key} []` first?"
-        )
+        return evt.reply(f"`{key}` not found in config. "
+                         f"Maybe do `$cmdprefix+sp config set {key} []` first?")
    elif not isinstance(arr, list):
        return evt.reply("`{key}` does not seem to be an array.")
    elif cmd == "add":
        if value in arr:
-            return evt.reply(f"The array at `{key}` already contains {_str_value(value)}".rstrip())
+            return evt.reply(f"The array at `{key}` already contains `{value}`.")
        arr.append(value)
-        return evt.reply(f"Successfully added {_str_value(value)} to the array at `{key}`")
+        return evt.reply(f"Successfully added `{value}` to the array at `{key}`")
    else:
        if value not in arr:
-            return evt.reply(f"The array at `{key}` does not contain {_str_value(value)}")
+            return evt.reply(f"The array at `{key}` does not contain `{value}`.")
        arr.remove(value)
-        return evt.reply(f"Successfully removed {_str_value(value)} from the array at `{key}`")
+        return evt.reply(f"Successfully removed `{value}` from the array at `{key}`")
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,38 +14,32 @@
 #
 # 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 __future__ import annotations
-
-from mautrix.types import EventID
+from typing import Dict

 from ... import portal as po
 from ...types import TelegramID
-from .. import SECTION_CREATING_PORTALS, CommandEvent, command_handler
-from .util import get_initial_state, user_has_power_level, warn_missing_power
+from .. import command_handler, CommandEvent, SECTION_CREATING_PORTALS
+from .util import user_has_power_level, get_initial_state


-@command_handler(
-    help_section=SECTION_CREATING_PORTALS,
-    help_args="[_type_]",
-    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 `supergroup`)."
-    ),
-)
-async def create(evt: CommandEvent) -> EventID:
-    type = evt.args[0] if len(evt.args) > 0 else "supergroup"
-    if type not in ("chat", "group", "supergroup", "channel"):
+@command_handler(help_section=SECTION_CREATING_PORTALS,
+                 help_args="[_type_]",
+                 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:
+    type = evt.args[0] if len(evt.args) > 0 else "group"
+    if type not in {"chat", "group", "supergroup", "channel"}:
        return await evt.reply(
-            "**Usage:** `$cmdprefix+sp create ['group'/'supergroup'/'channel']`"
-        )
+            "**Usage:** `$cmdprefix+sp create ['group'/'supergroup'/'channel']`")

-    if await po.Portal.get_by_mxid(evt.room_id):
+    if po.Portal.get_by_mxid(evt.room_id):
        return await evt.reply("This is already a portal room.")

    if not await user_has_power_level(evt.room_id, evt.az.intent, evt.sender, "bridge"):
        return await evt.reply("You do not have the permissions to bridge this room.")

-    title, about, levels, encrypted = await get_initial_state(evt.az.intent, evt.room_id)
+    title, about, levels = await get_initial_state(evt.az.intent, evt.room_id)
    if not title:
        return await evt.reply("Please set a title before creating a Telegram chat.")

@@ -56,20 +51,11 @@ async def create(evt: CommandEvent) -> EventID:
        "group": "chat",
    }[type]

-    portal = po.Portal(
-        tgid=TelegramID(0),
-        tg_receiver=TelegramID(0),
-        peer_type=type,
-        mxid=evt.room_id,
-        title=title,
-        about=about,
-        encrypted=encrypted,
-    )
-
-    await warn_missing_power(levels, evt)
-
+    portal = po.Portal(tgid=TelegramID(0), peer_type=type,
+                       mxid=evt.room_id, title=title, about=about)
    try:
        await portal.create_telegram_chat(evt.sender, supergroup=supergroup)
    except ValueError as e:
-        await portal.delete()
+        portal.delete()
        return await evt.reply(e.args[0])
+    return await evt.reply(f"Telegram chat created. ID: {portal.tgid}")
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,21 +14,18 @@
 #
 # 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 __future__ import annotations
-
-from mautrix.types import EventID
+from typing import Dict, Optional

 from ... import portal as po
-from .. import SECTION_ADMIN, CommandEvent, command_handler
+from .. import command_handler, CommandEvent, SECTION_ADMIN


-@command_handler(
-    needs_admin=True,
-    help_section=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) -> EventID:
+@command_handler(needs_admin=True,
+                 help_section=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:
    try:
        mode = evt.args[0]
        if mode not in ("whitelist", "blacklist"):
@@ -39,27 +37,20 @@ async def filter_mode(evt: CommandEvent) -> EventID:
    evt.config.save()
    po.Portal.filter_mode = mode
    if mode == "whitelist":
-        return await evt.reply(
-            "The bridge will now disallow bridging chats by default.\n"
-            "To allow bridging a specific chat, use"
-            "`!filter whitelist <chat ID>`."
-        )
+        return await evt.reply("The bridge will now disallow bridging chats by default.\n"
+                               "To allow bridging a specific chat, use"
+                               "`!filter whitelist <chat ID>`.")
    else:
-        return await evt.reply(
-            "The bridge will now allow bridging chats by default.\n"
-            "To disallow bridging a specific chat, use"
-            "`!filter blacklist <chat ID>`."
-        )
+        return await evt.reply("The bridge will now allow bridging chats by default.\n"
+                               "To disallow bridging a specific chat, use"
+                               "`!filter blacklist <chat ID>`.")


-@command_handler(
-    name="filter",
-    needs_admin=True,
-    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) -> EventID:
+@command_handler(name="filter", needs_admin=True,
+                 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]:
    try:
        action = evt.args[0]
        if action not in ("whitelist", "blacklist", "add", "remove"):
@@ -77,7 +68,7 @@ async def edit_filter(evt: CommandEvent) -> EventID:

    mode = evt.config["bridge.filter.mode"]
    if mode not in ("blacklist", "whitelist"):
-        return await evt.reply(f'Unknown filter mode "{mode}". Please fix the bridge config.')
+        return await evt.reply(f"Unknown filter mode \"{mode}\". Please fix the bridge config.")

    filter_id_list = evt.config["bridge.filter.list"]

@@ -101,5 +92,4 @@ async def edit_filter(evt: CommandEvent) -> EventID:
        filter_id_list.remove(filter_id)
        save()
        return await evt.reply(f"Chat ID removed from {mode}.")
-    else:
-        return await evt.reply("**Usage:** `$cmdprefix+sp filter <whitelist/blacklist> <chat ID>`")
+    return None
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,93 +14,35 @@
 #
 # 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 __future__ import annotations
+from typing import Dict

-from datetime import datetime, timedelta
-import re
+from telethon.errors import (ChatAdminRequiredError, UsernameInvalidError,
+                             UsernameNotModifiedError, UsernameOccupiedError)

-from telethon.errors import (
-    ChatAdminRequiredError,
-    RPCError,
-    UsernameInvalidError,
-    UsernameNotModifiedError,
-    UsernameOccupiedError,
-)
-from telethon.helpers import add_surrogate
-from telethon.tl.functions.channels import GetFullChannelRequest
-from telethon.tl.functions.messages import GetExportedChatInvitesRequest, GetFullChatRequest
-from telethon.tl.types import (
-    ChatInviteExported,
-    InputMessageEntityMentionName,
-    InputUserSelf,
-    MessageEntityMention,
-    TypeInputPeer,
-    TypeInputUser,
-)
-from telethon.tl.types.messages import ExportedChatInvites
-
-from mautrix.types import EventID
-
-from ... import formatter as fmt, portal as po, puppet as pu
-from .. import SECTION_MISC, SECTION_PORTAL_MANAGEMENT, CommandEvent, command_handler
+from ... import portal as po
+from .. import command_handler, CommandEvent, SECTION_PORTAL_MANAGEMENT, SECTION_MISC
 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) -> EventID:
-    portal = await po.Portal.get_by_mxid(evt.room_id)
+@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:
+    portal = po.Portal.get_by_mxid(evt.room_id)
    if not portal:
        return await evt.reply("This is not a portal room.")
    elif not await user_has_power_level(evt.room_id, evt.az.intent, evt.sender, "bridge"):
        return await evt.reply(f"You do not have the permissions to synchronize this room.")

-    await portal.main_intent.get_joined_members(portal.mxid)
+    await portal.sync_matrix_members()
    await evt.reply("Synchronization complete")


-@command_handler(
-    needs_admin=False, needs_puppeting=False, needs_auth=False, help_section=SECTION_MISC
-)
-async def sync_full(evt: CommandEvent) -> EventID:
-    portal = await po.Portal.get_by_mxid(evt.room_id)
-    if not portal:
-        return await evt.reply("This is not a portal room.")
-
-    if len(evt.args) > 0 and evt.args[0] == "--usebot" and evt.sender.is_admin:
-        src = evt.tgbot
-    else:
-        src = evt.tgbot if await evt.sender.needs_relaybot(portal) else evt.sender
-
-    try:
-        if portal.peer_type == "channel":
-            res = await src.client(GetFullChannelRequest(portal.peer))
-        elif portal.peer_type == "chat":
-            res = await src.client(GetFullChatRequest(portal.tgid))
-        else:
-            return await evt.reply("This is not a channel or chat portal.")
-    except (ValueError, RPCError):
-        return await evt.reply("Failed to get portal info from Telegram.")
-
-    await portal.update_matrix_room(src, res.full_chat)
-    return await evt.reply("Portal synced successfully.")
-
-
-@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) -> EventID:
-    portal = await po.Portal.get_by_mxid(evt.room_id)
+@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:
+    portal = po.Portal.get_by_mxid(evt.room_id)
    if not portal:
        return await evt.reply("This is not a portal room.")
    tgid = portal.tgid
@@ -110,189 +53,29 @@ async def get_id(evt: CommandEvent) -> EventID:
    await evt.reply(f"This room is bridged to Telegram chat ID `{tgid}`.")


-invite_link_usage = (
-    "**Usage:** `$cmdprefix+sp invite-link "
-    "[--uses=<amount>] [--expire=<delta>] [--request-needed] -- [title]`"
-    "\n\n"
-    "* `--uses`: the number of times the invite link can be used."
-    "            Defaults to unlimited.\n"
-    "* `--expire`: the duration after which the link will expire."
-    "              A number suffixed with d(ay), h(our), m(inute) or s(econd)\n"
-    "* `--request-needed`: should the link require admins to approve joins?\n"
-    "* `title`: a description of the link (only shown to admins)."
-)
-
-
-def _parse_flag(args: list[str]) -> tuple[str, str]:
-    arg = args.pop(0).lower()
-    if arg == "--":
-        return "", ""
-    value = ""
-    if arg.startswith("--"):
-        value_start = arg.find("=")
-        if value_start > 0:
-            flag = arg[2:value_start]
-            value = arg[value_start + 1 :]
-        else:
-            flag = arg[2:]
-            if arg not in ("request", "request-needed"):
-                value = args.pop(0).lower()
-    elif arg.startswith("-"):
-        flag = arg[1]
-        if len(arg) > 3 and arg[2] == "=":
-            value = arg[3:]
-        elif arg != "r":
-            value = args.pop(0).lower()
-    else:
-        raise ValueError("invalid flag")
-    return flag, value
-
-
-delta_regex = re.compile(
-    "([0-9]+)(w(?:eek)?|d(?:ay)?|h(?:our)?|m(?:in(?:ute)?)?|s(?:ec(?:ond)?)?)"
-)
-
-
-def _parse_delta(value: str) -> timedelta | None:
-    match = delta_regex.fullmatch(value)
-    if not match:
-        return None
-    number = int(match.group(1))
-    unit = match.group(2)[0]
-    if unit == "w":
-        return timedelta(weeks=number)
-    elif unit == "d":
-        return timedelta(days=number)
-    elif unit == "h":
-        return timedelta(hours=number)
-    elif unit == "m":
-        return timedelta(minutes=number)
-    elif unit == "s":
-        return timedelta(seconds=number)
-    else:
-        return None
-
-
-@command_handler(
-    help_section=SECTION_PORTAL_MANAGEMENT,
-    help_text="Get a Telegram invite link to the current chat.",
-    help_args="[--uses=<amount>] [--expire=<time delta, e.g. 1d>] [--request-needed] -- [title]",
-)
-async def invite_link(evt: CommandEvent) -> EventID:
-    if not evt.is_portal:
+@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:
+    portal = po.Portal.get_by_mxid(evt.room_id)
+    if not portal:
        return await evt.reply("This is not a portal room.")

-    # TODO once we switch to Python 3.9 minimum, use argparse with exit_on_error=False
-    uses = None
-    expire = None
-    request_needed = False
-    while evt.args:
-        try:
-            flag, value = _parse_flag(evt.args)
-        except (ValueError, IndexError):
-            return await evt.reply(invite_link_usage)
-        if not flag:
-            break
-        elif flag in ("uses", "u"):
-            try:
-                uses = int(value)
-            except ValueError:
-                await evt.reply("The number of uses must be an integer")
-        elif flag in ("expire", "e"):
-            expire_delta = _parse_delta(value)
-            if not expire_delta:
-                await evt.reply("Invalid format for expiry time delta")
-            expire = datetime.now() + expire_delta
-        elif flag in ("request", "request-needed", "r"):
-            request_needed = True
-    title = " ".join(evt.args)
-
-    if evt.portal.peer_type == "user":
+    if portal.peer_type == "user":
        return await evt.reply("You can't invite users to private chats.")

    try:
-        link = await evt.portal.get_invite_link(
-            evt.sender, uses=uses, expire=expire, request_needed=request_needed, title=title
-        )
-        return await evt.reply(f"Invite link to {evt.portal.title}: {link}")
+        link = await portal.get_invite_link(evt.sender)
+        return await evt.reply(f"Invite link to {portal.title}: {link}")
    except ValueError as e:
        return await evt.reply(e.args[0])
    except ChatAdminRequiredError:
        return await evt.reply("You don't have the permission to create an invite link.")


-async def _format_invite_link(link: ChatInviteExported) -> str:
-    desc = f"* {link.link}"
-    if link.title:
-        desc += f" - {link.title}"
-    if link.expire_date:
-        desc += f"  \n  Expires at {link.expire_date.isoformat()}"
-    if link.usage_limit:
-        desc += f"  \n  Used {link.usage or 0} out of {link.usage_limit} times"
-    elif link.usage:
-        desc += f"  \n  Used {link.usage} times"
-    else:
-        desc += "  \n  Never used"
-    if link.request_needed:
-        desc += "  \n  Join requests enabled - using link requires admin approval"
-    return desc
-
-
-async def _hacky_find_mention(evt: CommandEvent) -> TypeInputUser | TypeInputPeer | None:
-    if len(evt.args) == 0:
-        return None
-    text, entities = await fmt.matrix_to_telegram(
-        evt.sender.client, text=evt.content.body, html=evt.content.formatted_body
-    )
-    for entity in entities:
-        if isinstance(entity, MessageEntityMention):
-            admin_username = add_surrogate(text)[entity.offset + 1 : entity.offset + entity.length]
-            return await evt.sender.client.get_input_entity(admin_username)
-        elif isinstance(entity, InputMessageEntityMentionName):
-            return entity.user_id
-    return None
-
-
-@command_handler(
-    help_section=SECTION_PORTAL_MANAGEMENT,
-    help_text="List existing Telegram invite links to the current chat.",
-    help_args="[creator]",
-)
-async def list_invite_links(evt: CommandEvent) -> EventID:
-    admin_id = InputUserSelf()
-    try:
-        admin_id = await _hacky_find_mention(evt) or InputUserSelf()
-    except Exception:
-        pass
-    resp: ExportedChatInvites = await evt.sender.client(
-        GetExportedChatInvitesRequest(
-            peer=await evt.portal.get_input_entity(evt.sender),
-            admin_id=admin_id,
-            limit=100,
-        )
-    )
-    if resp.count == 0:
-        if isinstance(admin_id, InputUserSelf):
-            return await evt.reply("You haven't created any invite links to the current chat")
-        else:
-            return await evt.reply("That user hasn't created any invite links to the current chat")
-    formatted_links = "\n".join([await _format_invite_link(link) for link in resp.invites])
-    if isinstance(admin_id, InputUserSelf):
-        await evt.reply(f"Your links to this chat:\n\n{formatted_links}")
-    else:
-        puppet = await pu.Puppet.get_by_peer(admin_id)
-        await evt.reply(
-            f"[{puppet.displayname}](https://matrix.to/#/{puppet.mxid})'s links to this chat:\n\n"
-            f"{formatted_links}"
-        )
-
-
-@command_handler(
-    help_section=SECTION_PORTAL_MANAGEMENT,
-    help_text="Upgrade a normal Telegram group to a supergroup.",
-)
-async def upgrade(evt: CommandEvent) -> EventID:
-    portal = await po.Portal.get_by_mxid(evt.room_id)
+@command_handler(help_section=SECTION_PORTAL_MANAGEMENT,
+                 help_text="Upgrade a normal Telegram group to a supergroup.")
+async def upgrade(evt: CommandEvent) -> Dict:
+    portal = po.Portal.get_by_mxid(evt.room_id)
    if not portal:
        return await evt.reply("This is not a portal room.")
    elif portal.peer_type == "channel":
@@ -309,33 +92,30 @@ async def upgrade(evt: CommandEvent) -> EventID:
        return await evt.reply(e.args[0])


-@command_handler(
-    help_section=SECTION_PORTAL_MANAGEMENT,
-    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) -> EventID:
+@command_handler(help_section=SECTION_PORTAL_MANAGEMENT,
+                 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:
    if len(evt.args) == 0:
        return await evt.reply("**Usage:** `$cmdprefix+sp group-name <name/->`")

-    portal = await po.Portal.get_by_mxid(evt.room_id)
+    portal = po.Portal.get_by_mxid(evt.room_id)
    if not portal:
        return await evt.reply("This is not a portal room.")
    elif portal.peer_type != "channel":
        return await evt.reply("Only channels and supergroups have usernames.")

    try:
-        await portal.set_telegram_username(evt.sender, evt.args[0] if evt.args[0] != "-" else "")
+        await portal.set_telegram_username(evt.sender,
+                                           evt.args[0] if evt.args[0] != "-" else "")
        if portal.username:
            return await evt.reply(f"Username of channel changed to {portal.username}.")
        else:
            return await evt.reply(f"Channel is now private.")
    except ChatAdminRequiredError:
        return await evt.reply(
-            "You don't have the permission to set the username of this channel."
-        )
+            "You don't have the permission to set the username of this channel.")
    except UsernameNotModifiedError:
        if portal.username:
            return await evt.reply("That is already the username of this channel.")
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,42 +14,35 @@
 #
 # 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 __future__ import annotations
-
-from typing import Callable
-
-from mautrix.types import EventID, RoomID
+from typing import Dict, Callable, Optional

+from ...types import MatrixRoomID
 from ... import portal as po
-from .. import SECTION_PORTAL_MANAGEMENT, CommandEvent, command_handler
+from .. import command_handler, CommandEvent, SECTION_PORTAL_MANAGEMENT
 from .util import user_has_power_level


-async def _get_portal_and_check_permission(evt: CommandEvent) -> po.Portal | None:
-    room_id = RoomID(evt.args[0]) if len(evt.args) > 0 else evt.room_id
+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

-    portal = await po.Portal.get_by_mxid(room_id)
+    portal = po.Portal.get_by_mxid(room_id)
    if not portal:
        that_this = "This" if room_id == evt.room_id else "That"
        await evt.reply(f"{that_this} is not a portal room.")
        return None

-    if portal.peer_type == "user":
-        if portal.tg_receiver != evt.sender.tgid:
-            await evt.reply("You do not have the permissions to unbridge that portal.")
-            return None
-        return portal
-
-    if not await user_has_power_level(portal.mxid, evt.az.intent, evt.sender, "unbridge"):
-        await evt.reply("You do not have the permissions to unbridge that portal.")
+    if not await user_has_power_level(portal.mxid, evt.az.intent, evt.sender, permission):
+        action = action or f"{permission.replace('_', ' ')}s"
+        await evt.reply(f"You do not have the permissions to {action} that portal.")
        return None
    return portal


-def _get_portal_murder_function(
-    action: str, room_id: str, function: Callable, command: str, completed_message: str
-) -> dict:
-    async def post_confirm(confirm) -> EventID | None:
+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]:
        confirm.sender.command_status = None
        if len(confirm.args) > 0 and confirm.args[0] == f"confirm-{command}":
            await function()
@@ -64,55 +58,40 @@ def _get_portal_murder_function(
    }


-@command_handler(
-    needs_auth=False,
-    needs_puppeting=False,
-    help_section=SECTION_PORTAL_MANAGEMENT,
-    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) -> EventID | None:
-    portal = await _get_portal_and_check_permission(evt)
+@command_handler(needs_auth=False, needs_puppeting=False,
+                 help_section=SECTION_PORTAL_MANAGEMENT,
+                 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]:
+    portal = await _get_portal_and_check_permission(evt, "unbridge")
    if not portal:
        return None

-    evt.sender.command_status = _get_portal_murder_function(
-        "Portal deletion",
-        portal.mxid,
-        portal.cleanup_and_delete,
-        "delete",
-        "Portal successfully deleted.",
-    )
-    return await evt.reply(
-        "Please confirm deletion of portal "
-        f"[{portal.alias or portal.mxid}](https://matrix.to/#/{portal.mxid}) "
-        f'to Telegram chat "{portal.title}" '
-        "by typing `$cmdprefix+sp confirm-delete`"
-        "\n\n"
-        "**WARNING:** If the bridge bot has the power level to do so, **this "
-        "will kick ALL users** in the room. If you just want to remove the "
-        "bridge, use `$cmdprefix+sp unbridge` instead."
-    )
+    evt.sender.command_status = _get_portal_murder_function("Portal deletion", portal.mxid,
+                                                            portal.cleanup_and_delete, "delete",
+                                                            "Portal successfully deleted.")
+    return await evt.reply("Please confirm deletion of portal "
+                           f"[{portal.alias or portal.mxid}](https://matrix.to/#/{portal.mxid}) "
+                           f"to Telegram chat \"{portal.title}\" "
+                           "by typing `$cmdprefix+sp confirm-delete`"
+                           "\n\n"
+                           "**WARNING:** If the bridge bot has the power level to do so, **this "
+                           "will kick ALL users** in the room. If you just want to remove the "
+                           "bridge, use `$cmdprefix+sp unbridge` instead.")


-@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) -> EventID | None:
-    portal = await _get_portal_and_check_permission(evt)
+@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]:
+    portal = await _get_portal_and_check_permission(evt, "unbridge")
    if not portal:
        return None

-    evt.sender.command_status = _get_portal_murder_function(
-        "Room unbridging", portal.mxid, portal.unbridge, "unbridge", "Room successfully unbridged."
-    )
-    return await evt.reply(
-        f'Please confirm unbridging chat "{portal.title}" from room '
-        f"[{portal.alias or portal.mxid}](https://matrix.to/#/{portal.mxid}) "
-        "by typing `$cmdprefix+sp confirm-unbridge`"
-    )
+    evt.sender.command_status = _get_portal_murder_function("Room unbridging", portal.mxid,
+                                                            portal.unbridge, "unbridge",
+                                                            "Room successfully unbridged.")
+    return await evt.reply(f"Please confirm unbridging chat \"{portal.title}\" from room "
+                           f"[{portal.alias or portal.mxid}](https://matrix.to/#/{portal.mxid}) "
+                           "by typing `$cmdprefix+sp confirm-unbridge`")
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,60 +14,43 @@
 #
 # 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 __future__ import annotations
+from typing import Dict, Tuple

-from mautrix.appservice import IntentAPI
-from mautrix.errors import MatrixRequestError
-from mautrix.types import EventType, PowerLevelStateEventContent, RoomID
+from mautrix_appservice import MatrixRequestError, IntentAPI

 from ... import user as u
-from .. import CommandEvent


-async def get_initial_state(
-    intent: IntentAPI, room_id: RoomID
-) -> tuple[str | None, str | None, PowerLevelStateEventContent | None, bool]:
-    state = await intent.get_state(room_id)
-    title: str | None = None
-    about: str | None = None
-    levels: PowerLevelStateEventContent | None = None
-    encrypted: bool = False
+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
    for event in state:
        try:
-            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
-            elif event.type == EventType.ROOM_ENCRYPTION:
-                encrypted = True
+            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"]
        except KeyError:
            # Some state event probably has empty content
            pass
-    return title, about, levels, encrypted
+    return title, about, levels


-async def warn_missing_power(levels: PowerLevelStateEventContent, evt: CommandEvent) -> None:
-    if levels.get_user_level(evt.az.bot_mxid) < levels.redact:
-        await evt.reply(
-            "Warning: The bot does not have privileges to redact messages on Matrix. "
-            "Message deletions from Telegram will not be bridged unless you give "
-            f"redaction permissions to [{evt.az.bot_mxid}](https://matrix.to/#/{evt.az.bot_mxid})"
-        )
-
-
-async def user_has_power_level(
-    room_id: RoomID, intent: IntentAPI, sender: u.User, event: str
-) -> bool:
+async def user_has_power_level(room: str, intent, sender: u.User, event: str, default: int = 50
+                               ) -> bool:
    if sender.is_admin:
        return True
    # Make sure the state store contains the power levels.
    try:
-        await intent.get_power_levels(room_id)
+        await intent.get_power_levels(room)
    except MatrixRequestError:
        return False
-    event_type = EventType.find(f"fi.mau.telegram.{event}", t_class=EventType.Class.STATE)
-    return await intent.state_store.has_power_level(room_id, sender.mxid, event_type)
+    return intent.state_store.has_power_level(room, sender.mxid,
+                                              event=f"net.maunium.telegram.{event}",
+                                              default=default)
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,37 +14,22 @@
 #
 # 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 __future__ import annotations
+from typing import Dict, Optional

-from telethon.errors import (
-    AboutTooLongError,
-    AuthKeyError,
-    FirstNameInvalidError,
-    HashInvalidError,
-    UsernameInvalidError,
-    UsernameNotModifiedError,
-    UsernameOccupiedError,
-)
-from telethon.tl.functions.account import (
-    GetAuthorizationsRequest,
-    ResetAuthorizationRequest,
-    UpdateProfileRequest,
-    UpdateUsernameRequest,
-)
+from telethon.errors import (UsernameInvalidError, UsernameNotModifiedError, UsernameOccupiedError,
+                             HashInvalidError, AuthKeyError, FirstNameInvalidError)
 from telethon.tl.types import Authorization
+from telethon.tl.functions.account import (UpdateUsernameRequest, GetAuthorizationsRequest,
+                                           ResetAuthorizationRequest, UpdateProfileRequest)

-from mautrix.types import EventID
-
-from .. import SECTION_AUTH, CommandEvent, command_handler
+from .. import command_handler, CommandEvent, SECTION_AUTH


-@command_handler(
-    needs_auth=True,
-    help_section=SECTION_AUTH,
-    help_args="<_new username_>",
-    help_text="Change your Telegram username.",
-)
-async def username(evt: CommandEvent) -> EventID:
+@command_handler(needs_auth=True,
+                 help_section=SECTION_AUTH,
+                 help_args="<_new username_>",
+                 help_text="Change your Telegram username.")
+async def username(evt: CommandEvent) -> Optional[Dict]:
    if len(evt.args) == 0:
        return await evt.reply("**Usage:** `$cmdprefix+sp username <new username>`")
    if evt.sender.is_bot:
@@ -54,80 +40,50 @@ async def username(evt: CommandEvent) -> EventID:
    try:
        await evt.sender.client(UpdateUsernameRequest(username=new_name))
    except UsernameInvalidError:
-        return await evt.reply(
-            "Invalid username. Usernames must be between 5 and 30 alphanumeric characters."
-        )
+        return await evt.reply("Invalid username. Usernames must be between 5 and 30 alphanumeric "
+                               "characters.")
    except UsernameNotModifiedError:
        return await evt.reply("That is your current username.")
    except UsernameOccupiedError:
        return await evt.reply("That username is already in use.")
    await evt.sender.update_info()
-    if not evt.sender.tg_username:
+    if not evt.sender.username:
        await evt.reply("Username removed")
    else:
-        await evt.reply(f"Username changed to {evt.sender.tg_username}")
+        await evt.reply(f"Username changed to {evt.sender.username}")


-@command_handler(
-    needs_auth=True,
-    help_section=SECTION_AUTH,
-    help_args="<_new about_>",
-    help_text="Change your Telegram about section.",
-)
-async def about(evt: CommandEvent) -> EventID:
-    if len(evt.args) == 0:
-        return await evt.reply("**Usage:** `$cmdprefix+sp about <new about>`")
-    if evt.sender.is_bot:
-        return await evt.reply("Bots can't set their own about section.")
-    new_about = " ".join(evt.args)
-    if new_about == "-":
-        new_about = ""
-    try:
-        await evt.sender.client(UpdateProfileRequest(about=new_about))
-    except AboutTooLongError:
-        return await evt.reply("The provided about section is too long")
-    return await evt.reply("About section updated")
-
-
-@command_handler(
-    needs_auth=True,
-    help_section=SECTION_AUTH,
-    help_args="<_new displayname_>",
-    help_text="Change your Telegram displayname.",
-)
-async def displayname(evt: CommandEvent) -> EventID:
+@command_handler(needs_auth=True, help_section=SECTION_AUTH, help_args="<_new displayname_>",
+                 help_text="Change your Telegram displayname.")
+async def displayname(evt: CommandEvent) -> Optional[Dict]:
    if len(evt.args) == 0:
        return await evt.reply("**Usage:** `$cmdprefix+sp displayname <new displayname>`")
    if evt.sender.is_bot:
        return await evt.reply("Bots can't set their own displayname.")

-    first_name, last_name = (
-        (evt.args[0], "") if len(evt.args) == 1 else (" ".join(evt.args[:-1]), evt.args[-1])
-    )
+    first_name, last_name = ((evt.args[0], "")
+                             if len(evt.args) == 1
+                             else (" ".join(evt.args[:-1]), evt.args[-1]))
    try:
        await evt.sender.client(UpdateProfileRequest(first_name=first_name, last_name=last_name))
    except FirstNameInvalidError:
        return await evt.reply("Invalid first name")
    await evt.sender.update_info()
-    return await evt.reply("Displayname updated")
+    await evt.reply("Displayname updated")


 def _format_session(sess: Authorization) -> str:
-    return (
-        f"**{sess.app_name} {sess.app_version}**  \n"
-        f"  **Platform:** {sess.device_model} {sess.platform} {sess.system_version}  \n"
-        f"  **Active:** {sess.date_active} (created {sess.date_created})  \n"
-        f"  **From:** {sess.ip} - {sess.region}, {sess.country}"
-    )
+    return (f"**{sess.app_name} {sess.app_version}**  \n"
+            f"  **Platform:** {sess.device_model} {sess.platform} {sess.system_version}  \n"
+            f"  **Active:** {sess.date_active} (created {sess.date_created})  \n"
+            f"  **From:** {sess.ip} - {sess.region}, {sess.country}")


-@command_handler(
-    needs_auth=True,
-    help_section=SECTION_AUTH,
-    help_args="<`list`|`terminate`> [_hash_]",
-    help_text="View or delete other Telegram sessions.",
-)
-async def session(evt: CommandEvent) -> EventID:
+@command_handler(needs_auth=True,
+                 help_section=SECTION_AUTH,
+                 help_args="<`list`|`terminate`> [_hash_]",
+                 help_text="View or delete other Telegram sessions.")
+async def session(evt: CommandEvent) -> Optional[Dict]:
    if len(evt.args) == 0:
        return await evt.reply("**Usage:** `$cmdprefix+sp session <list|terminate> [hash]`")
    elif evt.sender.is_bot:
@@ -138,18 +94,14 @@ async def session(evt: CommandEvent) -> EventID:
        session_list = res.authorizations
        current = [s for s in session_list if s.current][0]
        current_text = _format_session(current)
-        other_text = "\n".join(
-            f"* {_format_session(sess)}  \n  **Hash:** {sess.hash}"
-            for sess in session_list
-            if not sess.current
-        )
-        return await evt.reply(
-            f"### Current session\n"
-            f"{current_text}\n"
-            f"\n"
-            f"### Other active sessions\n"
-            f"{other_text}"
-        )
+        other_text = "\n".join(f"* {_format_session(sess)}  \n"
+                               f"  **Hash:** {sess.hash}"
+                               for sess in session_list if not sess.current)
+        return await evt.reply(f"### Current session\n"
+                               f"{current_text}\n"
+                               f"\n"
+                               f"### Other active sessions\n"
+                               f"{other_text}")
    elif cmd == "terminate" and len(evt.args) > 1:
        try:
            session_hash = int(evt.args[1])
@@ -161,9 +113,8 @@ async def session(evt: CommandEvent) -> EventID:
            return await evt.reply("Invalid session hash.")
        except AuthKeyError as e:
            if e.message == "FRESH_RESET_AUTHORISATION_FORBIDDEN":
-                return await evt.reply(
-                    "New sessions can't terminate other sessions. Please wait a while."
-                )
+                return await evt.reply("New sessions can't terminate other sessions. "
+                                       "Please wait a while.")
            raise
        if ok:
            return await evt.reply("Session terminated successfully.")
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,184 +14,106 @@
 #
 # 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 __future__ import annotations
-
-from typing import Any
+from typing import Any, Dict, Optional
 import asyncio
-import io

 from telethon.errors import (
-    AccessTokenExpiredError,
-    AccessTokenInvalidError,
-    FloodWaitError,
-    PasswordHashInvalidError,
-    PhoneCodeExpiredError,
-    PhoneCodeInvalidError,
-    PhoneNumberAppSignupForbiddenError,
-    PhoneNumberBannedError,
-    PhoneNumberFloodError,
-    PhoneNumberInvalidError,
-    PhoneNumberUnoccupiedError,
-    SessionPasswordNeededError,
-)
-from telethon.tl.types import User
+    AccessTokenExpiredError, AccessTokenInvalidError, FirstNameInvalidError, FloodWaitError,
+    PasswordHashInvalidError, PhoneCodeExpiredError, PhoneCodeInvalidError,
+    PhoneNumberAppSignupForbiddenError, PhoneNumberBannedError, PhoneNumberFloodError,
+    PhoneNumberOccupiedError, PhoneNumberUnoccupiedError, SessionPasswordNeededError)

-from mautrix.client import Client
-from mautrix.types import (
-    EventID,
-    ImageInfo,
-    MediaMessageEventContent,
-    MessageType,
-    TextMessageEventContent,
-    UserID,
-)
-from mautrix.util import background_task
-from mautrix.util.format_duration import format_duration as fmt_duration
-
-from ... import user as u
-from ...commands import SECTION_AUTH, CommandEvent, command_handler
-from ...types import TelegramID
-
-try:
-    from telethon.tl.custom import QRLogin
-    import PIL as _
-    import qrcode
-except ImportError:
-    qrcode = None
-    QRLogin = None
+from ... import puppet as pu, user as u
+from ...commands import command_handler, CommandEvent, SECTION_AUTH
+from ...util import format_duration, ignore_coro


-@command_handler(
-    needs_auth=False, help_section=SECTION_AUTH, help_text="Check if you're logged into Telegram."
-)
-async def ping(evt: CommandEvent) -> EventID:
-    if await evt.sender.is_logged_in():
-        me = await evt.sender.get_me()
-        if me:
-            human_tg_id = f"@{me.username}" if me.username else f"+{me.phone}"
-            return await evt.reply(f"You're logged in as {human_tg_id}")
-        else:
-            return await evt.reply("You were logged in, but there appears to have been an error.")
+@command_handler(needs_auth=False,
+                 help_section=SECTION_AUTH,
+                 help_text="Check if you're logged into Telegram.")
+async def ping(evt: CommandEvent) -> Optional[Dict]:
+    me = await evt.sender.client.get_me() if await evt.sender.is_logged_in() else None
+    if me:
+        human_tg_id = f"@{me.username}" if me.username else f"+{me.phone}"
+        return await evt.reply(f"You're logged in as {human_tg_id}")
    else:
        return await evt.reply("You're not logged in.")


-@command_handler(
-    needs_auth=False,
-    needs_puppeting=False,
-    help_section=SECTION_AUTH,
-    help_text="Get the info of the message relay Telegram bot.",
-)
-async def ping_bot(evt: CommandEvent) -> EventID:
+@command_handler(needs_auth=False, needs_puppeting=False,
+                 help_section=SECTION_AUTH,
+                 help_text="Get the info of the message relay Telegram bot.")
+async def ping_bot(evt: CommandEvent) -> Optional[Dict]:
    if not evt.tgbot:
        return await evt.reply("Telegram message relay bot not configured.")
    info, mxid = await evt.tgbot.get_me(use_cache=False)
-    return await evt.reply(
-        "Telegram message relay bot is active: "
-        f"[{info.first_name}](https://matrix.to/#/{mxid}) (ID {info.id})\n\n"
-        "To use the bot, simply invite it to a portal room."
-    )
+    return await evt.reply("Telegram message relay bot is active: "
+                           f"[{info.first_name}](https://matrix.to/#/{mxid}) (ID {info.id})\n\n"
+                           "To use the bot, simply invite it to a portal room.")


-@command_handler(
-    needs_auth=False,
-    management_only=True,
-    help_section=SECTION_AUTH,
-    help_text="Log in by scanning a QR code.",
-)
-async def login_qr(evt: CommandEvent) -> EventID:
-    login_as = evt.sender
-    if len(evt.args) > 0 and evt.sender.is_admin:
-        login_as = await u.User.get_by_mxid(UserID(evt.args[0]))
-    if not qrcode or not QRLogin:
-        return await evt.reply("This bridge instance does not support logging in with a QR code.")
-    if await login_as.is_logged_in():
-        return await evt.reply(f"You are already logged in as {login_as.human_tg_id}.")
+@command_handler(needs_auth=False, management_only=True,
+                 help_section=SECTION_AUTH,
+                 help_args="<_phone_> <_full name_>",
+                 help_text="Register to Telegram")
+async def register(evt: CommandEvent) -> Optional[Dict]:
+    if await evt.sender.is_logged_in():
+        return await evt.reply("You are already logged in.")
+    elif len(evt.args) < 1:
+        return await evt.reply("**Usage:** `$cmdprefix+sp register <phone> <full name>`")

-    await login_as.ensure_started(even_if_no_session=True)
-    qr_login = QRLogin(login_as.client, ignored_ids=[])
-    qr_event_id: EventID | None = None
-
-    async def upload_qr() -> None:
-        nonlocal qr_event_id
-        buffer = io.BytesIO()
-        image = qrcode.make(qr_login.url)
-        size = image.pixel_size
-        image.save(buffer, "PNG")
-        qr = buffer.getvalue()
-        mxc = await evt.az.intent.upload_media(qr, "image/png", "login-qr.png", len(qr))
-        content = MediaMessageEventContent(
-            body=qr_login.url,
-            url=mxc,
-            msgtype=MessageType.IMAGE,
-            info=ImageInfo(mimetype="image/png", size=len(qr), width=size, height=size),
-        )
-        if qr_event_id:
-            content.set_edit(qr_event_id)
-            await evt.az.intent.send_message(evt.room_id, content)
-        else:
-            content.set_reply(evt.event_id)
-            qr_event_id = await evt.az.intent.send_message(evt.room_id, content)
-
-    retries = 4
-    while retries > 0:
-        await qr_login.recreate()
-        await upload_qr()
-        try:
-            user = await qr_login.wait()
-            break
-        except asyncio.TimeoutError:
-            retries -= 1
-        except SessionPasswordNeededError:
-            evt.sender.command_status = {
-                "next": enter_password,
-                "login_as": login_as if login_as != evt.sender else None,
-                "action": "Login (password entry)",
-            }
-            return await evt.reply(
-                "Your account has two-factor authentication. Please send your password here."
-            )
-        try:
-            await evt.main_intent.redact(evt.room_id, qr_event_id, reason="QR code scanned")
-        except Exception:
-            pass
+    phone_number = evt.args[0]
+    if len(evt.args) == 2:
+        full_name = evt.args[1], ""
    else:
-        timeout = TextMessageEventContent(body="Login timed out", msgtype=MessageType.TEXT)
-        timeout.set_edit(qr_event_id)
-        return await evt.az.intent.send_message(evt.room_id, timeout)
+        full_name = " ".join(evt.args[1:-1]), evt.args[-1]

-    return await _finish_sign_in(evt, user, login_as=login_as)
+    await _request_code(evt, phone_number, {
+        "next": enter_code_register,
+        "action": "Register",
+        "full_name": full_name,
+    })
+    return None


-@command_handler(
-    needs_auth=False,
-    management_only=True,
-    help_section=SECTION_AUTH,
-    help_text="Get instructions on how to log in.",
-)
-async def login(evt: CommandEvent) -> EventID:
+async def enter_code_register(evt: CommandEvent) -> Dict:
+    if len(evt.args) == 0:
+        return await evt.reply("**Usage:** `$cmdprefix+sp <code>`")
+    try:
+        await evt.sender.ensure_started(even_if_no_session=True)
+        first_name, last_name = evt.sender.command_status["full_name"]
+        user = await evt.sender.client.sign_up(evt.args[0], first_name, last_name)
+        ignore_coro(asyncio.ensure_future(evt.sender.post_login(user), loop=evt.loop))
+        evt.sender.command_status = None
+        return await evt.reply(f"Successfully registered to Telegram.")
+    except PhoneNumberOccupiedError:
+        return await evt.reply("That phone number has already been registered. "
+                               "You can log in with `$cmdprefix+sp login`.")
+    except FirstNameInvalidError:
+        return await evt.reply("Invalid name. Please set a Matrix displayname before registering.")
+    except PhoneCodeExpiredError:
+        return await evt.reply(
+            "Phone code expired. Try again with `$cmdprefix+sp register <phone>`.")
+    except PhoneCodeInvalidError:
+        return await evt.reply("Invalid phone code.")
+    except Exception:
+        evt.log.exception("Error sending phone code")
+        return await evt.reply("Unhandled exception while sending code. "
+                               "Check console for more details.")
+
+
+@command_handler(needs_auth=False, management_only=True,
+                 help_section=SECTION_AUTH,
+                 help_text="Get instructions on how to log in.")
+async def login(evt: CommandEvent) -> Optional[Dict]:
    override_sender = False
-    if len(evt.args) > 0 and evt.sender.is_admin and evt.args[0]:
-        override_user_id = UserID(evt.args[0])
-        try:
-            Client.parse_user_id(override_user_id)
-        except ValueError:
-            return await evt.reply(
-                f"**Usage:** `$cmdprefix+sp login [override user ID]`\n\n"
-                f"{override_user_id!r} is not a valid Matrix user ID"
-            )
-        orig_user_id = evt.sender.mxid
-        evt.sender = await u.User.get_and_start_by_mxid(override_user_id)
+    if len(evt.args) > 0 and evt.sender.is_admin:
+        evt.sender = await u.User.get_by_mxid(evt.args[0]).ensure_started()
        override_sender = True
-        if orig_user_id != evt.sender:
-            await evt.reply(
-                f"Admin override: logging in as {evt.sender.mxid} instead of {orig_user_id}"
-            )
-
    if await evt.sender.is_logged_in():
        return await evt.reply(f"You are already logged in as {evt.sender.human_tg_id}.")

-    allow_matrix_login = evt.config["bridge.allow_matrix_login"]
+    allow_matrix_login = evt.config.get("bridge.allow_matrix_login", True)
    if allow_matrix_login and not override_sender:
        evt.sender.command_status = {
            "next": enter_phone_or_token,
@@ -202,32 +125,24 @@ async def login(evt: CommandEvent) -> EventID:
        prefix = evt.config["appservice.public.external"]
        url = f"{prefix}/login?token={evt.public_website.make_token(evt.sender.mxid, '/login')}"
        if override_sender:
-            return await evt.reply(
-                f"[Click here to log in]({url}) as "
-                f"[{evt.sender.mxid}](https://matrix.to/#/{evt.sender.mxid})."
-            )
+            return await evt.reply(f"[Click here to log in]({url}) as "
+                                   f"[{evt.sender.mxid}](https://matrix.to/#/{evt.sender.mxid}).")
        elif allow_matrix_login:
-            return await evt.reply(
-                f"[Click here to log in]({url}). Alternatively, send your phone"
-                f" number (or bot auth token) here to log in.\n\n{nb}"
-            )
+            return await evt.reply(f"[Click here to log in]({url}). Alternatively, send your phone"
+                                   f" number (or bot auth token) here to log in.\n\n{nb}")
        return await evt.reply(f"[Click here to log in]({url}).\n\n{nb}")
    elif allow_matrix_login:
        if override_sender:
            return await evt.reply(
                "This bridge instance does not allow you to log in outside of Matrix. "
-                "Logging in as another user inside Matrix is not currently possible."
-            )
-        return await evt.reply(
-            "Please send your phone number (or bot auth token) here to start "
-            f"the login process.\n\n{nb}"
-        )
+                "Logging in as another user inside Matrix is not currently possible.")
+        return await evt.reply("Please send your phone number (or bot auth token) here to start "
+                               f"the login process.\n\n{nb}")
    return await evt.reply("This bridge instance has been configured to not allow logging in.")


-async def _request_code(
-    evt: CommandEvent, phone_number: str, next_status: dict[str, Any]
-) -> EventID:
+async def _request_code(evt: CommandEvent, phone_number: str, next_status: Dict[str, Any]
+                        ) -> Dict:
    ok = False
    try:
        await evt.sender.ensure_started(even_if_no_session=True)
@@ -235,44 +150,36 @@ async def _request_code(
        ok = True
        return await evt.reply(f"Login code sent to {phone_number}. Please send the code here.")
    except PhoneNumberAppSignupForbiddenError:
-        return await evt.reply("Your phone number does not allow 3rd party apps to sign in.")
+        return await evt.reply(
+            "Your phone number does not allow 3rd party apps to sign in.")
    except PhoneNumberFloodError:
        return await evt.reply(
            "Your phone number has been temporarily blocked for flooding. "
-            "The ban is usually applied for around a day."
-        )
+            "The ban is usually applied for around a day.")
    except FloodWaitError as e:
        return await evt.reply(
            "Your phone number has been temporarily blocked for flooding. "
-            f"Please wait for {fmt_duration(e.seconds)} before trying again."
-        )
+            f"Please wait for {format_duration(e.seconds)} before trying again.")
    except PhoneNumberBannedError:
-        return await evt.reply("Your phone number has been banned from Telegram.")
+        return await  evt.reply("Your phone number has been banned from Telegram.")
    except PhoneNumberUnoccupiedError:
-        return await evt.reply(
-            "That phone number has not been registered. "
-            "Please sign up to Telegram using an official mobile client first."
-        )
-    except PhoneNumberInvalidError:
-        return await evt.reply("That phone number is not valid.")
+        return await  evt.reply("That phone number has not been registered. "
+                                "Please register with `$cmdprefix+sp register <phone>`.")
    except Exception:
        evt.log.exception("Error requesting phone code")
-        return await evt.reply(
-            "Unhandled exception while requesting code. Check console for more details."
-        )
+        return await evt.reply("Unhandled exception while requesting code. "
+                               "Check console for more details.")
    finally:
        evt.sender.command_status = next_status if ok else None


@command_handler(needs_auth=False)
-async def enter_phone_or_token(evt: CommandEvent) -> EventID | None:
+async def enter_phone_or_token(evt: CommandEvent) -> Optional[Dict]:
    if len(evt.args) == 0:
        return await evt.reply("**Usage:** `$cmdprefix+sp enter-phone-or-token <phone-or-token>`")
    elif not evt.config.get("bridge.allow_matrix_login", True):
-        return await evt.reply(
-            "This bridge instance does not allow in-Matrix login. "
-            "Please use `$cmdprefix+sp login` to get login instructions"
-        )
+        return await evt.reply("This bridge instance does not allow in-Matrix login. "
+                               "Please use `$cmdprefix+sp login` to get login instructions")

    # phone numbers don't contain colons but telegram bot auth tokens do
    if evt.args[0].find(":") > 0:
@@ -280,67 +187,66 @@ async def enter_phone_or_token(evt: CommandEvent) -> EventID | None:
            await _sign_in(evt, bot_token=evt.args[0])
        except Exception:
            evt.log.exception("Error sending auth token")
-            return await evt.reply(
-                "Unhandled exception while sending auth token. Check console for more details."
-            )
+            return await evt.reply("Unhandled exception while sending auth token. "
+                                   "Check console for more details.")
    else:
-        await _request_code(evt, evt.args[0], {"next": enter_code, "action": "Login"})
+        await _request_code(evt, evt.args[0], {
+            "next": enter_code,
+            "action": "Login",
+        })
    return None


@command_handler(needs_auth=False)
-async def enter_code(evt: CommandEvent) -> EventID | None:
+async def enter_code(evt: CommandEvent) -> Optional[Dict]:
    if len(evt.args) == 0:
        return await evt.reply("**Usage:** `$cmdprefix+sp enter-code <code>`")
    elif not evt.config.get("bridge.allow_matrix_login", True):
-        return await evt.reply(
-            "This bridge instance does not allow in-Matrix login. "
-            "Please use `$cmdprefix+sp login` to get login instructions"
-        )
+        return await evt.reply("This bridge instance does not allow in-Matrix login. "
+                               "Please use `$cmdprefix+sp login` to get login instructions")
    try:
        await _sign_in(evt, code=evt.args[0])
    except Exception:
        evt.log.exception("Error sending phone code")
-        return await evt.reply(
-            "Unhandled exception while sending code. Check console for more details."
-        )
+        return await evt.reply("Unhandled exception while sending code. "
+                               "Check console for more details.")
    return None


@command_handler(needs_auth=False)
-async def enter_password(evt: CommandEvent) -> EventID | None:
+async def enter_password(evt: CommandEvent) -> Optional[Dict]:
    if len(evt.args) == 0:
        return await evt.reply("**Usage:** `$cmdprefix+sp enter-password <password>`")
    elif not evt.config.get("bridge.allow_matrix_login", True):
-        return await evt.reply(
-            "This bridge instance does not allow in-Matrix login. "
-            "Please use `$cmdprefix+sp login` to get login instructions"
-        )
-    await evt.redact()
+        return await evt.reply("This bridge instance does not allow in-Matrix login. "
+                               "Please use `$cmdprefix+sp login` to get login instructions")
    try:
-        await _sign_in(
-            evt,
-            login_as=evt.sender.command_status.get("login_as", None),
-            password=" ".join(evt.args),
-        )
+        await _sign_in(evt, password=" ".join(evt.args))
    except AccessTokenInvalidError:
        return await evt.reply("That bot token is not valid.")
    except AccessTokenExpiredError:
        return await evt.reply("That bot token has expired.")
    except Exception:
        evt.log.exception("Error sending password")
-        return await evt.reply(
-            "Unhandled exception while sending password. Check console for more details."
-        )
+        return await evt.reply("Unhandled exception while sending password. "
+                               "Check console for more details.")
    return None


-async def _sign_in(evt: CommandEvent, login_as: u.User = None, **sign_in_info) -> EventID:
-    login_as = login_as or evt.sender
+async def _sign_in(evt: CommandEvent, **sign_in_info) -> Dict:
    try:
-        await login_as.ensure_started(even_if_no_session=True)
-        user = await login_as.client.sign_in(**sign_in_info)
-        await _finish_sign_in(evt, user)
+        await evt.sender.ensure_started(even_if_no_session=True)
+        user = await evt.sender.client.sign_in(**sign_in_info)
+        existing_user = u.User.get_by_tgid(user.id)
+        if existing_user and existing_user != evt.sender:
+            await existing_user.log_out()
+            await evt.reply(f"[{existing_user.displayname}]"
+                            f"(https://matrix.to/#/{existing_user.mxid})"
+                            " was logged out from the account.")
+        ignore_coro(asyncio.ensure_future(evt.sender.post_login(user), loop=evt.loop))
+        evt.sender.command_status = None
+        name = f"@{user.username}" if user.username else f"+{user.phone}"
+        return await evt.reply(f"Successfully logged in as {name}")
    except PhoneCodeExpiredError:
        return await evt.reply("Phone code expired. Try again with `$cmdprefix+sp login`.")
    except PhoneCodeInvalidError:
@@ -352,37 +258,14 @@ async def _sign_in(evt: CommandEvent, login_as: u.User = None, **sign_in_info) -
            "next": enter_password,
            "action": "Login (password entry)",
        }
-        return await evt.reply(
-            "Your account has two-factor authentication. Please send your password here."
-        )
+        return await evt.reply("Your account has two-factor authentication. "
+                               "Please send your password here.")


-async def _finish_sign_in(evt: CommandEvent, user: User, login_as: u.User = None) -> EventID:
-    login_as = login_as or evt.sender
-    existing_user = await u.User.get_by_tgid(TelegramID(user.id))
-    if existing_user and existing_user != login_as:
-        await existing_user.log_out()
-        await evt.reply(
-            f"[{existing_user.displayname}] (https://matrix.to/#/{existing_user.mxid})"
-            " was logged out from the account."
-        )
-    background_task.create(login_as.post_login(user, first_login=True))
-    evt.sender.command_status = None
-    name = f"@{user.username}" if user.username else f"+{user.phone}"
-    if login_as != evt.sender:
-        msg = (
-            f"Successfully logged in [{login_as.mxid}](https://matrix.to/#/{login_as.mxid})"
-            f" as {name}"
-        )
-    else:
-        msg = f"Successfully logged in as {name}"
-    return await evt.reply(msg)
-
-
-@command_handler(needs_auth=False, help_section=SECTION_AUTH, help_text="Log out from Telegram.")
-async def logout(evt: CommandEvent) -> EventID:
-    if not evt.sender.tgid:
-        return await evt.reply("You're not logged in")
+@command_handler(needs_auth=True,
+                 help_section=SECTION_AUTH,
+                 help_text="Log out from Telegram.")
+async def logout(evt: CommandEvent) -> Optional[Dict]:
    if await evt.sender.log_out():
        return await evt.reply("Logged out successfully.")
    return await evt.reply("Failed to log out.")
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,88 +14,32 @@
 #
 # 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 __future__ import annotations
-
-from typing import cast
-import base64
+from typing import Dict, List, Optional, Tuple
 import codecs
+import base64
 import re
-import shlex

-from aiohttp import ClientSession, InvalidURL
-from telethon.errors import (
-    ChatIdInvalidError,
-    EmoticonInvalidError,
-    InviteHashExpiredError,
-    InviteHashInvalidError,
-    InviteRequestSentError,
-    OptionsTooMuchError,
-    UserAlreadyParticipantError,
-)
-from telethon.tl.functions.channels import JoinChannelRequest
-from telethon.tl.functions.contacts import DeleteByPhonesRequest, ImportContactsRequest
-from telethon.tl.functions.messages import (
-    CheckChatInviteRequest,
-    GetBotCallbackAnswerRequest,
-    ImportChatInviteRequest,
-    SendVoteRequest,
-)
+from telethon.errors import (InviteHashInvalidError, InviteHashExpiredError, OptionsTooMuchError,
+                             UserAlreadyParticipantError)
 from telethon.tl.patched import Message
-from telethon.tl.types import (
-    InputMediaDice,
-    InputPhoneContact,
-    MessageMediaGame,
-    MessageMediaPoll,
-    TypeInputPeer,
-    TypeUpdates,
-    User as TLUser,
-)
-from telethon.tl.types.contacts import ImportedContacts
+from telethon.tl.types import (User as TLUser, TypeUpdates, MessageMediaGame, MessageMediaPoll,
+                               TypePeer)
 from telethon.tl.types.messages import BotCallbackAnswer
+from telethon.tl.functions.messages import (ImportChatInviteRequest, CheckChatInviteRequest,
+                                            GetBotCallbackAnswerRequest, SendVoteRequest)
+from telethon.tl.functions.channels import JoinChannelRequest

-from mautrix.types import EventID, Format
-
-from ... import portal as po, puppet as pu
+from ... import puppet as pu, portal as po
 from ...abstract_user import AbstractUser
-from ...commands import (
-    SECTION_CREATING_PORTALS,
-    SECTION_MISC,
-    SECTION_PORTAL_MANAGEMENT,
-    CommandEvent,
-    command_handler,
-)
 from ...db import Message as DBMessage
 from ...types import TelegramID
+from ...commands import command_handler, CommandEvent, SECTION_MISC, SECTION_CREATING_PORTALS


-@command_handler(
-    needs_auth=False,
-    needs_puppeting=False,
-    help_section=SECTION_MISC,
-    help_args="<_caption_>",
-    help_text="Set a caption for the next image you send",
-)
-async def caption(evt: CommandEvent) -> EventID:
-    if len(evt.args) == 0:
-        return await evt.reply("**Usage:** `$cmdprefix+sp caption <caption>`")
-
-    prefix = f"{evt.command_prefix} caption "
-    if evt.content.format == Format.HTML:
-        evt.content.formatted_body = evt.content.formatted_body.replace(prefix, "", 1)
-    evt.content.body = evt.content.body.replace(prefix, "", 1)
-    evt.sender.command_status = {"caption": evt.content, "action": "Caption"}
-    return await evt.reply(
-        "Your next image or file will be sent with that caption. "
-        "Use `$cmdprefix+sp cancel` to cancel the caption."
-    )
-
-
-@command_handler(
-    help_section=SECTION_MISC,
-    help_args="[_-r|--remote_] <_query_>",
-    help_text="Search your contacts or the Telegram servers for users.",
-)
-async def search(evt: CommandEvent) -> EventID:
+@command_handler(help_section=SECTION_MISC,
+                 help_args="[_-r|--remote_] <_query_>",
+                 help_text="Search your contacts or the Telegram servers for users.")
+async def search(evt: CommandEvent) -> Optional[Dict]:
    if len(evt.args) == 0:
        return await evt.reply("**Usage:** `$cmdprefix+sp search [-r|--remote] <query>`")

@@ -111,45 +56,36 @@ async def search(evt: CommandEvent) -> EventID:

    if not results:
        if len(query) < 5 and remote:
-            return await evt.reply(
-                "No local results. Minimum length of remote query is 5 characters."
-            )
+            return await evt.reply("No local results. "
+                                   "Minimum length of remote query is 5 characters.")
        return await evt.reply("No results 3:")

-    reply: list[str] = []
+    reply = []  # type: List[str]
    if remote:
        reply += ["**Results from Telegram server:**", ""]
    else:
        reply += ["**Results in contacts:**", ""]
-    reply += [
-        (
-            f"* [{puppet.displayname}](https://matrix.to/#/{puppet.mxid}): "
-            f"{puppet.id} ({similarity}% match)"
-        )
-        for puppet, similarity in results
-    ]
+    reply += [(f"* [{puppet.displayname}](https://matrix.to/#/{puppet.mxid}): "
+               f"{puppet.id} ({similarity}% match)")
+              for puppet, similarity in results]

    # TODO somehow show remote channel results when joining by alias is possible?

    return await evt.reply("\n".join(reply))


-@command_handler(
-    help_section=SECTION_CREATING_PORTALS,
-    help_args="<_username_>",
-    help_text=(
-        "Open a private chat with the given Telegram user. You can also use a "
-        "phone number instead of username, but you must have the number in "
-        "your Telegram contacts for that to work."
-    ),
-)
-async def pm(evt: CommandEvent) -> EventID:
+@command_handler(help_section=SECTION_CREATING_PORTALS,
+                 help_args="<_identifier_>",
+                 help_text="Open a private chat with the given Telegram user. The identifier is "
+                           "either the internal user ID, the username or the phone number. "
+                           "**N.B.** The phone numbers you start chats with must already be in "
+                           "your contacts.")
+async def pm(evt: CommandEvent) -> Optional[Dict]:
    if len(evt.args) == 0:
-        return await evt.reply("**Usage:** `$cmdprefix+sp pm <username>`")
+        return await evt.reply("**Usage:** `$cmdprefix+sp pm <user identifier>`")

    try:
-        id = "".join(evt.args).translate({ord(c): None for c in "+()- "})
-        user = await evt.sender.client.get_entity(id)
+        user = await evt.sender.client.get_entity(evt.args[0])
    except ValueError:
        return await evt.reply("Invalid user identifier or user not found.")

@@ -157,170 +93,64 @@ async def pm(evt: CommandEvent) -> EventID:
        return await evt.reply("User not found.")
    elif not isinstance(user, TLUser):
        return await evt.reply("That doesn't seem to be a user.")
-    portal = await po.Portal.get_by_entity(user, tg_receiver=evt.sender.tgid)
+    portal = po.Portal.get_by_entity(user, evt.sender.tgid)
    await portal.create_matrix_room(evt.sender, user, [evt.sender.mxid])
-    displayname, _ = pu.Puppet.get_displayname(user, False)
-    return await evt.reply(f"Created private chat room with {displayname}")
+    return await evt.reply("Created private chat room with "
+                           f"{pu.Puppet.get_displayname(user, False)}")


-async def _handle_contact(source: AbstractUser, user: TLUser) -> str:
-    puppet: pu.Puppet = await pu.Puppet.get_by_tgid(user.id)
-    await puppet.update_info(source, user)
-
-    params = []
-    if user.username:
-        params.append(f"[@{user.username}](https://t.me/{user.username})")
-    if user.phone:
-        params.append(f"+{user.phone}")
-    params.append(f"ID `{user.id}`")
-    params_str = " / ".join(params)
-    return f"[{puppet.displayname}](https://matrix.to/#/{puppet.mxid}): {params_str}"
-
-
-@command_handler(
-    help_section=SECTION_CREATING_PORTALS,
-    help_args="<_phone_> <_first name_> <_last name_>",
-    help_text="Add a phone number to your contacts on Telegram",
-)
-async def add_contact(evt: CommandEvent) -> EventID:
-    if len(evt.args) < 3:
-        return await evt.reply(
-            "**Usage:** `$cmdprefix+sp add-contact <phone> <first name> <last name>`"
-        )
-    try:
-        names = shlex.split(" ".join(evt.args[1:]))
-    except ValueError as e:
-        return await evt.reply(
-            f"Failed to parse names (use shell quoting for names with spaces): {e}"
-        )
-    if len(names) != 2:
-        return await evt.reply(
-            "Wrong number of names, must have first and last name "
-            "(use shell quoting for names with spaces)"
-        )
-    res: ImportedContacts = await evt.sender.client(
-        ImportContactsRequest(
-            contacts=[
-                InputPhoneContact(
-                    client_id=1, phone=evt.args[0], first_name=names[0], last_name=names[1]
-                )
-            ]
-        )
-    )
-    if res.retry_contacts:
-        return await evt.reply("Failed to import contacts")
-    elif not res.users:
-        return await evt.reply("Contact imported, but user not found on Telegram")
-    imported_str = "\n".join(
-        [f"* {await _handle_contact(evt.sender, user)}" for user in res.users]
-    )
-    return await evt.reply(f"Imported contacts:\n\n{imported_str}")
-
-
-@command_handler(
-    help_section=SECTION_CREATING_PORTALS,
-    help_args="<_phones..._>",
-    help_text="Remove phone numbers from your contacts on Telegram.",
-    aliases=["remove-contact", "delete-contacts", "remove-contacts"],
-)
-async def delete_contact(evt: CommandEvent) -> EventID:
-    if len(evt.args) == 0:
-        return await evt.reply("**Usage:** `$cmdprefix+sp delete-contact <phones...>`")
-    ok = await evt.sender.client(DeleteByPhonesRequest(phones=evt.args))
-    if ok:
-        return await evt.reply("Contacts deleted")
-    else:
-        return await evt.reply("Contacts not deleted?")
-
-
-async def _join(
-    evt: CommandEvent, identifier: str, link_type: str
-) -> tuple[TypeUpdates | None, EventID | None]:
-    if link_type == "joinchat":
+async def _join(evt: CommandEvent, arg: str) -> Tuple[Optional[TypeUpdates], Optional[Dict]]:
+    if arg.startswith("joinchat/"):
+        invite_hash = arg[len("joinchat/"):]
        try:
-            await evt.sender.client(CheckChatInviteRequest(identifier))
+            await evt.sender.client(CheckChatInviteRequest(invite_hash))
        except InviteHashInvalidError:
            return None, await evt.reply("Invalid invite link.")
        except InviteHashExpiredError:
            return None, await evt.reply("Invite link expired.")
        try:
-            return (await evt.sender.client(ImportChatInviteRequest(identifier))), None
+            return (await evt.sender.client(ImportChatInviteRequest(invite_hash))), None
        except UserAlreadyParticipantError:
            return None, await evt.reply("You are already in that chat.")
-        except InviteRequestSentError:
-            return None, await evt.reply("Invite request sent successfully.")
    else:
-        channel = await evt.sender.client.get_entity(identifier)
+        channel = await evt.sender.client.get_entity(arg)
        if not channel:
            return None, await evt.reply("Channel/supergroup not found.")
        return await evt.sender.client(JoinChannelRequest(channel)), None


-@command_handler(
-    help_section=SECTION_CREATING_PORTALS,
-    help_args="<_link_>",
-    help_text="Join a chat with an invite link.",
-)
-async def join(evt: CommandEvent) -> EventID | None:
+@command_handler(help_section=SECTION_CREATING_PORTALS,
+                 help_args="<_link_>",
+                 help_text="Join a chat with an invite link.")
+async def join(evt: CommandEvent) -> Optional[Dict]:
    if len(evt.args) == 0:
        return await evt.reply("**Usage:** `$cmdprefix+sp join <invite link>`")

-    url = evt.args[0]
-    if evt.config["bridge.invite_link_resolve"]:
-        try:
-            async with ClientSession() as sess, sess.get(url) as resp:
-                url = str(resp.url)
-        except InvalidURL:
-            return await evt.reply("That doesn't look like a Telegram invite link.")
-
-    regex = re.compile(
-        r"(?:https?://)?t(?:elegram)?\.(?:dog|me)(?:/(?P<type>joinchat|s))?/(?P<id>[^/]+)/?",
-        flags=re.IGNORECASE,
-    )
-    arg = regex.match(url)
+    regex = re.compile(r"(?:https?://)?t(?:elegram)?\.(?:dog|me)(?:joinchat/)?/(.+)")
+    arg = regex.match(evt.args[0])
    if not arg:
        return await evt.reply("That doesn't look like a Telegram invite link.")

-    data = arg.groupdict()
-    identifier = data["id"]
-    link_type = data["type"]
-    if link_type:
-        link_type = link_type.lower()
-    elif identifier.startswith("+"):
-        link_type = "joinchat"
-        identifier = identifier[1:]
-    updates, _ = await _join(evt, identifier, link_type)
+    updates, _ = await _join(evt, arg.group(1))
    if not updates:
        return None

    for chat in updates.chats:
-        portal = await po.Portal.get_by_entity(chat)
+        portal = po.Portal.get_by_entity(chat)
        if portal.mxid:
            await portal.invite_to_matrix([evt.sender.mxid])
            return await evt.reply(f"Invited you to portal of {portal.title}")
        else:
            await evt.reply(f"Creating room for {chat.title}... This might take a while.")
-            try:
-                await portal.create_matrix_room(evt.sender, chat, [evt.sender.mxid])
-            except ChatIdInvalidError as e:
-                evt.log.trace(
-                    "ChatIdInvalidError while creating portal from !tg join command: %s",
-                    updates.stringify(),
-                )
-                raise e
-            if portal.mxid:
-                return await evt.reply(f"Created room for {portal.title}")
-            else:
-                return await evt.reply(f"Couldn't create room for {portal.title}")
+            await portal.create_matrix_room(evt.sender, chat, [evt.sender.mxid])
+            return await evt.reply(f"Created room for {portal.title}")
    return None


-@command_handler(
-    help_section=SECTION_MISC,
-    help_args="[`chats`|`contacts`|`me`]",
-    help_text="Synchronize your chat portals, contacts and/or own info.",
-)
-async def sync(evt: CommandEvent) -> EventID:
+@command_handler(help_section=SECTION_MISC,
+                 help_args="[`chats`|`contacts`|`me`]",
+                 help_text="Synchronize your chat portals, contacts and/or own info.")
+async def sync(evt: CommandEvent) -> Optional[Dict]:
    if len(evt.args) > 0:
        sync_only = evt.args[0]
        if sync_only not in ("chats", "contacts", "me"):
@@ -329,10 +159,8 @@ async def sync(evt: CommandEvent) -> EventID:
        sync_only = None

    if not sync_only or sync_only == "chats":
-        await evt.reply("Synchronizing chats...")
-        await evt.sender.sync_dialogs()
+        await evt.sender.sync_dialogs(synchronous_create=True)
    if not sync_only or sync_only == "contacts":
-        await evt.reply("Synchronizing contacts...")
        await evt.sender.sync_contacts()
    if not sync_only or sync_only == "me":
        await evt.sender.update_info()
@@ -348,9 +176,8 @@ class MessageIDError(ValueError):
        self.message = message


-async def _parse_encoded_msgid(
-    user: AbstractUser, enc_id: str, type_name: str
-) -> tuple[TypeInputPeer, Message]:
+async def _parse_encoded_msgid(user: AbstractUser, enc_id: str, type_name: str
+                               ) -> Tuple[TypePeer, Message]:
    try:
        enc_id += (4 - len(enc_id) % 4) * "="
        enc_id = base64.b64decode(enc_id)
@@ -364,10 +191,10 @@ async def _parse_encoded_msgid(
        raise MessageIDError(f"Invalid {type_name} ID (format)") from e

    if peer_type == PEER_TYPE_CHAT:
-        orig_msg = await DBMessage.get_one_by_tgid(msg_id, space)
+        orig_msg = DBMessage.get_one_by_tgid(msg_id, space)
        if not orig_msg:
            raise MessageIDError(f"Invalid {type_name} ID (original message not found in db)")
-        new_msg = await DBMessage.get_by_mxid(orig_msg.mxid, orig_msg.mx_room, user.tgid)
+        new_msg = DBMessage.get_by_mxid(orig_msg.mxid, orig_msg.mx_room, user.tgid)
        if not new_msg:
            raise MessageIDError(f"Invalid {type_name} ID (your copy of message not found in db)")
        msg_id = new_msg.tgid
@@ -379,13 +206,13 @@ async def _parse_encoded_msgid(
    msg = await user.client.get_messages(entity=peer, ids=msg_id)
    if not msg:
        raise MessageIDError(f"Invalid {type_name} ID (message not found)")
-    return peer, cast(Message, msg)
+    return peer, msg


-@command_handler(
-    help_section=SECTION_MISC, help_args="<_play ID_>", help_text="Play a Telegram game."
-)
-async def play(evt: CommandEvent) -> EventID:
+@command_handler(help_section=SECTION_MISC,
+                 help_args="<_play ID_>",
+                 help_text="Play a Telegram game.")
+async def play(evt: CommandEvent) -> Optional[Dict]:
    if len(evt.args) < 1:
        return await evt.reply("**Usage:** `$cmdprefix+sp play <play ID>`")
    elif not await evt.sender.is_logged_in():
@@ -401,24 +228,18 @@ async def play(evt: CommandEvent) -> EventID:
    if not isinstance(msg.media, MessageMediaGame):
        return await evt.reply("Invalid play ID (message doesn't look like a game)")

-    game = await evt.sender.client(
-        GetBotCallbackAnswerRequest(peer=peer, msg_id=msg.id, game=True)
-    )
+    game = await evt.sender.client(GetBotCallbackAnswerRequest(peer=peer, msg_id=msg.id, game=True))
    if not isinstance(game, BotCallbackAnswer):
        return await evt.reply("Game request response invalid")

-    return await evt.reply(
-        f"Click [here]({game.url}) to play {msg.media.game.title}:\n\n"
-        f"{msg.media.game.description}"
-    )
+    await evt.reply(f"Click [here]({game.url}) to play {msg.media.game.title}:\n\n"
+                    f"{msg.media.game.description}")


-@command_handler(
-    help_section=SECTION_MISC,
-    help_args="<_poll ID_> <_choice number_>",
-    help_text="Vote in a Telegram poll.",
-)
-async def vote(evt: CommandEvent) -> EventID | None:
+@command_handler(help_section=SECTION_MISC,
+                 help_args="<_poll ID_> <_choice number_>",
+                 help_text="Vote in a Telegram poll.")
+async def vote(evt: CommandEvent) -> Optional[Dict]:
    if len(evt.args) < 1:
        return await evt.reply("**Usage:** `$cmdprefix+sp vote <poll ID> <choice number>`")
    elif not await evt.sender.is_logged_in():
@@ -443,74 +264,20 @@ async def vote(evt: CommandEvent) -> EventID | None:
        except ValueError:
            option_index = None
        if option_index is None:
-            return await evt.reply(
-                f'Invalid option number "{option}"', render_markdown=False, allow_html=False
-            )
+            return await evt.reply(f"Invalid option number \"{option}\"",
+                                   render_markdown=False, allow_html=False)
        elif option_index < 0:
-            return await evt.reply(
-                f"Invalid option number {option}. Option numbers must be positive."
-            )
+            return await evt.reply(f"Invalid option number {option}. "
+                                   f"Option numbers must be positive.")
        elif option_index >= len(msg.media.poll.answers):
-            return await evt.reply(
-                f"Invalid option number {option}. "
-                f"The poll only has {len(msg.media.poll.answers)} options."
-            )
+            return await evt.reply(f"Invalid option number {option}. "
+                                   f"The poll only has {len(msg.media.poll.answers)} options.")
        options.append(msg.media.poll.answers[option_index].option)
-    options = [msg.media.poll.answers[int(option) - 1].option for option in evt.args[1:]]
+    options = [msg.media.poll.answers[int(option) - 1].option
+               for option in evt.args[1:]]
    try:
-        await evt.sender.client(SendVoteRequest(peer=peer, msg_id=msg.id, options=options))
+        resp = await evt.sender.client(SendVoteRequest(peer=peer, msg_id=msg.id, options=options))
    except OptionsTooMuchError:
        return await evt.reply("You passed too many options.")
    # TODO use response
    return await evt.mark_read()
-
-
-@command_handler(
-    help_section=SECTION_MISC,
-    help_args="<_emoji_>",
-    help_text="Roll a dice (\U0001F3B2), kick a football (\u26BD\uFE0F) or throw a "
-    "dart (\U0001F3AF) or basketball (\U0001F3C0) on the Telegram servers.",
-)
-async def random(evt: CommandEvent) -> EventID:
-    if not evt.is_portal:
-        return await evt.reply("You can only randomize values in portal rooms")
-    portal = await po.Portal.get_by_mxid(evt.room_id)
-    arg = evt.args[0] if len(evt.args) > 0 else "dice"
-    emoticon = {
-        "dart": "\U0001F3AF",
-        "dice": "\U0001F3B2",
-        "ball": "\U0001F3C0",
-        "basketball": "\U0001F3C0",
-        "football": "\u26BD",
-        "soccer": "\u26BD",
-    }.get(arg, arg)
-    try:
-        await evt.sender.client.send_media(
-            await portal.get_input_entity(evt.sender), InputMediaDice(emoticon)
-        )
-    except EmoticonInvalidError:
-        return await evt.reply("Invalid emoji for randomization")
-
-
-@command_handler(
-    help_section=SECTION_PORTAL_MANAGEMENT,
-    help_args="[_limit_]",
-    help_text="Backfill messages from Telegram history.",
-)
-async def backfill(evt: CommandEvent) -> None:
-    if not evt.is_portal:
-        await evt.reply("You can only use backfill in portal rooms")
-        return
-    elif not evt.config["bridge.backfill.enable"]:
-        await evt.reply("Backfilling is disabled in the bridge config")
-        return
-    try:
-        limit = int(evt.args[0])
-    except (ValueError, IndexError):
-        limit = -1
-    portal = await po.Portal.get_by_mxid(evt.room_id)
-    if not evt.config["bridge.backfill.normal_groups"] and portal.peer_type == "chat":
-        await evt.reply("Backfilling normal groups is disabled in the bridge config")
-        return
-    output = await portal.forward_backfill(evt.sender, initial=False, override_limit=limit)
-    await evt.reply(output)
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,62 +14,165 @@
 #
 # 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 Any, List, NamedTuple
-import os
-
+from typing import Any, Dict, Optional, Tuple
+from ruamel.yaml import YAML
 from ruamel.yaml.comments import CommentedMap
+import random
+import string

-from mautrix.bridge.config import BaseBridgeConfig
-from mautrix.client import Client
-from mautrix.types import UserID
-from mautrix.util.config import ConfigUpdateHelper, ForbiddenDefault, ForbiddenKey
-
-Permissions = NamedTuple(
-    "Permissions",
-    relaybot=bool,
-    user=bool,
-    puppeting=bool,
-    matrix_puppeting=bool,
-    admin=bool,
-    level=str,
-)
+yaml = YAML()  # type: YAML
+yaml.indent(4)


-class Config(BaseBridgeConfig):
-    @property
-    def forbidden_defaults(self) -> List[ForbiddenDefault]:
-        return [
-            *super().forbidden_defaults,
-            ForbiddenDefault(
-                "appservice.database",
-                "postgres://username:password@hostname/dbname",
-            ),
-            ForbiddenDefault(
-                "appservice.public.external",
-                "https://example.com/public",
-                condition="appservice.public.enabled",
-            ),
-            ForbiddenDefault("bridge.permissions", ForbiddenKey("example.com")),
-            ForbiddenDefault("telegram.api_id", 12345),
-            ForbiddenDefault("telegram.api_hash", "tjyd5yge35lbodk1xwzw2jstp90k55qz"),
-        ]
+class DictWithRecursion:
+    def __init__(self, data: Optional[CommentedMap] = None) -> None:
+        self._data = data or CommentedMap()  # type: CommentedMap

-    def do_update(self, helper: ConfigUpdateHelper) -> None:
-        super().do_update(helper)
-        copy, copy_dict, base = helper
+    @staticmethod
+    def _parse_key(key: str) -> Tuple[str, Optional[str]]:
+        if '.' not in key:
+            return key, None
+        key, next_key = key.split('.', 1)
+        if len(key) > 0 and key[0] == "[":
+            end_index = next_key.index("]")
+            key = key[1:] + "." + next_key[:end_index]
+            next_key = next_key[end_index + 2:] if len(next_key) > end_index + 1 else None
+        return key, next_key
+
+    def _recursive_get(self, data: CommentedMap, key: str, default_value: Any) -> Any:
+        key, next_key = self._parse_key(key)
+        if next_key is not None:
+            next_data = data.get(key, CommentedMap())
+            return self._recursive_get(next_data, next_key, default_value)
+        return data.get(key, default_value)
+
+    def get(self, key: str, default_value: Any, allow_recursion: bool = True) -> Any:
+        if allow_recursion and '.' in key:
+            return self._recursive_get(self._data, key, default_value)
+        return self._data.get(key, default_value)
+
+    def __getitem__(self, key: str) -> Any:
+        return self.get(key, None)
+
+    def __contains__(self, key: str) -> bool:
+        return self[key] is not None
+
+    def _recursive_set(self, data: CommentedMap, key: str, value: Any) -> None:
+        key, next_key = self._parse_key(key)
+        if next_key is not None:
+            if key not in data:
+                data[key] = CommentedMap()
+            next_data = data.get(key, CommentedMap())
+            return self._recursive_set(next_data, next_key, value)
+        data[key] = value
+
+    def set(self, key: str, value: Any, allow_recursion: bool = True) -> None:
+        if allow_recursion and '.' in key:
+            self._recursive_set(self._data, key, value)
+            return
+        self._data[key] = value
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.set(key, value)
+
+    def _recursive_del(self, data: CommentedMap, key: str) -> None:
+        key, next_key = self._parse_key(key)
+        if next_key is not None:
+            if key not in data:
+                return
+            next_data = data[key]
+            return self._recursive_del(next_data, next_key)
+        try:
+            del data[key]
+            del data.ca.items[key]
+        except KeyError:
+            pass
+
+    def delete(self, key: str, allow_recursion: bool = True) -> None:
+        if allow_recursion and '.' in key:
+            self._recursive_del(self._data, key)
+            return
+        try:
+            del self._data[key]
+            del self._data.ca.items[key]
+        except KeyError:
+            pass
+
+    def __delitem__(self, key: str) -> None:
+        self.delete(key)
+
+
+class Config(DictWithRecursion):
+    def __init__(self, path: str, registration_path: str, base_path: str,
+                 overrides: Dict[str, Any] = None) -> None:
+        super().__init__()
+        self.path = path  # type: str
+        self.registration_path = registration_path  # type: str
+        self.base_path = base_path  # type: str
+        self._registration = None  # type: Optional[Dict]
+        self._overrides = overrides or {}  # type: Dict[str, Any]
+
+    def __getitem__(self, key: str) -> Any:
+        try:
+            return self._overrides[f"MAUTRIX_TELEGRAM_{key.replace('.', '_').upper()}"]
+        except KeyError:
+            return super().__getitem__(key)
+
+    def load(self) -> None:
+        with open(self.path, 'r') as stream:
+            self._data = yaml.load(stream)
+
+    def load_base(self) -> Optional[DictWithRecursion]:
+        try:
+            with open(self.base_path, 'r') as stream:
+                return DictWithRecursion(yaml.load(stream))
+        except OSError:
+            pass
+        return None
+
+    def save(self) -> None:
+        with open(self.path, 'w') as stream:
+            yaml.dump(self._data, stream)
+        if self._registration and self.registration_path:
+            with open(self.registration_path, 'w') as stream:
+                yaml.dump(self._registration, stream)
+
+    @staticmethod
+    def _new_token() -> str:
+        return "".join(random.choice(string.ascii_lowercase + string.digits) for _ in range(64))
+
+    def update(self) -> None:
+        base = self.load_base()
+        if not base:
+            return
+
+        def copy(from_path, to_path=None) -> None:
+            if from_path in self:
+                base[to_path or from_path] = self[from_path]
+
+        def copy_dict(from_path, to_path=None, override_existing_map=True) -> None:
+            if from_path in self:
+                to_path = to_path or from_path
+                if override_existing_map or to_path not in base:
+                    base[to_path] = CommentedMap()
+                for key, value in self[from_path].items():
+                    base[to_path][key] = value
+
+        copy("homeserver.address")
+        copy("homeserver.domain")
+        copy("homeserver.verify_ssl")

        if "appservice.protocol" in self and "appservice.address" not in self:
-            protocol, hostname, port = (
-                self["appservice.protocol"],
-                self["appservice.hostname"],
-                self["appservice.port"],
-            )
+            protocol, hostname, port = (self["appservice.protocol"], self["appservice.hostname"],
+                                        self["appservice.port"])
            base["appservice.address"] = f"{protocol}://{hostname}:{port}"
-        if "appservice.debug" in self and "logging" not in self:
-            level = "DEBUG" if self["appservice.debug"] else "INFO"
-            base["logging.root.level"] = level
-            base["logging.loggers.mau.level"] = level
-            base["logging.loggers.telethon.level"] = level
+        else:
+            copy("appservice.address")
+        copy("appservice.hostname")
+        copy("appservice.port")
+        copy("appservice.max_body_size")
+
+        copy("appservice.database")

        copy("appservice.public.enabled")
        copy("appservice.public.prefix")
@@ -76,20 +180,19 @@ class Config(BaseBridgeConfig):

        copy("appservice.provisioning.enabled")
        copy("appservice.provisioning.prefix")
-        if base["appservice.provisioning.prefix"].endswith("/v1"):
-            base["appservice.provisioning.prefix"] = base["appservice.provisioning.prefix"][
-                : -len("/v1")
-            ]
        copy("appservice.provisioning.shared_secret")
        if base["appservice.provisioning.shared_secret"] == "generate":
            base["appservice.provisioning.shared_secret"] = self._new_token()

-        if "pool_size" in base["appservice.database_opts"]:
-            pool_size = base["appservice.database_opts"].pop("pool_size")
-            base["appservice.database_opts.min_size"] = pool_size
-            base["appservice.database_opts.max_size"] = pool_size
-        if "pool_pre_ping" in base["appservice.database_opts"]:
-            del base["appservice.database_opts.pool_pre_ping"]
+        copy("appservice.id")
+        copy("appservice.bot_username")
+        copy("appservice.bot_displayname")
+        copy("appservice.bot_avatar")
+
+        copy("appservice.community_id")
+
+        copy("appservice.as_token")
+        copy("appservice.hs_token")

        copy("metrics.enabled")
        copy("metrics.listen_port")
@@ -99,123 +202,39 @@ class Config(BaseBridgeConfig):
        copy("bridge.displayname_template")

        copy("bridge.displayname_preference")
-        copy("bridge.displayname_max_length")
-        copy("bridge.allow_avatar_remove")
-        copy("bridge.allow_contact_info")

        copy("bridge.max_initial_member_sync")
-        copy("bridge.max_member_count")
        copy("bridge.sync_channel_members")
        copy("bridge.skip_deleted_members")
        copy("bridge.startup_sync")
-        if "bridge.sync_dialog_limit" in self:
-            base["bridge.sync_create_limit"] = self["bridge.sync_dialog_limit"]
-            base["bridge.sync_update_limit"] = self["bridge.sync_dialog_limit"]
-        else:
-            copy("bridge.sync_update_limit")
-            copy("bridge.sync_create_limit")
-        copy("bridge.sync_deferred_create_all")
-        copy("bridge.sync_direct_chats")
+        copy("bridge.sync_dialog_limit")
        copy("bridge.max_telegram_delete")
        copy("bridge.sync_matrix_state")
        copy("bridge.allow_matrix_login")
+        copy("bridge.plaintext_highlights")
        copy("bridge.public_portals")
+        copy("bridge.catch_up")
        copy("bridge.sync_with_custom_puppets")
-        copy("bridge.sync_direct_chat_list")
-        copy("bridge.double_puppet_server_map")
-        copy("bridge.double_puppet_allow_discovery")
-        copy("bridge.create_group_on_invite")
-        if "bridge.login_shared_secret" in self:
-            base["bridge.login_shared_secret_map"] = {
-                base["homeserver.domain"]: self["bridge.login_shared_secret"]
-            }
-        else:
-            copy("bridge.login_shared_secret_map")
        copy("bridge.telegram_link_preview")
-        copy("bridge.invite_link_resolve")
-        copy("bridge.caption_in_message")
+        copy("bridge.inline_images")
        copy("bridge.image_as_file_size")
-        copy("bridge.image_as_file_pixels")
-        copy("bridge.parallel_file_transfer")
-        copy("bridge.federate_rooms")
-        copy("bridge.always_custom_emoji_reaction")
-        copy("bridge.animated_sticker.target")
-        copy("bridge.animated_sticker.convert_from_webm")
-        copy("bridge.animated_sticker.args.width")
-        copy("bridge.animated_sticker.args.height")
-        copy("bridge.animated_sticker.args.fps")
-        copy("bridge.animated_emoji.target")
-        copy("bridge.animated_emoji.args.width")
-        copy("bridge.animated_emoji.args.height")
-        copy("bridge.animated_emoji.args.fps")
-        if isinstance(self.get("bridge.private_chat_portal_meta", "default"), bool):
-            base["bridge.private_chat_portal_meta"] = (
-                "always" if self["bridge.private_chat_portal_meta"] else "default"
-            )
-        else:
-            copy("bridge.private_chat_portal_meta")
-            if base["bridge.private_chat_portal_meta"] not in ("default", "always", "never"):
-                base["bridge.private_chat_portal_meta"] = "default"
-        copy("bridge.disable_reply_fallbacks")
-        copy("bridge.cross_room_replies")
-        copy("bridge.delivery_receipts")
-        copy("bridge.delivery_error_reports")
-        copy("bridge.incoming_bridge_error_reports")
-        copy("bridge.message_status_events")
-        copy("bridge.resend_bridge_info")
-        copy("bridge.mute_bridging")
-        copy("bridge.pinned_tag")
-        copy("bridge.archive_tag")
-        copy("bridge.tag_only_on_create")
-        copy("bridge.bridge_matrix_leave")
-        copy("bridge.kick_on_logout")
-        copy("bridge.always_read_joined_telegram_notice")
-        copy("bridge.backfill.enable")
-        copy("bridge.backfill.normal_groups")
-        copy("bridge.backfill.unread_hours_threshold")
-        if "bridge.backfill.forward" in self:
-            initial_limit = self.get("bridge.backfill.forward.initial_limit", 10)
-            sync_limit = self.get("bridge.backfill.forward.sync_limit", 100)
-            base["bridge.backfill.forward_limits.initial.user"] = initial_limit
-            base["bridge.backfill.forward_limits.initial.normal_group"] = initial_limit
-            base["bridge.backfill.forward_limits.initial.supergroup"] = initial_limit
-            base["bridge.backfill.forward_limits.initial.channel"] = initial_limit
-            base["bridge.backfill.forward_limits.sync.user"] = sync_limit
-            base["bridge.backfill.forward_limits.sync.normal_group"] = sync_limit
-            base["bridge.backfill.forward_limits.sync.supergroup"] = sync_limit
-            base["bridge.backfill.forward_limits.sync.channel"] = sync_limit
-        else:
-            copy("bridge.backfill.forward_limits.initial.user")
-            copy("bridge.backfill.forward_limits.initial.normal_group")
-            copy("bridge.backfill.forward_limits.initial.supergroup")
-            copy("bridge.backfill.forward_limits.initial.channel")
-            copy("bridge.backfill.forward_limits.sync.user")
-            copy("bridge.backfill.forward_limits.sync.normal_group")
-            copy("bridge.backfill.forward_limits.sync.supergroup")
-            copy("bridge.backfill.forward_limits.sync.channel")
-        copy("bridge.backfill.forward_timeout")
-        copy("bridge.backfill.incremental.messages_per_batch")
-        copy("bridge.backfill.incremental.post_batch_delay")
-        copy("bridge.backfill.incremental.max_batches.user")
-        copy("bridge.backfill.incremental.max_batches.normal_group")
-        copy("bridge.backfill.incremental.max_batches.supergroup")
-        copy("bridge.backfill.incremental.max_batches.channel")
-
-        copy("bridge.initial_power_level_overrides.group")
-        copy("bridge.initial_power_level_overrides.user")
+        copy("bridge.max_document_size")

        copy("bridge.bot_messages_as_notices")
        if isinstance(self["bridge.bridge_notices"], bool):
-            base["bridge.bridge_notices"]["default"] = self["bridge.bridge_notices"]
+            base["bridge.bridge_notices"] = {
+                "default": self["bridge.bridge_notices"],
+                "exceptions": ["@importantbot:example.com"],
+            }
        else:
-            copy("bridge.bridge_notices.default")
-            copy("bridge.bridge_notices.exceptions")
+            copy("bridge.bridge_notices")
+
+        copy("bridge.deduplication.pre_db_check")
+        copy("bridge.deduplication.cache_queue_length")

        if "bridge.message_formats.m_text" in self:
            del self["bridge.message_formats"]
        copy_dict("bridge.message_formats", override_existing_map=False)
-        copy("bridge.emote_format")
-        copy("bridge.relay_user_distinguishers")

        copy("bridge.state_event_formats.join")
        copy("bridge.state_event_formats.leave")
@@ -223,15 +242,12 @@ class Config(BaseBridgeConfig):

        copy("bridge.filter.mode")
        copy("bridge.filter.list")
-        copy("bridge.filter.users")

        copy("bridge.command_prefix")

-        migrate_permissions = (
-            "bridge.permissions" not in self
-            or "bridge.whitelist" in self
-            or "bridge.admins" in self
-        )
+        migrate_permissions = ("bridge.permissions" not in self
+                               or "bridge.whitelist" in self
+                               or "bridge.admins" in self)
        if migrate_permissions:
            permissions = self["bridge.permissions"] or CommentedMap()
            for entry in self["bridge.whitelist"] or []:
@@ -240,16 +256,11 @@ class Config(BaseBridgeConfig):
                permissions[entry] = "admin"
            base["bridge.permissions"] = permissions
        else:
-            copy_dict("bridge.permissions", override_existing_map=True)
+            copy_dict("bridge.permissions")

        if "bridge.relaybot" not in self:
            copy("bridge.authless_relaybot_portals", "bridge.relaybot.authless_portals")
        else:
-            copy("bridge.relaybot.private_chat.invite")
-            copy("bridge.relaybot.private_chat.state_changes")
-            copy("bridge.relaybot.private_chat.message")
-            copy("bridge.relaybot.group_chat_invite")
-            copy("bridge.relaybot.ignore_unbridged_group_chat")
            copy("bridge.relaybot.authless_portals")
            copy("bridge.relaybot.whitelist_group_admins")
            copy("bridge.relaybot.whitelist")
@@ -259,16 +270,11 @@ class Config(BaseBridgeConfig):
        copy("telegram.api_hash")
        copy("telegram.bot_token")

-        copy("telegram.catch_up")
-        copy("telegram.sequential_updates")
-        copy("telegram.exit_on_update_error")
-
        copy("telegram.connection.timeout")
        copy("telegram.connection.retries")
        copy("telegram.connection.retry_delay")
        copy("telegram.connection.flood_sleep_threshold")
        copy("telegram.connection.request_retries")
-        copy("telegram.connection.use_ipv6")

        copy("telegram.device_info.device_model")
        copy("telegram.device_info.system_version")
@@ -288,22 +294,66 @@ class Config(BaseBridgeConfig):
        copy("telegram.proxy.username")
        copy("telegram.proxy.password")

-    def _get_permissions(self, key: str) -> Permissions:
+        if "appservice.debug" in self and "logging" not in self:
+            level = "DEBUG" if self["appservice.debug"] else "INFO"
+            base["logging.root.level"] = level
+            base["logging.loggers.mau.level"] = level
+            base["logging.loggers.telethon.level"] = level
+        else:
+            copy("logging")
+
+        self._data = base._data
+        self.save()
+
+    def _get_permissions(self, key: str) -> Tuple[bool, bool, bool, bool, bool, bool]:
        level = self["bridge.permissions"].get(key, "")
        admin = level == "admin"
        matrix_puppeting = level == "full" or admin
        puppeting = level == "puppeting" or matrix_puppeting
        user = level == "user" or puppeting
        relaybot = level == "relaybot" or user
-        return Permissions(relaybot, user, puppeting, matrix_puppeting, admin, level)
+        return relaybot, user, puppeting, matrix_puppeting, admin, level

-    def get_permissions(self, mxid: UserID) -> Permissions:
-        permissions = self["bridge.permissions"]
+    def get_permissions(self, mxid: str) -> Tuple[bool, bool, bool, bool, bool, bool]:
+        permissions = self["bridge.permissions"] or {}
        if mxid in permissions:
            return self._get_permissions(mxid)

-        _, homeserver = Client.parse_user_id(mxid)
+        homeserver = mxid[mxid.index(":") + 1:]
        if homeserver in permissions:
            return self._get_permissions(homeserver)

        return self._get_permissions("*")
+
+    def generate_registration(self) -> None:
+        homeserver = self["homeserver.domain"]
+
+        username_format = self.get("bridge.username_template", "telegram_{userid}") \
+            .format(userid=".+")
+        alias_format = self.get("bridge.alias_template", "telegram_{groupname}") \
+            .format(groupname=".+")
+
+        self.set("appservice.as_token", self._new_token())
+        self.set("appservice.hs_token", self._new_token())
+
+        self._registration = {
+            "id": self["appservice.id"] or "telegram",
+            "as_token": self["appservice.as_token"],
+            "hs_token": self["appservice.hs_token"],
+            "namespaces": {
+                "users": [{
+                    "exclusive": True,
+                    "regex": f"@{username_format}:{homeserver}"
+                }],
+                "aliases": [{
+                    "exclusive": True,
+                    "regex": f"#{alias_format}:{homeserver}"
+                }]
+            },
+            "url": self["appservice.address"],
+            "sender_localpart": self["appservice.bot_username"],
+            "rate_limited": False
+        }
+        if self["appservice.community_id"]:
+            self._registration["namespaces"]["users"][0]["group_id"] \
+                = self["appservice.community_id"]
@@ -0,0 +1,45 @@
+# -*- coding: future_fstrings -*-
+# 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 Optional, Tuple, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import asyncio
+
+    from alchemysession import AlchemySessionContainer
+    from mautrix_appservice import AppService
+
+    from .web import PublicBridgeWebsite, ProvisioningAPI
+    from .config import Config
+    from .bot import Bot
+    from .matrix import MatrixHandler
+
+
+class Context:
+    def __init__(self, az: 'AppService', config: 'Config', loop: 'asyncio.AbstractEventLoop',
+                 session_container: 'AlchemySessionContainer', bot: Optional['Bot']) -> None:
+        self.az = az  # type: AppService
+        self.config = config  # type: Config
+        self.loop = loop  # type: asyncio.AbstractEventLoop
+        self.bot = bot  # type: Optional[Bot]
+        self.mx = None  # type: Optional[MatrixHandler]
+        self.session_container = session_container  # type: AlchemySessionContainer
+        self.public_website = None  # type: Optional[PublicBridgeWebsite]
+        self.provisioning_api = None  # type: Optional[ProvisioningAPI]
+
+    @property
+    def core(self) -> Tuple['AppService', 'Config', 'asyncio.AbstractEventLoop', Optional['Bot']]:
+        return self.az, self.config, self.loop, self.bot
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,48 +14,20 @@
 #
 # 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 mautrix.util.async_db import Database
-
-from .backfill_queue import Backfill, BackfillType
+from .base import Base
 from .bot_chat import BotChat
-from .disappearing_message import DisappearingMessage
 from .message import Message
 from .portal import Portal
 from .puppet import Puppet
-from .reaction import Reaction
+from .room_state import RoomState
 from .telegram_file import TelegramFile
-from .telethon_session import PgSession
-from .upgrade import upgrade_table
-from .user import User
+from .user import User, UserPortal, Contact
+from .user_profile import UserProfile


-def init(db: Database) -> None:
-    for table in (
-        Portal,
-        Message,
-        Reaction,
-        User,
-        Puppet,
-        TelegramFile,
-        BotChat,
-        PgSession,
-        DisappearingMessage,
-        Backfill,
-    ):
-        table.db = db
-
-
-__all__ = [
-    "upgrade_table",
-    "init",
-    "Portal",
-    "Message",
-    "Reaction",
-    "User",
-    "Puppet",
-    "TelegramFile",
-    "BotChat",
-    "PgSession",
-    "DisappearingMessage",
-    "Backfill",
-]
+def init(db_engine) -> None:
+    for table in (Portal, Message, User, Contact, UserPortal, Puppet, TelegramFile, UserProfile,
+                  RoomState, BotChat):
+        table.db = db_engine
+        table.t = table.__table__
+        table.c = table.t.c
@@ -1,235 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 Tulir Asokan, Sumner Evans
-#
-# 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 __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, ClassVar
-from datetime import datetime, timedelta
-from enum import Enum
-import json
-
-from asyncpg import Record
-from attr import dataclass
-
-from mautrix.types import UserID
-from mautrix.util.async_db import Connection, Database
-
-from ..types import TelegramID
-
-fake_db = Database.create("") if TYPE_CHECKING else None
-
-
-class BackfillType(Enum):
-    HISTORICAL = "historical"
-    SYNC_DIALOG = "sync_dialog"
-
-
-@dataclass
-class Backfill:
-    db: ClassVar[Database] = fake_db
-
-    queue_id: int | None
-    user_mxid: UserID
-    priority: int
-    type: BackfillType
-    portal_tgid: TelegramID
-    portal_tg_receiver: TelegramID
-    anchor_msg_id: TelegramID | None
-    extra_data: dict[str, Any]
-    messages_per_batch: int
-    post_batch_delay: int
-    max_batches: int
-    dispatch_time: datetime | None
-    completed_at: datetime | None
-    cooldown_timeout: datetime | None
-
-    @staticmethod
-    def new(
-        user_mxid: UserID,
-        priority: int,
-        type: BackfillType,
-        portal_tgid: TelegramID,
-        portal_tg_receiver: TelegramID,
-        messages_per_batch: int,
-        anchor_msg_id: TelegramID | None = None,
-        extra_data: dict[str, Any] | None = None,
-        post_batch_delay: int = 0,
-        max_batches: int = -1,
-    ) -> "Backfill":
-        return Backfill(
-            queue_id=None,
-            user_mxid=user_mxid,
-            priority=priority,
-            type=type,
-            portal_tgid=portal_tgid,
-            portal_tg_receiver=portal_tg_receiver,
-            anchor_msg_id=anchor_msg_id,
-            extra_data=extra_data or {},
-            messages_per_batch=messages_per_batch,
-            post_batch_delay=post_batch_delay,
-            max_batches=max_batches,
-            dispatch_time=None,
-            completed_at=None,
-            cooldown_timeout=None,
-        )
-
-    @classmethod
-    def _from_row(cls, row: Record | None) -> Backfill | None:
-        if row is None:
-            return None
-        data = {**row}
-        type = BackfillType(data.pop("type"))
-        extra_data = json.loads(data.pop("extra_data", None) or "{}")
-        return cls(**data, type=type, extra_data=extra_data)
-
-    columns = [
-        "user_mxid",
-        "priority",
-        "type",
-        "portal_tgid",
-        "portal_tg_receiver",
-        "anchor_msg_id",
-        "extra_data",
-        "messages_per_batch",
-        "post_batch_delay",
-        "max_batches",
-        "dispatch_time",
-        "completed_at",
-        "cooldown_timeout",
-    ]
-    columns_str = ",".join(columns)
-
-    @classmethod
-    async def get_next(cls, user_mxid: UserID) -> Backfill | None:
-        q = f"""
-        SELECT queue_id, {cls.columns_str}
-        FROM backfill_queue
-        WHERE user_mxid=$1
-            AND (
-                dispatch_time IS NULL
-                OR (
-                    dispatch_time < $2
-                    AND completed_at IS NULL
-                )
-            )
-            AND (
-                cooldown_timeout IS NULL
-                OR cooldown_timeout < current_timestamp
-            )
-        ORDER BY priority, queue_id
-        LIMIT 1
-        """
-        return cls._from_row(
-            await cls.db.fetchrow(q, user_mxid, datetime.now() - timedelta(minutes=15))
-        )
-
-    @classmethod
-    async def delete_existing(
-        cls,
-        user_mxid: UserID,
-        portal_tgid: int,
-        portal_tg_receiver: int,
-        type: BackfillType,
-    ) -> Backfill | None:
-        q = f"""
-        WITH deleted_entries AS (
-            DELETE FROM backfill_queue
-            WHERE user_mxid=$1
-              AND portal_tgid=$2
-              AND portal_tg_receiver=$3
-              AND type=$4
-              AND dispatch_time IS NULL
-              AND completed_at IS NULL
-            RETURNING 1
-        )
-        WITH dispatched_entries AS (
-            SELECT 1 FROM backfill_queue
-            WHERE user_mxid=$1
-              AND portal_tgid=$2
-              AND portal_tg_receiver=$3
-              AND type=$4
-              AND dispatch_time IS NOT NULL
-              AND completed_at IS NULL
-        )
-        """
-        return cls._from_row(
-            await cls.db.fetchrow(q, user_mxid, portal_tgid, portal_tg_receiver, type.value)
-        )
-
-    @classmethod
-    async def delete_all(cls, user_mxid: UserID, conn: Connection | None = None) -> None:
-        await (conn or cls.db).execute("DELETE FROM backfill_queue WHERE user_mxid=$1", user_mxid)
-
-    @classmethod
-    async def delete_for_portal(cls, tgid: int, tg_receiver: int) -> None:
-        q = "DELETE FROM backfill_queue WHERE portal_tgid=$1 AND portal_tg_receiver=$2"
-        await cls.db.execute(q, tgid, tg_receiver)
-
-    async def insert(self) -> list[Backfill]:
-        delete_q = f"""
-        DELETE FROM backfill_queue
-        WHERE user_mxid=$1
-          AND portal_tgid=$2
-          AND portal_tg_receiver=$3
-          AND type=$4
-          AND dispatch_time IS NULL
-          AND completed_at IS NULL
-        RETURNING queue_id, {self.columns_str}
-        """
-        q = f"""
-        INSERT INTO backfill_queue ({self.columns_str})
-        VALUES ({','.join(f'${i+1}' for i in range(len(self.columns)))})
-        RETURNING queue_id
-        """
-        async with self.db.acquire() as conn, conn.transaction():
-            deleted_rows = await conn.fetch(
-                delete_q,
-                self.user_mxid,
-                self.portal_tgid,
-                self.portal_tg_receiver,
-                self.type.value,
-            )
-            self.queue_id = await conn.fetchval(
-                q,
-                self.user_mxid,
-                self.priority,
-                self.type.value,
-                self.portal_tgid,
-                self.portal_tg_receiver,
-                self.anchor_msg_id,
-                json.dumps(self.extra_data) if self.extra_data else None,
-                self.messages_per_batch,
-                self.post_batch_delay,
-                self.max_batches,
-                self.dispatch_time,
-                self.completed_at,
-                self.cooldown_timeout,
-            )
-        return [self._from_row(row) for row in deleted_rows]
-
-    async def mark_dispatched(self) -> None:
-        q = "UPDATE backfill_queue SET dispatch_time=$1 WHERE queue_id=$2"
-        await self.db.execute(q, datetime.now(), self.queue_id)
-
-    async def mark_done(self) -> None:
-        q = "UPDATE backfill_queue SET completed_at=$1 WHERE queue_id=$2"
-        await self.db.execute(q, datetime.now(), self.queue_id)
-
-    async def set_cooldown_timeout(self, timeout: int) -> None:
-        """
-        Set the backfill request to cooldown for ``timeout`` seconds.
-        """
-        q = "UPDATE backfill_queue SET cooldown_timeout=$1 WHERE queue_id=$2"
-        await self.db.execute(q, datetime.now() + timedelta(seconds=timeout), self.queue_id)
@@ -0,0 +1,58 @@
+# -*- coding: future_fstrings -*-
+# 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 abc import abstractmethod
+
+from sqlalchemy import Table
+from sqlalchemy.engine.base import Engine
+from sqlalchemy.engine.result import RowProxy
+from sqlalchemy.sql.base import ImmutableColumnCollection
+from sqlalchemy.ext.declarative import declarative_base
+
+
+class BaseBase:
+    db = None  # type: Engine
+    t = None  # type: Table
+    __table__ = None  # type: Table
+    c = None  # type: ImmutableColumnCollection
+
+    @classmethod
+    @abstractmethod
+    def _one_or_none(cls, rows: RowProxy):
+        pass
+
+    @classmethod
+    def _select_one_or_none(cls, *args):
+        return cls._one_or_none(cls.db.execute(cls.t.select().where(*args)))
+
+    @property
+    @abstractmethod
+    def _edit_identity(self):
+        pass
+
+    def update(self, **values) -> None:
+        with self.db.begin() as conn:
+            conn.execute(self.t.update()
+                         .where(self._edit_identity)
+                         .values(**values))
+        for key, value in values.items():
+            setattr(self, key, value)
+
+    def delete(self) -> None:
+        with self.db.begin() as conn:
+            conn.execute(self.t.delete().where(self._edit_identity))
+
+Base = declarative_base(cls=BaseBase)
@@ -0,0 +1,26 @@
+from abc import abstractmethod
+
+from sqlalchemy import Table
+from sqlalchemy.engine.base import Engine
+from sqlalchemy.engine.result import RowProxy
+from sqlalchemy.sql.base import ImmutableColumnCollection
+from sqlalchemy.ext.declarative import declarative_base
+
+class Base(declarative_base):
+	db: Engine
+	t: Table
+	__table__: Table
+	c: ImmutableColumnCollection
+
+    @classmethod
+    @abstractmethod
+    def _one_or_none(cls, rows: RowProxy): ...
+
+	@classmethod
+	def _select_one_or_none(cls, *args): ...
+
+    def _edit_identity(self): ...
+
+    def update(self, **values) -> None: ...
+
+    def delete(self) -> None: ...
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,43 +14,32 @@
 #
 # 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 __future__ import annotations
+from typing import Iterable

-from typing import TYPE_CHECKING, ClassVar
-
-from asyncpg import Record
-from attr import dataclass
-
-from mautrix.util.async_db import Database
+from sqlalchemy import Column, Integer, String

 from ..types import TelegramID
-
-fake_db = Database.create("") if TYPE_CHECKING else None
+from .base import Base


 # Fucking Telegram not telling bots what chats they are in 3:<
-@dataclass
-class BotChat:
-    db: ClassVar[Database] = fake_db
-
-    id: TelegramID
-    type: str
+class BotChat(Base):
+    __tablename__ = "bot_chat"
+    id = Column(Integer, primary_key=True)  # type: TelegramID
+    type = Column(String, nullable=False)

    @classmethod
-    def _from_row(cls, row: Record | None) -> BotChat | None:
-        if row is None:
-            return None
-        return cls(**row)
+    def delete(cls, chat_id: TelegramID) -> None:
+        with cls.db.begin() as conn:
+            conn.execute(cls.t.delete().where(cls.c.id == chat_id))

    @classmethod
-    async def delete_by_id(cls, chat_id: TelegramID) -> None:
-        await cls.db.execute("DELETE FROM bot_chat WHERE id=$1", chat_id)
+    def all(cls) -> Iterable['BotChat']:
+        rows = cls.db.execute(cls.t.select())
+        for row in rows:
+            chat_id, chat_type = row
+            yield cls(id=chat_id, type=chat_type)

-    @classmethod
-    async def all(cls) -> list[BotChat]:
-        rows = await cls.db.fetch("SELECT id, type FROM bot_chat")
-        return [cls._from_row(row) for row in rows]
-
-    async def insert(self) -> None:
-        q = "INSERT INTO bot_chat (id, type) VALUES ($1, $2)"
-        await self.db.execute(q, self.id, self.type)
+    def insert(self) -> None:
+        with self.db.begin() as conn:
+            conn.execute(self.t.insert().values(id=self.id, type=self.type))
@@ -1,78 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Sumner Evans
-#
-# 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 __future__ import annotations
-
-from typing import TYPE_CHECKING, ClassVar
-
-import asyncpg
-
-from mautrix.bridge import AbstractDisappearingMessage
-from mautrix.types import EventID, RoomID
-from mautrix.util.async_db import Database
-
-fake_db = Database.create("") if TYPE_CHECKING else None
-
-
-class DisappearingMessage(AbstractDisappearingMessage):
-    db: ClassVar[Database] = fake_db
-
-    async def insert(self) -> None:
-        q = """
-            INSERT INTO disappearing_message (room_id, event_id, expiration_seconds, expiration_ts)
-            VALUES ($1, $2, $3, $4)
-        """
-        await self.db.execute(
-            q, self.room_id, self.event_id, self.expiration_seconds, self.expiration_ts
-        )
-
-    async def update(self) -> None:
-        q = "UPDATE disappearing_message SET expiration_ts=$3 WHERE room_id=$1 AND event_id=$2"
-        await self.db.execute(q, self.room_id, self.event_id, self.expiration_ts)
-
-    async def delete(self) -> None:
-        q = "DELETE from disappearing_message WHERE room_id=$1 AND event_id=$2"
-        await self.db.execute(q, self.room_id, self.event_id)
-
-    @classmethod
-    def _from_row(cls, row: asyncpg.Record) -> DisappearingMessage:
-        return cls(**row)
-
-    @classmethod
-    async def get(cls, room_id: RoomID, event_id: EventID) -> DisappearingMessage | None:
-        q = """
-            SELECT room_id, event_id, expiration_seconds, expiration_ts FROM disappearing_message
-            WHERE room_id=$1 AND mxid=$2
-        """
-        try:
-            return cls._from_row(await cls.db.fetchrow(q, room_id, event_id))
-        except Exception:
-            return None
-
-    @classmethod
-    async def get_all_scheduled(cls) -> list[DisappearingMessage]:
-        q = """
-            SELECT room_id, event_id, expiration_seconds, expiration_ts FROM disappearing_message
-            WHERE expiration_ts IS NOT NULL
-        """
-        return [cls._from_row(r) for r in await cls.db.fetch(q)]
-
-    @classmethod
-    async def get_unscheduled_for_room(cls, room_id: RoomID) -> list[DisappearingMessage]:
-        q = """
-            SELECT room_id, event_id, expiration_seconds, expiration_ts FROM disappearing_message
-            WHERE room_id = $1 AND expiration_ts IS NULL
-        """
-        return [cls._from_row(r) for r in await cls.db.fetch(q, room_id)]
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,214 +14,100 @@
 #
 # 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 __future__ import annotations
+from sqlalchemy import Column, UniqueConstraint, Integer, String, and_, func, desc, select
+from sqlalchemy.engine.result import RowProxy
+from typing import Optional, List

-from typing import TYPE_CHECKING, ClassVar
-
-from asyncpg import Record
-from attr import dataclass
-import attr
-
-from mautrix.types import EventID, RoomID, UserID
-from mautrix.util.async_db import Database, Scheme
-
-from ..types import TelegramID
-
-fake_db = Database.create("") if TYPE_CHECKING else None
+from ..types import MatrixRoomID, MatrixEventID, TelegramID
+from .base import Base


-@dataclass
-class Message:
-    db: ClassVar[Database] = fake_db
+class Message(Base):
+    __tablename__ = "message"

-    mxid: EventID
-    mx_room: RoomID
-    tgid: TelegramID
-    tg_space: TelegramID
-    edit_index: int
-    redacted: bool = False
-    content_hash: bytes | None = None
-    sender_mxid: UserID | None = None
-    sender: TelegramID | None = None
+    mxid = Column(String)  # type: MatrixEventID
+    mx_room = Column(String)  # type: MatrixRoomID
+    tgid = Column(Integer, primary_key=True)  # type: TelegramID
+    tg_space = Column(Integer, primary_key=True)  # type: TelegramID
+    edit_index = Column(Integer, primary_key=True)  # type: int
+
+    __table_args__ = (UniqueConstraint("mxid", "mx_room", "tg_space", name="_mx_id_room"),)

    @classmethod
-    def _from_row(cls, row: Record | None) -> Message | None:
-        if row is None:
+    def _one_or_none(cls, rows: RowProxy) -> Optional['Message']:
+        try:
+            mxid, mx_room, tgid, tg_space, edit_index = next(rows)
+            return cls(mxid=mxid, mx_room=mx_room, tgid=tgid, tg_space=tg_space,
+                       edit_index=edit_index)
+        except StopIteration:
            return None
-        return cls(**row)

-    columns: ClassVar[str] = ", ".join(
-        (
-            "mxid",
-            "mx_room",
-            "tgid",
-            "tg_space",
-            "edit_index",
-            "redacted",
-            "content_hash",
-            "sender_mxid",
-            "sender",
-        )
-    )
+    @staticmethod
+    def _all(rows: RowProxy) -> List['Message']:
+        return [Message(mxid=row[0], mx_room=row[1], tgid=row[2], tg_space=row[3],
+                        edit_index=row[4])
+                for row in rows]

    @classmethod
-    async def get_all_by_tgid(cls, tgid: TelegramID, tg_space: TelegramID) -> list[Message]:
-        q = f"SELECT {cls.columns} FROM message WHERE tgid=$1 AND tg_space=$2"
-        rows = await cls.db.fetch(q, tgid, tg_space)
-        return [cls._from_row(row) for row in rows]
+    def get_all_by_tgid(cls, tgid: TelegramID, tg_space: TelegramID) -> List['Message']:
+        return cls._all(cls.db.execute(cls.t.select().where(and_(cls.c.tgid == tgid,
+                                                                 cls.c.tg_space == tg_space))))

    @classmethod
-    async def get_one_by_tgid(
-        cls, tgid: TelegramID, tg_space: TelegramID, edit_index: int = 0
-    ) -> Message | None:
+    def get_one_by_tgid(cls, tgid: TelegramID, tg_space: TelegramID, edit_index: int = 0
+                        ) -> Optional['Message']:
+        query = cls.t.select()
        if edit_index < 0:
-            q = (
-                f"SELECT {cls.columns} FROM message WHERE tgid=$1 AND tg_space=$2 "
-                f"ORDER BY edit_index DESC LIMIT 1 OFFSET {-edit_index - 1}"
-            )
-            row = await cls.db.fetchrow(q, tgid, tg_space)
+            query = (query
+                     .where(and_(cls.c.tgid == tgid, cls.c.tg_space == tg_space))
+                     .order_by(desc(cls.c.edit_index))
+                     .limit(1)
+                     .offset(-edit_index - 1))
        else:
-            q = (
-                f"SELECT {cls.columns} FROM message"
-                " WHERE tgid=$1 AND tg_space=$2 AND edit_index=$3"
-            )
-            row = await cls.db.fetchrow(q, tgid, tg_space, edit_index)
-        return cls._from_row(row)
+            query = query.where(and_(cls.c.tgid == tgid, cls.c.tg_space == tg_space,
+                                     cls.c.edit_index == edit_index))
+        return cls._one_or_none(cls.db.execute(query))

    @classmethod
-    async def get_first_by_tgids(
-        cls, tgids: list[TelegramID], tg_space: TelegramID
-    ) -> list[Message]:
-        if cls.db.scheme in (Scheme.POSTGRES, Scheme.COCKROACH):
-            q = (
-                f"SELECT {cls.columns} FROM message"
-                " WHERE tgid=ANY($1) AND tg_space=$2 AND edit_index=0"
-            )
-            rows = await cls.db.fetch(q, tgids, tg_space)
-        else:
-            tgid_placeholders = ("?," * len(tgids)).rstrip(",")
-            q = (
-                f"SELECT {cls.columns} FROM message "
-                f"WHERE tg_space=? AND edit_index=0 AND tgid IN ({tgid_placeholders})"
-            )
-            rows = await cls.db.fetch(q, tg_space, *tgids)
-        return [cls._from_row(row) for row in rows]
+    def count_spaces_by_mxid(cls, mxid: MatrixEventID, mx_room: MatrixRoomID) -> int:
+        rows = cls.db.execute(select([func.count(cls.c.tg_space)])
+                              .where(and_(cls.c.mxid == mxid, cls.c.mx_room == mx_room)))
+        try:
+            count, = next(rows)
+            return count
+        except StopIteration:
+            return 0

    @classmethod
-    async def count_spaces_by_mxid(cls, mxid: EventID, mx_room: RoomID) -> int:
-        return (
-            await cls.db.fetchval(
-                "SELECT COUNT(tg_space) FROM message WHERE mxid=$1 AND mx_room=$2", mxid, mx_room
-            )
-            or 0
-        )
+    def get_by_mxid(cls, mxid: MatrixEventID, mx_room: MatrixRoomID, tg_space: TelegramID
+                    ) -> Optional['Message']:
+        return cls._select_one_or_none(and_(cls.c.mxid == mxid,
+                                            cls.c.mx_room == mx_room,
+                                            cls.c.tg_space == tg_space))

    @classmethod
-    async def find_last(cls, mx_room: RoomID, tg_space: TelegramID) -> Message | None:
-        q = (
-            f"SELECT {cls.columns} FROM message WHERE mx_room=$1 AND tg_space=$2 "
-            f"ORDER BY tgid DESC LIMIT 1"
-        )
-        return cls._from_row(await cls.db.fetchrow(q, mx_room, tg_space))
+    def update_by_tgid(cls, s_tgid: TelegramID, s_tg_space: TelegramID, s_edit_index: int,
+                       **values) -> None:
+        with cls.db.begin() as conn:
+            conn.execute(cls.t.update()
+                         .where(and_(cls.c.tgid == s_tgid, cls.c.tg_space == s_tg_space,
+                                     cls.c.edit_index == s_edit_index))
+                         .values(**values))

    @classmethod
-    async def find_first(cls, mx_room: RoomID, tg_space: TelegramID) -> Message | None:
-        q = (
-            f"SELECT {cls.columns} FROM message WHERE mx_room=$1 AND tg_space=$2 "
-            f"ORDER BY tgid ASC LIMIT 1"
-        )
-        return cls._from_row(await cls.db.fetchrow(q, mx_room, tg_space))
-
-    @classmethod
-    async def delete_all(cls, mx_room: RoomID) -> None:
-        await cls.db.execute("DELETE FROM message WHERE mx_room=$1", mx_room)
-
-    @classmethod
-    async def get_by_mxid(
-        cls, mxid: EventID, mx_room: RoomID, tg_space: TelegramID
-    ) -> Message | None:
-        q = f"SELECT {cls.columns} FROM message WHERE mxid=$1 AND mx_room=$2 AND tg_space=$3"
-        return cls._from_row(await cls.db.fetchrow(q, mxid, mx_room, tg_space))
-
-    @classmethod
-    async def get_by_mxids(
-        cls, mxids: list[EventID], mx_room: RoomID, tg_space: TelegramID
-    ) -> list[Message]:
-        if cls.db.scheme in (Scheme.POSTGRES, Scheme.COCKROACH):
-            q = (
-                f"SELECT {cls.columns} FROM message"
-                " WHERE mxid=ANY($1) AND mx_room=$2 AND tg_space=$3"
-            )
-            rows = await cls.db.fetch(q, mxids, mx_room, tg_space)
-        else:
-            mxid_placeholders = ("?," * len(mxids)).rstrip(",")
-            q = (
-                f"SELECT {cls.columns} FROM message "
-                f"WHERE mx_room=? AND tg_space=? AND mxid IN ({mxid_placeholders})"
-            )
-            rows = await cls.db.fetch(q, mx_room, tg_space, *mxids)
-        return [cls._from_row(row) for row in rows]
-
-    @classmethod
-    async def find_recent(
-        cls, mx_room: RoomID, not_sender: TelegramID, limit: int = 20
-    ) -> list[Message]:
-        q = f"""
-        SELECT {cls.columns} FROM message
-        WHERE mx_room=$1 AND sender<>$2
-        ORDER BY tgid DESC LIMIT $3
-        """
-        return [cls._from_row(row) for row in await cls.db.fetch(q, mx_room, not_sender, limit)]
-
-    @classmethod
-    async def replace_temp_mxid(cls, temp_mxid: str, mx_room: RoomID, real_mxid: EventID) -> None:
-        q = "UPDATE message SET mxid=$1 WHERE mxid=$2 AND mx_room=$3"
-        await cls.db.execute(q, real_mxid, temp_mxid, mx_room)
-
-    @classmethod
-    async def delete_temp_mxid(cls, temp_mxid: str, mx_room: RoomID) -> None:
-        q = "DELETE FROM message WHERE mxid=$1 AND mx_room=$2"
-        await cls.db.execute(q, temp_mxid, mx_room)
-
-    @classmethod
-    async def bulk_insert(cls, messages: list[Message]) -> None:
-        columns = cls.columns.split(", ")
-        records = [attr.astuple(message) for message in messages]
-        async with cls.db.acquire() as conn, conn.transaction():
-            if cls.db.scheme == Scheme.POSTGRES:
-                await conn.copy_records_to_table("message", records=records, columns=columns)
-            else:
-                await conn.executemany(cls._insert_query, records)
-
-    _insert_query: ClassVar[
-        str
-    ] = """
-        INSERT INTO message (mxid, mx_room, tgid, tg_space, edit_index, redacted, content_hash, sender_mxid, sender)
-        VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
-    """
+    def update_by_mxid(cls, s_mxid: MatrixEventID, s_mx_room: MatrixRoomID, **values) -> None:
+        with cls.db.begin() as conn:
+            conn.execute(cls.t.update()
+                         .where(and_(cls.c.mxid == s_mxid, cls.c.mx_room == s_mx_room))
+                         .values(**values))

    @property
-    def _values(self):
-        return (
-            self.mxid,
-            self.mx_room,
-            self.tgid,
-            self.tg_space,
-            self.edit_index,
-            self.redacted,
-            self.content_hash,
-            self.sender_mxid,
-            self.sender,
-        )
+    def _edit_identity(self):
+        return and_(self.c.tgid == self.tgid, self.c.tg_space == self.tg_space,
+                    self.c.edit_index == self.edit_index)

-    async def insert(self) -> None:
-        await self.db.execute(self._insert_query, *self._values)
-
-    async def delete(self) -> None:
-        q = "DELETE FROM message WHERE mxid=$1 AND mx_room=$2 AND tg_space=$3"
-        await self.db.execute(q, self.mxid, self.mx_room, self.tg_space)
-
-    async def mark_redacted(self) -> None:
-        self.redacted = True
-        q = "UPDATE message SET redacted=true WHERE mxid=$1 AND mx_room=$2"
-        await self.db.execute(q, self.mxid, self.mx_room)
+    def insert(self) -> None:
+        with self.db.begin() as conn:
+            conn.execute(self.t.insert().values(mxid=self.mxid, mx_room=self.mx_room,
+                                                tgid=self.tgid, tg_space=self.tg_space,
+                                                edit_index=self.edit_index))
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,180 +14,68 @@
 #
 # 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 __future__ import annotations
+from sqlalchemy import Column, Integer, String, Boolean, Text, and_
+from sqlalchemy.engine.result import RowProxy
+from typing import Optional

-from typing import TYPE_CHECKING, Any, ClassVar
-import json
-
-from asyncpg import Record
-from attr import dataclass
-import attr
-
-from mautrix.types import BatchID, ContentURI, EventID, RoomID
-from mautrix.util.async_db import Database
-
-from ..types import TelegramID
-
-fake_db = Database.create("") if TYPE_CHECKING else None
+from ..types import MatrixRoomID, TelegramID
+from .base import Base


-@dataclass
-class Portal:
-    db: ClassVar[Database] = fake_db
+class Portal(Base):
+    __tablename__ = "portal"

    # Telegram chat information
-    tgid: TelegramID
-    tg_receiver: TelegramID
-    peer_type: str
-    megagroup: bool
+    tgid = Column(Integer, primary_key=True)  # type: TelegramID
+    tg_receiver = Column(Integer, primary_key=True)  # type: TelegramID
+    peer_type = Column(String, nullable=False)
+    megagroup = Column(Boolean)

    # Matrix portal information
-    mxid: RoomID | None
-    avatar_url: ContentURI | None
-    encrypted: bool
-    first_event_id: EventID | None
-    next_batch_id: BatchID | None
-    base_insertion_id: EventID | None
+    mxid = Column(String, unique=True, nullable=True)  # type: Optional[MatrixRoomID]

-    sponsored_event_id: EventID | None
-    sponsored_event_ts: int | None
-    sponsored_msg_random_id: bytes | None
+    config = Column(Text, nullable=True)

    # Telegram chat metadata
-    username: str | None
-    title: str | None
-    about: str | None
-    photo_id: str | None
-    name_set: bool
-    avatar_set: bool
-
-    local_config: dict[str, Any] = attr.ib(factory=lambda: {})
+    username = Column(String, nullable=True)
+    title = Column(String, nullable=True)
+    about = Column(String, nullable=True)
+    photo_id = Column(String, nullable=True)

    @classmethod
-    def _from_row(cls, row: Record | None) -> Portal | None:
-        if row is None:
+    def scan(cls, row) -> Optional['Portal']:
+        (tgid, tg_receiver, peer_type, megagroup, mxid, config, username, title, about,
+         photo_id) = row
+        return cls(tgid=tgid, tg_receiver=tg_receiver, peer_type=peer_type, megagroup=megagroup,
+                   mxid=mxid, config=config, username=username, title=title, about=about,
+                   photo_id=photo_id)
+
+    @classmethod
+    def _one_or_none(cls, rows: RowProxy) -> Optional['Portal']:
+        try:
+            return cls.scan(next(rows))
+        except StopIteration:
            return None
-        data = {**row}
-        data["local_config"] = json.loads(data.pop("config", None) or "{}")
-        return cls(**data)
-
-    columns: ClassVar[str] = ", ".join(
-        (
-            "tgid",
-            "tg_receiver",
-            "peer_type",
-            "megagroup",
-            "mxid",
-            "avatar_url",
-            "encrypted",
-            "first_event_id",
-            "next_batch_id",
-            "base_insertion_id",
-            "sponsored_event_id",
-            "sponsored_event_ts",
-            "sponsored_msg_random_id",
-            "username",
-            "title",
-            "about",
-            "photo_id",
-            "name_set",
-            "avatar_set",
-            "config",
-        )
-    )

    @classmethod
-    async def get_by_tgid(cls, tgid: TelegramID, tg_receiver: TelegramID) -> Portal | None:
-        q = f"SELECT {cls.columns} FROM portal WHERE tgid=$1 AND tg_receiver=$2"
-        return cls._from_row(await cls.db.fetchrow(q, tgid, tg_receiver))
+    def get_by_tgid(cls, tgid: TelegramID, tg_receiver: TelegramID) -> Optional['Portal']:
+        return cls._select_one_or_none(and_(cls.c.tgid == tgid, cls.c.tg_receiver == tg_receiver))

    @classmethod
-    async def get_by_mxid(cls, mxid: RoomID) -> Portal | None:
-        q = f"SELECT {cls.columns} FROM portal WHERE mxid=$1"
-        return cls._from_row(await cls.db.fetchrow(q, mxid))
+    def get_by_mxid(cls, mxid: MatrixRoomID) -> Optional['Portal']:
+        return cls._select_one_or_none(cls.c.mxid == mxid)

    @classmethod
-    async def find_by_username(cls, username: str) -> Portal | None:
-        q = f"SELECT {cls.columns} FROM portal WHERE lower(username)=$1"
-        return cls._from_row(await cls.db.fetchrow(q, username.lower()))
-
-    @classmethod
-    async def find_private_chats_of(cls, tg_receiver: TelegramID) -> list[Portal]:
-        q = f"SELECT {cls.columns} FROM portal WHERE tg_receiver=$1 AND peer_type='user'"
-        return [cls._from_row(row) for row in await cls.db.fetch(q, tg_receiver)]
-
-    @classmethod
-    async def find_private_chats_with(cls, tgid: TelegramID) -> list[Portal]:
-        q = f"SELECT {cls.columns} FROM portal WHERE tgid=$1 AND peer_type='user'"
-        return [cls._from_row(row) for row in await cls.db.fetch(q, tgid)]
-
-    @classmethod
-    async def all(cls) -> list[Portal]:
-        rows = await cls.db.fetch(f"SELECT {cls.columns} FROM portal")
-        return [cls._from_row(row) for row in rows]
+    def get_by_username(cls, username: str) -> Optional['Portal']:
+        return cls._select_one_or_none(cls.c.username == username)

    @property
-    def _values(self):
-        return (
-            self.tgid,
-            self.tg_receiver,
-            self.peer_type,
-            self.mxid,
-            self.avatar_url,
-            self.encrypted,
-            self.first_event_id,
-            self.next_batch_id,
-            self.base_insertion_id,
-            self.sponsored_event_id,
-            self.sponsored_event_ts,
-            self.sponsored_msg_random_id,
-            self.username,
-            self.title,
-            self.about,
-            self.photo_id,
-            self.name_set,
-            self.avatar_set,
-            self.megagroup,
-            json.dumps(self.local_config) if self.local_config else None,
-        )
+    def _edit_identity(self):
+        return and_(self.c.tgid == self.tgid, self.c.tg_receiver == self.tg_receiver)

-    async def save(self) -> None:
-        q = """
-        UPDATE portal
-        SET mxid=$4, avatar_url=$5, encrypted=$6,
-            first_event_id=$7, next_batch_id=$8, base_insertion_id=$9,
-            sponsored_event_id=$10, sponsored_event_ts=$11, sponsored_msg_random_id=$12,
-            username=$13, title=$14, about=$15, photo_id=$16, name_set=$17, avatar_set=$18,
-            megagroup=$19, config=$20
-        WHERE tgid=$1 AND tg_receiver=$2 AND (peer_type=$3 OR true)
-        """
-        await self.db.execute(q, *self._values)
-
-    async def update_id(self, id: TelegramID, peer_type: str) -> None:
-        q = (
-            "UPDATE portal SET tgid=$1, tg_receiver=$1, peer_type=$2 "
-            "WHERE tgid=$3 AND tg_receiver=$3"
-        )
-        clear_queue = "DELETE FROM backfill_queue WHERE portal_tgid=$1 AND portal_tg_receiver=$2"
-        async with self.db.acquire() as conn, conn.transaction():
-            await conn.execute(clear_queue, self.tgid, self.tg_receiver)
-            await conn.execute(q, id, peer_type, self.tgid)
-        self.tgid = id
-        self.tg_receiver = id
-        self.peer_type = peer_type
-
-    async def insert(self) -> None:
-        q = """
-        INSERT INTO portal (
-            tgid, tg_receiver, peer_type, mxid, avatar_url, encrypted,
-            first_event_id, base_insertion_id, next_batch_id,
-            sponsored_event_id, sponsored_event_ts, sponsored_msg_random_id,
-            username, title, about, photo_id, name_set, avatar_set, megagroup, config
-        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18,
-                  $19, $20)
-        """
-        await self.db.execute(q, *self._values)
-
-    async def delete(self) -> None:
-        q = "DELETE FROM portal WHERE tgid=$1 AND tg_receiver=$2"
-        await self.db.execute(q, self.tgid, self.tg_receiver)
+    def insert(self) -> None:
+        with self.db.begin() as conn:
+            conn.execute(self.t.insert().values(
+                tgid=self.tgid, tg_receiver=self.tg_receiver, peer_type=self.peer_type,
+                megagroup=self.megagroup, mxid=self.mxid, config=self.config,
+                username=self.username, title=self.title, about=self.about, photo_id=self.photo_id))
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 Tulir Asokan
+# 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
@@ -13,132 +14,75 @@
 #
 # 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 __future__ import annotations
+from sqlalchemy import Column, Integer, String, Boolean
+from sqlalchemy.engine.result import RowProxy
+from sqlalchemy.sql import expression
+from typing import Optional, Iterable

-from typing import TYPE_CHECKING, ClassVar
-
-from asyncpg import Record
-from attr import dataclass
-from yarl import URL
-
-from mautrix.types import ContentURI, SyncToken, UserID
-from mautrix.util.async_db import Database
-
-from ..types import TelegramID
-
-fake_db = Database.create("") if TYPE_CHECKING else None
+from ..types import MatrixUserID, MatrixRoomID, TelegramID
+from .base import Base


-@dataclass
-class Puppet:
-    db: ClassVar[Database] = fake_db
+class Puppet(Base):
+    __tablename__ = "puppet"

-    id: TelegramID
-
-    is_registered: bool
-
-    displayname: str | None
-    displayname_source: TelegramID | None
-    displayname_contact: bool
-    displayname_quality: int
-    disable_updates: bool
-    username: str | None
-    phone: str | None
-    photo_id: str | None
-    avatar_url: ContentURI | None
-    name_set: bool
-    avatar_set: bool
-    contact_info_set: bool
-    is_bot: bool | None
-    is_channel: bool
-    is_premium: bool
-
-    custom_mxid: UserID | None
-    access_token: str | None
-    next_batch: SyncToken | None
-    base_url: URL | None
+    id = Column(Integer, primary_key=True)  # type: TelegramID
+    custom_mxid = Column(String, nullable=True)  # type: Optional[MatrixUserID]
+    access_token = Column(String, nullable=True)
+    displayname = Column(String, nullable=True)
+    displayname_source = Column(Integer, nullable=True)  # type: Optional[TelegramID]
+    username = Column(String, nullable=True)
+    photo_id = Column(String, nullable=True)
+    is_bot = Column(Boolean, nullable=True)
+    matrix_registered = Column(Boolean, nullable=False, server_default=expression.false())
+    disable_updates = Column(Boolean, nullable=False, server_default=expression.false())

    @classmethod
-    def _from_row(cls, row: Record | None) -> Puppet | None:
-        if row is None:
+    def scan(cls, row) -> Optional['Puppet']:
+        (id, custom_mxid, access_token, displayname, displayname_source, username, photo_id,
+         is_bot, matrix_registered, disable_updates) = row
+        return cls(id=id, custom_mxid=custom_mxid, access_token=access_token,
+                   displayname=displayname, displayname_source=displayname_source,
+                   username=username, photo_id=photo_id, is_bot=is_bot,
+                   matrix_registered=matrix_registered, disable_updates=disable_updates)
+
+    @classmethod
+    def _one_or_none(cls, rows: RowProxy) -> Optional['Puppet']:
+        try:
+            return cls.scan(next(rows))
+        except StopIteration:
            return None
-        data = {**row}
-        base_url = data.pop("base_url", None)
-        return cls(**data, base_url=URL(base_url) if base_url else None)
-
-    columns: ClassVar[str] = (
-        "id, is_registered, displayname, displayname_source, displayname_contact, "
-        "displayname_quality, disable_updates, username, phone, photo_id, avatar_url, "
-        "name_set, avatar_set, contact_info_set, is_bot, is_channel, is_premium, "
-        "custom_mxid, access_token, next_batch, base_url"
-    )

    @classmethod
-    async def all_with_custom_mxid(cls) -> list[Puppet]:
-        q = f"SELECT {cls.columns} FROM puppet WHERE custom_mxid<>''"
-        return [cls._from_row(row) for row in await cls.db.fetch(q)]
+    def all_with_custom_mxid(cls) -> Iterable['Puppet']:
+        rows = cls.db.execute(cls.t.select().where(cls.c.custom_mxid != None))
+        for row in rows:
+            yield cls.scan(row)

    @classmethod
-    async def get_by_tgid(cls, tgid: TelegramID) -> Puppet | None:
-        q = f"SELECT {cls.columns} FROM puppet WHERE id=$1"
-        return cls._from_row(await cls.db.fetchrow(q, tgid))
+    def get_by_tgid(cls, tgid: TelegramID) -> Optional['Puppet']:
+        return cls._select_one_or_none(cls.c.id == tgid)

    @classmethod
-    async def get_by_custom_mxid(cls, mxid: UserID) -> Puppet | None:
-        q = f"SELECT {cls.columns} FROM puppet WHERE custom_mxid=$1"
-        return cls._from_row(await cls.db.fetchrow(q, mxid))
+    def get_by_custom_mxid(cls, mxid: MatrixUserID) -> Optional['Puppet']:
+        return cls._select_one_or_none(cls.c.custom_mxid == mxid)

    @classmethod
-    async def find_by_username(cls, username: str) -> Puppet | None:
-        q = f"SELECT {cls.columns} FROM puppet WHERE lower(username)=$1"
-        return cls._from_row(await cls.db.fetchrow(q, username.lower()))
+    def get_by_username(cls, username: str) -> Optional['Puppet']:
+        return cls._select_one_or_none(cls.c.username == username)
+
+    @classmethod
+    def get_by_displayname(cls, displayname: str) -> Optional['Puppet']:
+        return cls._select_one_or_none(cls.c.displayname == displayname)

    @property
-    def _values(self):
-        return (
-            self.id,
-            self.is_registered,
-            self.displayname,
-            self.displayname_source,
-            self.displayname_contact,
-            self.displayname_quality,
-            self.disable_updates,
-            self.username,
-            self.phone,
-            self.photo_id,
-            self.avatar_url,
-            self.name_set,
-            self.avatar_set,
-            self.contact_info_set,
-            self.is_bot,
-            self.is_channel,
-            self.is_premium,
-            self.custom_mxid,
-            self.access_token,
-            self.next_batch,
-            str(self.base_url) if self.base_url else None,
-        )
+    def _edit_identity(self):
+        return self.c.id == self.id

-    async def save(self) -> None:
-        q = """
-        UPDATE puppet
-        SET is_registered=$2, displayname=$3, displayname_source=$4, displayname_contact=$5,
-            displayname_quality=$6, disable_updates=$7, username=$8, phone=$9, photo_id=$10,
-            avatar_url=$11, name_set=$12, avatar_set=$13, contact_info_set=$14, is_bot=$15,
-            is_channel=$16, is_premium=$17, custom_mxid=$18, access_token=$19, next_batch=$20,
-            base_url=$21
-        WHERE id=$1
-        """
-        await self.db.execute(q, *self._values)
-
-    async def insert(self) -> None:
-        q = """
-        INSERT INTO puppet (
-            id, is_registered, displayname, displayname_source, displayname_contact,
-            displayname_quality, disable_updates, username, phone, photo_id, avatar_url, name_set,
-            avatar_set, contact_info_set, is_bot, is_channel, is_premium, custom_mxid,
-            access_token, next_batch, base_url
-        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18,
-                  $19, $20, $21)
-        """
-        await self.db.execute(q, *self._values)
+    def insert(self) -> None:
+        with self.db.begin() as conn:
+            conn.execute(self.t.insert().values(
+                id=self.id, custom_mxid=self.custom_mxid, access_token=self.access_token,
+                displayname=self.displayname, displayname_source=self.displayname_source,
+                username=self.username, photo_id=self.photo_id, is_bot=self.is_bot,
+                matrix_registered=self.matrix_registered, disable_updates=self.disable_updates))
@@ -1,100 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 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 __future__ import annotations
-
-from typing import TYPE_CHECKING, ClassVar
-
-from asyncpg import Record
-from attr import dataclass
-from telethon.tl.types import ReactionCustomEmoji, ReactionEmoji, TypeReaction
-
-from mautrix.types import EventID, RoomID
-from mautrix.util.async_db import Database
-
-from ..types import TelegramID
-
-fake_db = Database.create("") if TYPE_CHECKING else None
-
-
-@dataclass
-class Reaction:
-    db: ClassVar[Database] = fake_db
-
-    mxid: EventID
-    mx_room: RoomID
-    msg_mxid: EventID
-    tg_sender: TelegramID
-    reaction: str
-
-    @classmethod
-    def _from_row(cls, row: Record | None) -> Reaction | None:
-        if row is None:
-            return None
-        return cls(**row)
-
-    columns: ClassVar[str] = "mxid, mx_room, msg_mxid, tg_sender, reaction"
-
-    @classmethod
-    async def delete_all(cls, mx_room: RoomID) -> None:
-        await cls.db.execute("DELETE FROM reaction WHERE mx_room=$1", mx_room)
-
-    @classmethod
-    async def get_by_mxid(cls, mxid: EventID, mx_room: RoomID) -> Reaction | None:
-        q = f"SELECT {cls.columns} FROM reaction WHERE mxid=$1 AND mx_room=$2"
-        return cls._from_row(await cls.db.fetchrow(q, mxid, mx_room))
-
-    @classmethod
-    async def get_by_sender(
-        cls, mxid: EventID, mx_room: RoomID, tg_sender: TelegramID
-    ) -> list[Reaction]:
-        q = f"SELECT {cls.columns} FROM reaction WHERE msg_mxid=$1 AND mx_room=$2 AND tg_sender=$3"
-        rows = await cls.db.fetch(q, mxid, mx_room, tg_sender)
-        return [cls._from_row(row) for row in rows]
-
-    @classmethod
-    async def get_all_by_message(cls, mxid: EventID, mx_room: RoomID) -> list[Reaction]:
-        q = f"SELECT {cls.columns} FROM reaction WHERE msg_mxid=$1 AND mx_room=$2"
-        rows = await cls.db.fetch(q, mxid, mx_room)
-        return [cls._from_row(row) for row in rows]
-
-    @property
-    def telegram(self) -> TypeReaction:
-        if self.reaction.isdecimal():
-            return ReactionCustomEmoji(document_id=int(self.reaction))
-        else:
-            return ReactionEmoji(emoticon=self.reaction)
-
-    @property
-    def _values(self):
-        return (
-            self.mxid,
-            self.mx_room,
-            self.msg_mxid,
-            self.tg_sender,
-            self.reaction,
-        )
-
-    async def save(self) -> None:
-        q = """
-            INSERT INTO reaction (mxid, mx_room, msg_mxid, tg_sender, reaction)
-            VALUES ($1, $2, $3, $4, $5) ON CONFLICT (msg_mxid, mx_room, tg_sender, reaction)
-                DO UPDATE SET mxid=excluded.mxid
-        """
-        await self.db.execute(q, *self._values)
-
-    async def delete(self) -> None:
-        q = "DELETE FROM reaction WHERE msg_mxid=$1 AND mx_room=$2 AND tg_sender=$3 AND reaction=$4"
-        await self.db.execute(q, self.msg_mxid, self.mx_room, self.tg_sender, self.reaction)
@@ -0,0 +1,62 @@
+# -*- coding: future_fstrings -*-
+# 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 sqlalchemy import Column, String, Text
+from typing import Dict, Optional
+import json
+
+from ..types import MatrixRoomID
+from .base import Base
+
+
+class RoomState(Base):
+    __tablename__ = "mx_room_state"
+
+    room_id = Column(String, primary_key=True)  # type: MatrixRoomID
+    power_levels = Column("power_levels", Text, nullable=True)  # type: Optional[Dict]
+
+    @property
+    def _power_levels_text(self) -> Optional[str]:
+        return json.dumps(self.power_levels) if self.power_levels else None
+
+    @property
+    def has_power_levels(self) -> bool:
+        return bool(self.power_levels)
+
+    @classmethod
+    def get(cls, room_id: MatrixRoomID) -> Optional['RoomState']:
+        rows = cls.db.execute(cls.t.select().where(cls.c.room_id == room_id))
+        try:
+            room_id, power_levels_text = next(rows)
+            return cls(room_id=room_id, power_levels=(json.loads(power_levels_text)
+                                                      if power_levels_text else None))
+        except StopIteration:
+            return None
+
+    def update(self) -> None:
+        with self.db.begin() as conn:
+            conn.execute(self.t.update()
+                         .where(self.c.room_id == self.room_id)
+                         .values(power_levels=self._power_levels_text))
+
+    @property
+    def _edit_identity(self):
+        return self.c.room_id == self.room_id
+
+    def insert(self) -> None:
+        with self.db.begin() as conn:
+            conn.execute(self.t.insert().values(room_id=self.room_id,
+                                                power_levels=self._power_levels_text))
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,99 +14,43 @@
 #
 # 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 __future__ import annotations
+from sqlalchemy import Column, ForeignKey, Integer, BigInteger, String, Boolean
+from typing import Optional

-from typing import TYPE_CHECKING, ClassVar
-
-from asyncpg import Record
-from attr import dataclass
-
-from mautrix.types import ContentURI, EncryptedFile
-from mautrix.util.async_db import Database, Scheme
-
-fake_db = Database.create("") if TYPE_CHECKING else None
+from .base import Base


-@dataclass
-class TelegramFile:
-    db: ClassVar[Database] = fake_db
+class TelegramFile(Base):
+    __tablename__ = "telegram_file"

-    id: str
-    mxc: ContentURI
-    mime_type: str
-    was_converted: bool
-    timestamp: int
-    size: int | None
-    width: int | None
-    height: int | None
-    decryption_info: EncryptedFile | None
-    thumbnail: TelegramFile | None = None
-
-    columns: ClassVar[str] = (
-        "id, mxc, mime_type, was_converted, timestamp, size, width, height, thumbnail, "
-        "decryption_info"
-    )
+    id = Column(String, primary_key=True)
+    mxc = Column(String)
+    mime_type = Column(String)
+    was_converted = Column(Boolean)
+    timestamp = Column(BigInteger)
+    size = Column(Integer, nullable=True)
+    width = Column(Integer, nullable=True)
+    height = Column(Integer, nullable=True)
+    thumbnail_id = Column("thumbnail", String, ForeignKey("telegram_file.id"), nullable=True)
+    thumbnail = None  # type: Optional[TelegramFile]

    @classmethod
-    def _from_row(cls, row: Record | None) -> TelegramFile | None:
-        if row is None:
-            return None
-        data = {**row}
-        data.pop("thumbnail", None)
-        decryption_info = data.pop("decryption_info", None)
-        return cls(
-            **data,
-            thumbnail=None,
-            decryption_info=EncryptedFile.parse_json(decryption_info) if decryption_info else None,
-        )
-
-    @classmethod
-    async def get_many(cls, loc_ids: list[str]) -> list[TelegramFile]:
-        if cls.db.scheme in (Scheme.POSTGRES, Scheme.COCKROACH):
-            q = f"SELECT {cls.columns} FROM telegram_file WHERE id=ANY($1)"
-            rows = await cls.db.fetch(q, loc_ids)
-        else:
-            tgid_placeholders = ("?," * len(loc_ids)).rstrip(",")
-            q = f"SELECT {cls.columns} FROM telegram_file WHERE id IN ({tgid_placeholders})"
-            rows = await cls.db.fetch(q, *loc_ids)
-        return [cls._from_row(row) for row in rows]
-
-    @classmethod
-    async def get(cls, loc_id: str, *, _thumbnail: bool = False) -> TelegramFile | None:
-        q = f"SELECT {cls.columns} FROM telegram_file WHERE id=$1"
-        row = await cls.db.fetchrow(q, loc_id)
-        file = cls._from_row(row)
-        if file is None:
-            return None
+    def get(cls, loc_id: str) -> Optional['TelegramFile']:
+        rows = cls.db.execute(cls.t.select().where(cls.c.id == loc_id))
        try:
-            thumbnail_id = row["thumbnail"]
-        except KeyError:
-            thumbnail_id = None
-        if thumbnail_id and not _thumbnail:
-            file.thumbnail = await cls.get(thumbnail_id, _thumbnail=True)
-        return file
+            loc_id, mxc, mime, conv, ts, s, w, h, thumb_id = next(rows)
+            thumb = None
+            if thumb_id:
+                thumb = cls.get(thumb_id)
+            return cls(id=loc_id, mxc=mxc, mime_type=mime, was_converted=conv, timestamp=ts,
+                       size=s, width=w, height=h, thumbnail_id=thumb_id, thumbnail=thumb)
+        except StopIteration:
+            return None

-    @classmethod
-    async def find_by_mxc(cls, mxc: ContentURI) -> TelegramFile | None:
-        q = f"SELECT {cls.columns} FROM telegram_file WHERE mxc=$1"
-        return cls._from_row(await cls.db.fetchrow(q, mxc))
-
-    async def insert(self) -> None:
-        q = (
-            "INSERT INTO telegram_file (id, mxc, mime_type, was_converted, timestamp,"
-            "                           size, width, height, thumbnail, decryption_info) "
-            "VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)"
-        )
-        await self.db.execute(
-            q,
-            self.id,
-            self.mxc,
-            self.mime_type,
-            self.was_converted,
-            self.timestamp,
-            self.size,
-            self.width,
-            self.height,
-            self.thumbnail.id if self.thumbnail else None,
-            self.decryption_info.json() if self.decryption_info else None,
-        )
+    def insert(self) -> None:
+        with self.db.begin() as conn:
+            conn.execute(self.t.insert().values(
+                id=self.id, mxc=self.mxc, mime_type=self.mime_type,
+                was_converted=self.was_converted, timestamp=self.timestamp, size=self.size,
+                width=self.width, height=self.height,
+                thumbnail=self.thumbnail.id if self.thumbnail else self.thumbnail_id))
@@ -1,266 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 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 __future__ import annotations
-
-from typing import TYPE_CHECKING, ClassVar, Iterable
-import asyncio
-import datetime
-
-from telethon import utils
-from telethon.crypto import AuthKey
-from telethon.sessions import MemorySession
-from telethon.tl.types import PeerChannel, PeerChat, PeerUser, updates
-
-from mautrix.util.async_db import Database, Scheme
-
-fake_db = Database.create("") if TYPE_CHECKING else None
-
-
-class PgSession(MemorySession):
-    db: ClassVar[Database] = fake_db
-
-    session_id: str
-    _dc_id: int
-    _server_address: str | None
-    _port: int | None
-    _auth_key: AuthKey | None
-    _takeout_id: int | None
-    _process_entities_lock: asyncio.Lock
-
-    def __init__(
-        self,
-        session_id: str,
-        dc_id: int = 0,
-        server_address: str | None = None,
-        port: int | None = None,
-        auth_key: AuthKey | None = None,
-        takeout_id: int | None = None,
-    ) -> None:
-        super().__init__()
-        self.session_id = session_id
-        self._dc_id = dc_id
-        self._server_address = server_address
-        self._port = port
-        self._auth_key = auth_key
-        self._takeout_id = takeout_id
-        self._process_entities_lock = asyncio.Lock()
-
-    def clone(self, to_instance=None) -> MemorySession:
-        # We don't want to store data of clones
-        # (which are used for temporarily connecting to different DCs)
-        return super().clone(MemorySession())
-
-    @property
-    def auth_key_bytes(self) -> bytes | None:
-        return self._auth_key.key if self._auth_key else None
-
-    @classmethod
-    async def get(cls, session_id: str) -> PgSession:
-        q = (
-            "SELECT session_id, dc_id, server_address, port, auth_key FROM telethon_sessions "
-            "WHERE session_id=$1"
-        )
-        row = await cls.db.fetchrow(q, session_id)
-        if row is None:
-            return cls(session_id)
-        data = {**row}
-        auth_key = AuthKey(data.pop("auth_key", None))
-        return cls(**data, auth_key=auth_key)
-
-    @classmethod
-    async def has(cls, session_id: str) -> bool:
-        q = "SELECT COUNT(*) FROM telethon_sessions WHERE session_id=$1"
-        count = await cls.db.fetchval(q, session_id)
-        return count > 0
-
-    async def save(self) -> None:
-        q = (
-            "INSERT INTO telethon_sessions (session_id, dc_id, server_address, port, auth_key) "
-            "VALUES ($1, $2, $3, $4, $5) ON CONFLICT (session_id) "
-            "DO UPDATE SET dc_id=$2, server_address=$3, port=$4, auth_key=$5"
-        )
-        await self.db.execute(
-            q, self.session_id, self.dc_id, self.server_address, self.port, self.auth_key_bytes
-        )
-
-    _tables: ClassVar[tuple[str, ...]] = (
-        "telethon_sessions",
-        "telethon_entities",
-        "telethon_sent_files",
-        "telethon_update_state",
-    )
-
-    async def delete(self) -> None:
-        async with self.db.acquire() as conn, conn.transaction():
-            for table in self._tables:
-                await conn.execute(f"DELETE FROM {table} WHERE session_id=$1", self.session_id)
-
-    async def close(self) -> None:
-        # Nothing to do here, DB connection is global
-        pass
-
-    async def get_update_state(self, entity_id: int) -> updates.State | None:
-        q = (
-            "SELECT pts, qts, date, seq, unread_count FROM telethon_update_state "
-            "WHERE session_id=$1 AND entity_id=$2"
-        )
-        row = await self.db.fetchrow(q, self.session_id, entity_id)
-        if row is None:
-            return None
-        date = datetime.datetime.utcfromtimestamp(row["date"])
-        return updates.State(row["pts"], row["qts"], date, row["seq"], row["unread_count"])
-
-    _set_update_state_q = """
-    INSERT INTO telethon_update_state (session_id, entity_id, pts, qts, date, seq, unread_count)
-    VALUES ($1, $2, $3, $4, $5, $6, $7)
-    ON CONFLICT (session_id, entity_id) DO UPDATE SET
-        pts=excluded.pts, qts=excluded.qts, date=excluded.date, seq=excluded.seq,
-        unread_count=excluded.unread_count
-    """
-
-    async def set_update_state(self, entity_id: int, row: updates.State) -> None:
-        q = self._set_update_state_q
-        ts = row.date.timestamp()
-        await self.db.execute(
-            q, self.session_id, entity_id, row.pts, row.qts, ts, row.seq, row.unread_count
-        )
-
-    async def set_update_states(self, rows: list[tuple[int, updates.State]]) -> None:
-        rows = [
-            (
-                self.session_id,
-                entity_id,
-                row.pts,
-                row.qts,
-                row.date.timestamp(),
-                row.seq,
-                row.unread_count,
-            )
-            for entity_id, row in rows
-        ]
-        if self.db.scheme == Scheme.POSTGRES:
-            q = """
-            INSERT INTO telethon_update_state (
-                session_id, entity_id, pts, qts, date, seq, unread_count
-            )
-            VALUES (
-                $1,
-                unnest($2::bigint[]), unnest($3::bigint[]), unnest($4::bigint[]),
-                unnest($5::bigint[]), unnest($6::bigint[]), unnest($7::integer[])
-            )
-            ON CONFLICT (session_id, entity_id) DO UPDATE SET
-                pts=excluded.pts, qts=excluded.qts, date=excluded.date, seq=excluded.seq,
-                unread_count=excluded.unread_count
-            """
-            _, entity_ids, ptses, qtses, timestamps, seqs, unread_counts = zip(*rows)
-            await self.db.execute(
-                q, self.session_id, entity_ids, ptses, qtses, timestamps, seqs, unread_counts
-            )
-        else:
-            await self.db.executemany(self._set_update_state_q, rows)
-
-    async def delete_update_state(self, entity_id: int) -> None:
-        q = "DELETE FROM telethon_update_state WHERE session_id=$1 AND entity_id=$2"
-        await self.db.execute(q, self.session_id, entity_id)
-
-    async def get_update_states(self) -> Iterable[tuple[int, updates.State], ...]:
-        q = (
-            "SELECT entity_id, pts, qts, date, seq, unread_count FROM telethon_update_state "
-            "WHERE session_id=$1"
-        )
-        rows = await self.db.fetch(q, self.session_id)
-        return (
-            (
-                row["entity_id"],
-                updates.State(
-                    row["pts"],
-                    row["qts"],
-                    datetime.datetime.utcfromtimestamp(row["date"]),
-                    row["seq"],
-                    row["unread_count"],
-                ),
-            )
-            for row in rows
-        )
-
-    def _entity_values_to_row(
-        self, id: int, hash: int, username: str | None, phone: str | int | None, name: str | None
-    ) -> tuple[str, int, int, str | None, str | None, str | None]:
-        return self.session_id, id, hash, username, str(phone) if phone else None, name
-
-    async def process_entities(self, tlo) -> None:
-        # Postgres likes to deadlock on simultaneous upserts, so just lock the whole thing here
-        # TODO: make sure postgres doesn't deadlock on upserts when session_id is different
-        async with self._process_entities_lock:
-            await self._locked_process_entities(tlo)
-
-    async def _locked_process_entities(self, tlo) -> None:
-        rows: list[
-            tuple[str, int, int, str | None, str | None, str | None]
-        ] = self._entities_to_rows(tlo)
-        if not rows:
-            return
-        if self.db.scheme == Scheme.POSTGRES:
-            q = (
-                "INSERT INTO telethon_entities (session_id, id, hash, username, phone, name) "
-                "VALUES ($1, unnest($2::bigint[]), unnest($3::bigint[]), "
-                "        unnest($4::text[]), unnest($5::text[]), unnest($6::text[])) "
-                "ON CONFLICT (session_id, id) DO UPDATE"
-                "  SET hash=excluded.hash, username=excluded.username,"
-                "      phone=excluded.phone, name=excluded.name"
-            )
-            _, ids, hashes, usernames, phones, names = zip(*rows)
-            await self.db.execute(q, self.session_id, ids, hashes, usernames, phones, names)
-        else:
-            q = (
-                "INSERT INTO telethon_entities (session_id, id, hash, username, phone, name) "
-                "VALUES ($1, $2, $3, $4, $5, $6) "
-                "ON CONFLICT (session_id, id) DO UPDATE "
-                "    SET hash=$3, username=$4, phone=$5, name=$6"
-            )
-            await self.db.executemany(q, rows)
-
-    async def _select_entity(
-        self, constraint: str, *args: str | int | tuple[int, ...]
-    ) -> tuple[int, int] | None:
-        q = f"SELECT id, hash FROM telethon_entities WHERE session_id=$1 AND {constraint}"
-        row = await self.db.fetchrow(q, self.session_id, *args)
-        if row is None:
-            return None
-        return row["id"], row["hash"]
-
-    async def get_entity_rows_by_phone(self, key: str | int) -> tuple[int, int] | None:
-        return await self._select_entity("phone=$2", str(key))
-
-    async def get_entity_rows_by_username(self, key: str) -> tuple[int, int] | None:
-        return await self._select_entity("username=$2", key)
-
-    async def get_entity_rows_by_name(self, key: str) -> tuple[int, int] | None:
-        return await self._select_entity("name=$2", key)
-
-    async def get_entity_rows_by_id(self, key: int, exact: bool = True) -> tuple[int, int] | None:
-        if exact:
-            return await self._select_entity("id=$2", key)
-
-        ids = (
-            utils.get_peer_id(PeerUser(key)),
-            utils.get_peer_id(PeerChat(key)),
-            utils.get_peer_id(PeerChannel(key)),
-        )
-        if self.db.scheme in (Scheme.POSTGRES, Scheme.COCKROACH):
-            return await self._select_entity("id=ANY($2)", ids)
-        else:
-            return await self._select_entity(f"id IN ($2, $3, $4)", *ids)
@@ -1,24 +0,0 @@
-from mautrix.util.async_db import UpgradeTable
-
-upgrade_table = UpgradeTable()
-
-from . import (
-    v01_initial_revision,
-    v02_sponsored_events,
-    v03_reactions,
-    v04_disappearing_messages,
-    v05_channel_ghosts,
-    v06_puppet_avatar_url,
-    v07_puppet_phone_number,
-    v08_portal_first_event,
-    v09_puppet_username_index,
-    v10_more_backfill_fields,
-    v11_backfill_queue,
-    v12_message_sender,
-    v13_multiple_reactions,
-    v14_puppet_custom_mxid_index,
-    v15_backfill_anchor_id,
-    v16_backfill_type,
-    v17_message_find_recent,
-    v18_puppet_contact_info_set,
-)
@@ -1,242 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection, Scheme
-
-latest_version = 18
-
-
-async def create_latest_tables(conn: Connection, scheme: Scheme) -> int:
-    await conn.execute(
-        """CREATE TABLE "user" (
-            mxid TEXT   PRIMARY KEY,
-            tgid BIGINT UNIQUE,
-            tg_username    TEXT,
-            tg_phone       TEXT,
-            is_bot         BOOLEAN NOT NULL DEFAULT false,
-            is_premium     BOOLEAN NOT NULL DEFAULT false,
-            saved_contacts INTEGER NOT NULL DEFAULT 0
-        )"""
-    )
-    await conn.execute(
-        """CREATE TABLE portal (
-            tgid        BIGINT,
-            tg_receiver BIGINT,
-            peer_type   TEXT NOT NULL,
-            mxid        TEXT UNIQUE,
-            avatar_url  TEXT,
-            encrypted   BOOLEAN NOT NULL DEFAULT false,
-            username    TEXT,
-            title       TEXT,
-            about       TEXT,
-            photo_id    TEXT,
-            name_set    BOOLEAN NOT NULL DEFAULT false,
-            avatar_set  BOOLEAN NOT NULL DEFAULT false,
-            megagroup   BOOLEAN,
-            config      jsonb,
-
-            first_event_id    TEXT,
-            next_batch_id     TEXT,
-            base_insertion_id TEXT,
-
-            sponsored_event_id     TEXT,
-            sponsored_event_ts     BIGINT,
-            sponsored_msg_random_id bytea,
-
-            PRIMARY KEY (tgid, tg_receiver)
-        )"""
-    )
-    await conn.execute(
-        """CREATE TABLE message (
-            mxid         TEXT   NOT NULL,
-            mx_room      TEXT   NOT NULL,
-            tgid         BIGINT,
-            tg_space     BIGINT,
-            edit_index   INTEGER,
-            redacted     BOOLEAN NOT NULL DEFAULT false,
-            content_hash bytea,
-            sender_mxid  TEXT,
-            sender       BIGINT,
-            PRIMARY KEY (tgid, tg_space, edit_index),
-            UNIQUE (mxid, mx_room, tg_space)
-        )"""
-    )
-    await conn.execute("CREATE INDEX message_mx_room_and_tgid_idx ON message(mx_room, tgid DESC)")
-    await conn.execute(
-        """CREATE TABLE reaction (
-            mxid      TEXT NOT NULL,
-            mx_room   TEXT NOT NULL,
-            msg_mxid  TEXT NOT NULL,
-            tg_sender BIGINT,
-            reaction  TEXT NOT NULL,
-
-            PRIMARY KEY (msg_mxid, mx_room, tg_sender, reaction),
-            UNIQUE (mxid, mx_room)
-        )"""
-    )
-    await conn.execute(
-        """CREATE TABLE disappearing_message (
-            room_id             TEXT,
-            event_id            TEXT,
-            expiration_seconds  BIGINT,
-            expiration_ts       BIGINT,
-
-            PRIMARY KEY (room_id, event_id)
-        )"""
-    )
-    await conn.execute(
-        """CREATE TABLE puppet (
-            id BIGINT PRIMARY KEY,
-
-            is_registered BOOLEAN NOT NULL DEFAULT false,
-
-            displayname         TEXT,
-            displayname_source  BIGINT,
-            displayname_contact BOOLEAN NOT NULL DEFAULT true,
-            displayname_quality INTEGER NOT NULL DEFAULT 0,
-            disable_updates     BOOLEAN NOT NULL DEFAULT false,
-            username            TEXT,
-            phone               TEXT,
-            photo_id            TEXT,
-            avatar_url          TEXT,
-            name_set            BOOLEAN NOT NULL DEFAULT false,
-            avatar_set          BOOLEAN NOT NULL DEFAULT false,
-            contact_info_set    BOOLEAN NOT NULL DEFAULT false,
-            is_bot              BOOLEAN,
-            is_channel          BOOLEAN NOT NULL DEFAULT false,
-            is_premium          BOOLEAN NOT NULL DEFAULT false,
-
-            access_token TEXT,
-            custom_mxid  TEXT,
-            next_batch   TEXT,
-            base_url     TEXT
-        )"""
-    )
-    await conn.execute("CREATE INDEX puppet_username_idx ON puppet(LOWER(username))")
-    await conn.execute("CREATE INDEX puppet_custom_mxid_idx ON puppet(custom_mxid)")
-    await conn.execute(
-        """CREATE TABLE telegram_file (
-            id              TEXT PRIMARY KEY,
-            mxc             TEXT NOT NULL,
-            mime_type       TEXT,
-            was_converted   BOOLEAN NOT NULL DEFAULT false,
-            timestamp       BIGINT  NOT NULL DEFAULT 0,
-            size            BIGINT,
-            width           INTEGER,
-            height          INTEGER,
-            thumbnail       TEXT,
-            decryption_info jsonb,
-            FOREIGN KEY (thumbnail) REFERENCES telegram_file(id)
-                ON UPDATE CASCADE ON DELETE SET NULL
-        )"""
-    )
-    await conn.execute("CREATE INDEX telegram_file_mxc_idx ON telegram_file(mxc)")
-    await conn.execute(
-        """CREATE TABLE bot_chat (
-            id   BIGINT PRIMARY KEY,
-            type TEXT NOT NULL
-        )"""
-    )
-    await conn.execute(
-        """CREATE TABLE user_portal (
-            "user"          BIGINT,
-            portal          BIGINT,
-            portal_receiver BIGINT,
-            PRIMARY KEY ("user", portal, portal_receiver),
-            FOREIGN KEY ("user") REFERENCES "user"(tgid) ON DELETE CASCADE ON UPDATE CASCADE,
-            FOREIGN KEY (portal, portal_receiver) REFERENCES portal(tgid, tg_receiver)
-                 ON DELETE CASCADE ON UPDATE CASCADE
-        )"""
-    )
-    await conn.execute(
-        """CREATE TABLE contact (
-            "user"  BIGINT,
-            contact BIGINT,
-            PRIMARY KEY ("user", contact),
-            FOREIGN KEY ("user")  REFERENCES "user"(tgid) ON DELETE CASCADE ON UPDATE CASCADE,
-            FOREIGN KEY (contact) REFERENCES puppet(id)   ON DELETE CASCADE ON UPDATE CASCADE
-        )"""
-    )
-    await conn.execute(
-        """CREATE TABLE telethon_sessions (
-            session_id     TEXT PRIMARY KEY,
-            dc_id          INTEGER,
-            server_address TEXT,
-            port           INTEGER,
-            auth_key       bytea
-        )"""
-    )
-    await conn.execute(
-        """CREATE TABLE telethon_entities (
-            session_id TEXT,
-            id         BIGINT,
-            hash       BIGINT NOT NULL,
-            username   TEXT,
-            phone      TEXT,
-            name       TEXT,
-            PRIMARY KEY (session_id, id)
-        )"""
-    )
-    await conn.execute(
-        """CREATE TABLE telethon_sent_files (
-            session_id TEXT,
-            md5_digest bytea,
-            file_size  INTEGER,
-            type       INTEGER,
-            id         BIGINT,
-            hash       BIGINT,
-            PRIMARY KEY (session_id, md5_digest, file_size, type)
-        )"""
-    )
-    await conn.execute(
-        """CREATE TABLE telethon_update_state (
-            session_id   TEXT,
-            entity_id    BIGINT,
-            pts          BIGINT,
-            qts          BIGINT,
-            date         BIGINT,
-            seq          BIGINT,
-            unread_count INTEGER,
-            PRIMARY KEY (session_id, entity_id)
-        )"""
-    )
-    gen = ""
-    if scheme in (Scheme.POSTGRES, Scheme.COCKROACH):
-        gen = "GENERATED ALWAYS AS IDENTITY"
-    await conn.execute(
-        f"""
-        CREATE TABLE backfill_queue (
-            queue_id            INTEGER PRIMARY KEY {gen},
-            user_mxid           TEXT,
-            priority            INTEGER NOT NULL,
-            type                TEXT NOT NULL,
-            portal_tgid         BIGINT,
-            portal_tg_receiver  BIGINT,
-            anchor_msg_id       BIGINT,
-            extra_data          jsonb,
-            messages_per_batch  INTEGER NOT NULL,
-            post_batch_delay    INTEGER NOT NULL,
-            max_batches         INTEGER NOT NULL,
-            dispatch_time       TIMESTAMP,
-            completed_at        TIMESTAMP,
-            cooldown_timeout    TIMESTAMP,
-            FOREIGN KEY (user_mxid) REFERENCES "user"(mxid) ON DELETE CASCADE ON UPDATE CASCADE,
-            FOREIGN KEY (portal_tgid, portal_tg_receiver)
-                REFERENCES portal(tgid, tg_receiver) ON DELETE CASCADE
-        )
-        """
-    )
-
-    return latest_version
@@ -1,181 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 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 __future__ import annotations
-
-from mautrix.util.async_db import Connection, Scheme
-
-from . import upgrade_table
-from .v00_latest_revision import create_latest_tables, latest_version
-
-legacy_version_query = "SELECT version_num FROM alembic_version"
-last_legacy_version = "bfc0a39bfe02"
-
-
-async def first_upgrade_target(conn: Connection, scheme: Scheme) -> int:
-    is_legacy = await conn.table_exists("alembic_version")
-    # If it's a legacy db, the upgrade process will go to v1 and run each migration up to latest.
-    # If it's a new db, we'll create the latest tables directly (see create_latest_tables call).
-    return 1 if is_legacy else latest_version
-
-
-@upgrade_table.register(description="Initial asyncpg revision", upgrades_to=first_upgrade_target)
-async def upgrade_v1(conn: Connection, scheme: Scheme) -> int:
-    is_legacy = await conn.table_exists("alembic_version")
-    if is_legacy:
-        await migrate_legacy_to_v1(conn, scheme)
-        return 1
-    else:
-        return await create_latest_tables(conn, scheme)
-
-
-async def drop_constraints(conn: Connection, table: str, contype: str) -> None:
-    q = (
-        "SELECT conname FROM pg_constraint con INNER JOIN pg_class rel ON rel.oid=con.conrelid "
-        f"WHERE rel.relname='{table}' AND contype='{contype}'"
-    )
-    names = [row["conname"] for row in await conn.fetch(q)]
-    drops = ", ".join(f"DROP CONSTRAINT {name}" for name in names)
-    await conn.execute(f"ALTER TABLE {table} {drops}")
-
-
-async def migrate_legacy_to_v1(conn: Connection, scheme: Scheme) -> None:
-    legacy_version = await conn.fetchval(legacy_version_query)
-    if legacy_version != last_legacy_version:
-        raise RuntimeError(
-            "Legacy database is not on last version. "
-            "Please upgrade the old database with alembic or drop it completely first."
-        )
-    if scheme != Scheme.SQLITE:
-        await drop_constraints(conn, "contact", contype="f")
-        await conn.execute(
-            """
-            ALTER TABLE contact
-              ADD CONSTRAINT contact_user_fkey FOREIGN KEY (contact) REFERENCES puppet(id)
-                ON DELETE CASCADE ON UPDATE CASCADE,
-              ADD CONSTRAINT contact_contact_fkey FOREIGN KEY ("user") REFERENCES "user"(tgid)
-                ON DELETE CASCADE ON UPDATE CASCADE
-            """
-        )
-        await drop_constraints(conn, "telethon_sessions", contype="p")
-        await conn.execute(
-            """
-            ALTER TABLE telethon_sessions
-              ADD CONSTRAINT telethon_sessions_pkey PRIMARY KEY (session_id)
-            """
-        )
-        await drop_constraints(conn, "telegram_file", contype="f")
-        await conn.execute(
-            """
-            ALTER TABLE telegram_file
-              ADD CONSTRAINT fk_file_thumbnail
-                FOREIGN KEY (thumbnail) REFERENCES telegram_file(id)
-                ON UPDATE CASCADE ON DELETE SET NULL
-            """
-        )
-        await conn.execute("ALTER TABLE puppet ALTER COLUMN id DROP IDENTITY IF EXISTS")
-        await conn.execute("ALTER TABLE puppet ALTER COLUMN id DROP DEFAULT")
-        await conn.execute("DROP SEQUENCE IF EXISTS puppet_id_seq")
-        await conn.execute("ALTER TABLE bot_chat ALTER COLUMN id DROP IDENTITY IF EXISTS")
-        await conn.execute("ALTER TABLE bot_chat ALTER COLUMN id DROP DEFAULT")
-        await conn.execute("DROP SEQUENCE IF EXISTS bot_chat_id_seq")
-        await conn.execute("ALTER TABLE portal ALTER COLUMN config TYPE jsonb USING config::jsonb")
-        await conn.execute(
-            "ALTER TABLE telegram_file ALTER COLUMN decryption_info TYPE jsonb "
-            "USING decryption_info::jsonb"
-        )
-        await varchar_to_text(conn)
-    else:
-        await conn.execute(
-            """CREATE TABLE telethon_sessions_new (
-                session_id     TEXT PRIMARY KEY,
-                dc_id          INTEGER,
-                server_address TEXT,
-                port           INTEGER,
-                auth_key       bytea
-            )"""
-        )
-        await conn.execute(
-            """
-            INSERT INTO telethon_sessions_new (session_id, dc_id, server_address, port, auth_key)
-            SELECT session_id, dc_id, server_address, port, auth_key FROM telethon_sessions
-            """
-        )
-        await conn.execute("DROP TABLE telethon_sessions")
-        await conn.execute("ALTER TABLE telethon_sessions_new RENAME TO telethon_sessions")
-
-    await update_state_store(conn, scheme)
-    await conn.execute('ALTER TABLE "user" ADD COLUMN is_bot BOOLEAN NOT NULL DEFAULT false')
-    await conn.execute("ALTER TABLE puppet RENAME COLUMN matrix_registered TO is_registered")
-    await conn.execute("DROP TABLE telethon_version")
-    await conn.execute("DROP TABLE alembic_version")
-
-
-async def update_state_store(conn: Connection, scheme: Scheme) -> None:
-    # The Matrix state store already has more or less the correct schema, so set the version
-    await conn.execute("CREATE TABLE mx_version (version INTEGER PRIMARY KEY)")
-    await conn.execute("INSERT INTO mx_version (version) VALUES (2)")
-    await conn.execute("UPDATE mx_user_profile SET membership='LEAVE' WHERE membership='LEFT'")
-    if scheme != Scheme.SQLITE:
-        # Also add the membership type on postgres
-        await conn.execute(
-            "CREATE TYPE membership AS ENUM ('join', 'leave', 'invite', 'ban', 'knock')"
-        )
-        await conn.execute(
-            "ALTER TABLE mx_user_profile ALTER COLUMN membership TYPE membership "
-            "USING LOWER(membership)::membership"
-        )
-    else:
-        # On SQLite there's no custom type, but we still want to lowercase everything
-        await conn.execute("UPDATE mx_user_profile SET membership=LOWER(membership)")
-
-
-async def varchar_to_text(conn: Connection) -> None:
-    columns_to_adjust = {
-        "user": ("mxid", "tg_username", "tg_phone"),
-        "portal": (
-            "peer_type",
-            "mxid",
-            "username",
-            "title",
-            "about",
-            "photo_id",
-            "avatar_url",
-            "config",
-        ),
-        "message": ("mxid", "mx_room"),
-        "puppet": (
-            "displayname",
-            "username",
-            "photo_id",
-            "access_token",
-            "custom_mxid",
-            "next_batch",
-            "base_url",
-        ),
-        "bot_chat": ("type",),
-        "telegram_file": ("id", "mxc", "mime_type", "thumbnail"),
-        # Phone is a bigint in the old schema, which is safe, but we don't do math on it,
-        # so let's change it to a string
-        "telethon_entities": ("session_id", "username", "name", "phone"),
-        "telethon_sent_files": ("session_id",),
-        "telethon_sessions": ("session_id", "server_address"),
-        "telethon_update_state": ("session_id",),
-        "mx_room_state": ("room_id",),
-        "mx_user_profile": ("room_id", "user_id", "displayname", "avatar_url"),
-    }
-    for table, columns in columns_to_adjust.items():
-        for column in columns:
-            await conn.execute(f'ALTER TABLE "{table}" ALTER COLUMN {column} TYPE TEXT')
@@ -1,25 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 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 mautrix.util.async_db import Connection
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Add column to store sponsored message event ID in channels")
-async def upgrade_v2(conn: Connection) -> None:
-    await conn.execute("ALTER TABLE portal ADD COLUMN sponsored_event_id TEXT")
-    await conn.execute("ALTER TABLE portal ADD COLUMN sponsored_event_ts BIGINT")
-    await conn.execute("ALTER TABLE portal ADD COLUMN sponsored_msg_random_id bytea")
@@ -1,39 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 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 mautrix.util.async_db import Connection
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Add support for reactions")
-async def upgrade_v3(conn: Connection, scheme: str) -> None:
-    await conn.execute(
-        """CREATE TABLE reaction (
-            mxid      TEXT NOT NULL,
-            mx_room   TEXT NOT NULL,
-            msg_mxid  TEXT NOT NULL,
-            tg_sender BIGINT,
-            reaction  TEXT NOT NULL,
-
-            PRIMARY KEY (msg_mxid, mx_room, tg_sender),
-            UNIQUE (mxid, mx_room)
-        )"""
-    )
-    if scheme != "sqlite":
-        await conn.execute("DELETE FROM message WHERE mxid IS NULL OR mx_room IS NULL")
-        await conn.execute("ALTER TABLE message ALTER COLUMN mxid SET NOT NULL")
-        await conn.execute("ALTER TABLE message ALTER COLUMN mx_room SET NOT NULL")
-    await conn.execute("ALTER TABLE message ADD COLUMN content_hash bytea")
@@ -1,32 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Add support for disappearing messages")
-async def upgrade_v4(conn: Connection) -> None:
-    await conn.execute(
-        """CREATE TABLE disappearing_message (
-            room_id             TEXT,
-            event_id            TEXT,
-            expiration_seconds  BIGINT,
-            expiration_ts       BIGINT,
-
-            PRIMARY KEY (room_id, event_id)
-        )"""
-    )
@@ -1,25 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection, Scheme
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Add separate ghost users for channel senders")
-async def upgrade_v5(conn: Connection, scheme: str) -> None:
-    await conn.execute("ALTER TABLE puppet ADD COLUMN is_channel BOOLEAN NOT NULL DEFAULT false")
-    if scheme == Scheme.POSTGRES:
-        await conn.execute("ALTER TABLE puppet ALTER COLUMN is_channel DROP DEFAULT")
@@ -1,31 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Store avatar mxc URI in puppet table")
-async def upgrade_v6(conn: Connection) -> None:
-    await conn.execute("ALTER TABLE puppet ADD COLUMN avatar_url TEXT")
-    await conn.execute("ALTER TABLE puppet ADD COLUMN name_set BOOLEAN NOT NULL DEFAULT false")
-    await conn.execute("ALTER TABLE puppet ADD COLUMN avatar_set BOOLEAN NOT NULL DEFAULT false")
-    await conn.execute("UPDATE puppet SET name_set=true WHERE displayname<>''")
-    await conn.execute("UPDATE puppet SET avatar_set=true WHERE photo_id<>''")
-    await conn.execute("ALTER TABLE portal ADD COLUMN name_set BOOLEAN NOT NULL DEFAULT false")
-    await conn.execute("ALTER TABLE portal ADD COLUMN avatar_set BOOLEAN NOT NULL DEFAULT false")
-    await conn.execute("UPDATE portal SET name_set=true WHERE title<>'' AND mxid<>''")
-    await conn.execute("UPDATE portal SET avatar_set=true WHERE photo_id<>'' AND mxid<>''")
@@ -1,23 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Store phone number in puppet table")
-async def upgrade_v7(conn: Connection) -> None:
-    await conn.execute("ALTER TABLE puppet ADD COLUMN phone TEXT")
@@ -1,24 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Track first event ID in portals for infinite backfilling")
-async def upgrade_v8(conn: Connection) -> None:
-    await conn.execute("ALTER TABLE portal ADD COLUMN first_event_id TEXT")
-    await conn.execute("ALTER TABLE portal ADD COLUMN next_batch_id TEXT")
@@ -1,23 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Add index to puppet username column")
-async def upgrade_v9(conn: Connection) -> None:
-    await conn.execute("CREATE INDEX puppet_username_idx ON puppet(LOWER(username))")
@@ -1,23 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Add more portal columns related to infinite backfill")
-async def upgrade_v10(conn: Connection) -> None:
-    await conn.execute("ALTER TABLE portal ADD COLUMN base_insertion_id TEXT")
@@ -1,45 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 Tulir Asokan, Sumner Evans
-#
-# 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 mautrix.util.async_db import Connection, Scheme
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Add the backfill queue table")
-async def upgrade_v11(conn: Connection, scheme: Scheme) -> None:
-    gen = ""
-    if scheme in (Scheme.POSTGRES, Scheme.COCKROACH):
-        gen = "GENERATED ALWAYS AS IDENTITY"
-    await conn.execute(
-        f"""
-        CREATE TABLE backfill_queue (
-            queue_id            INTEGER PRIMARY KEY {gen},
-            user_mxid           TEXT,
-            priority            INTEGER NOT NULL,
-            portal_tgid         BIGINT,
-            portal_tg_receiver  BIGINT,
-            messages_per_batch  INTEGER NOT NULL,
-            post_batch_delay    INTEGER NOT NULL,
-            max_batches         INTEGER NOT NULL,
-            dispatch_time       TIMESTAMP,
-            completed_at        TIMESTAMP,
-            cooldown_timeout    TIMESTAMP,
-            FOREIGN KEY (user_mxid) REFERENCES "user"(mxid) ON DELETE CASCADE ON UPDATE CASCADE,
-            FOREIGN KEY (portal_tgid, portal_tg_receiver)
-                REFERENCES portal(tgid, tg_receiver) ON DELETE CASCADE
-        )
-        """
-    )
@@ -1,24 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Store sender in message table")
-async def upgrade_v12(conn: Connection) -> None:
-    await conn.execute("ALTER TABLE message ADD COLUMN sender_mxid TEXT")
-    await conn.execute("ALTER TABLE message ADD COLUMN sender BIGINT")
@@ -1,54 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection, Scheme
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Allow multiple reactions from the same user")
-async def upgrade_v13(conn: Connection, scheme: Scheme) -> None:
-    await conn.execute("CREATE INDEX telegram_file_mxc_idx ON telegram_file(mxc)")
-    await conn.execute('ALTER TABLE "user" ADD COLUMN is_premium BOOLEAN NOT NULL DEFAULT false')
-    await conn.execute("ALTER TABLE puppet ADD COLUMN is_premium BOOLEAN NOT NULL DEFAULT false")
-    if scheme == Scheme.POSTGRES:
-        await conn.execute(
-            """
-            ALTER TABLE reaction
-                DROP CONSTRAINT reaction_pkey,
-                ADD CONSTRAINT reaction_pkey PRIMARY KEY (msg_mxid, mx_room, tg_sender, reaction)
-            """
-        )
-    else:
-        await conn.execute(
-            """CREATE TABLE new_reaction (
-                mxid      TEXT NOT NULL,
-                mx_room   TEXT NOT NULL,
-                msg_mxid  TEXT NOT NULL,
-                tg_sender BIGINT,
-                reaction  TEXT NOT NULL,
-
-                PRIMARY KEY (msg_mxid, mx_room, tg_sender, reaction),
-                UNIQUE (mxid, mx_room)
-            )"""
-        )
-        await conn.execute(
-            """
-            INSERT INTO new_reaction (mxid, mx_room, msg_mxid, tg_sender, reaction)
-            SELECT mxid, mx_room, msg_mxid, tg_sender, reaction FROM reaction
-            """
-        )
-        await conn.execute("DROP TABLE reaction")
-        await conn.execute("ALTER TABLE new_reaction RENAME TO reaction")
@@ -1,23 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Add index to puppet custom_mxid column")
-async def upgrade_v14(conn: Connection) -> None:
-    await conn.execute("CREATE INDEX IF NOT EXISTS puppet_custom_mxid_idx ON puppet(custom_mxid)")
@@ -1,23 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Store lowest message ID in backfill queue")
-async def upgrade_v15(conn: Connection) -> None:
-    await conn.execute("ALTER TABLE backfill_queue ADD COLUMN anchor_msg_id BIGINT")
@@ -1,28 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection, Scheme
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Add type for backfill queue items")
-async def upgrade_v16(conn: Connection, scheme: Scheme) -> None:
-    await conn.execute(
-        "ALTER TABLE backfill_queue ADD COLUMN type TEXT NOT NULL DEFAULT 'historical'"
-    )
-    await conn.execute("ALTER TABLE backfill_queue ADD COLUMN extra_data jsonb")
-    if scheme != Scheme.SQLITE:
-        await conn.execute("ALTER TABLE backfill_queue ALTER COLUMN type DROP DEFAULT")
@@ -1,25 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Add index for Message.find_recent")
-async def upgrade_v17(conn: Connection) -> None:
-    await conn.execute(
-        "CREATE INDEX IF NOT EXISTS message_mx_room_and_tgid_idx ON message(mx_room, tgid DESC)"
-    )
@@ -1,25 +0,0 @@
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2022 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 mautrix.util.async_db import Connection
-
-from . import upgrade_table
-
-
-@upgrade_table.register(description="Add contact_info_set column to puppet table")
-async def upgrade_v18(conn: Connection) -> None:
-    await conn.execute(
-        "ALTER TABLE puppet ADD COLUMN contact_info_set BOOLEAN NOT NULL DEFAULT false"
-    )
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,146 +14,117 @@
 #
 # 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 __future__ import annotations
+from sqlalchemy import Column, ForeignKey, ForeignKeyConstraint, Integer, String
+from sqlalchemy.engine.result import RowProxy
+from typing import Optional, Iterable, Tuple

-from typing import TYPE_CHECKING, ClassVar, Iterable
-
-from asyncpg import Record
-from attr import dataclass
-
-from mautrix.types import UserID
-from mautrix.util.async_db import Connection, Database, Scheme
-
-from ..types import TelegramID
-from .backfill_queue import Backfill
-
-fake_db = Database.create("") if TYPE_CHECKING else None
+from ..types import MatrixUserID, TelegramID
+from .base import Base


-@dataclass
-class User:
-    db: ClassVar[Database] = fake_db
+class User(Base):
+    __tablename__ = "user"

-    mxid: UserID
-    tgid: TelegramID | None
-    tg_username: str | None
-    tg_phone: str | None
-    is_bot: bool
-    is_premium: bool
-    saved_contacts: int
+    mxid = Column(String, primary_key=True)  # type: MatrixUserID
+    tgid = Column(Integer, nullable=True, unique=True)  # type: Optional[TelegramID]
+    tg_username = Column(String, nullable=True)
+    tg_phone = Column(String, nullable=True)
+    saved_contacts = Column(Integer, default=0, nullable=False)

    @classmethod
-    def _from_row(cls, row: Record | None) -> User | None:
-        if row is None:
+    def _one_or_none(cls, rows: RowProxy) -> Optional['User']:
+        try:
+            mxid, tgid, tg_username, tg_phone, saved_contacts = next(rows)
+            return cls(mxid=mxid, tgid=tgid, tg_username=tg_username, tg_phone=tg_phone,
+                       saved_contacts=saved_contacts)
+        except StopIteration:
            return None
-        return cls(**row)
-
-    columns: ClassVar[str] = ", ".join(
-        ("mxid", "tgid", "tg_username", "tg_phone", "is_bot", "is_premium", "saved_contacts")
-    )

    @classmethod
-    async def get_by_tgid(cls, tgid: TelegramID) -> User | None:
-        q = f'SELECT {cls.columns} FROM "user" WHERE tgid=$1'
-        return cls._from_row(await cls.db.fetchrow(q, tgid))
+    def all(cls) -> Iterable['User']:
+        rows = cls.db.execute(cls.t.select())
+        for row in rows:
+            mxid, tgid, tg_username, tg_phone, saved_contacts = row
+            yield cls(mxid=mxid, tgid=tgid, tg_username=tg_username, tg_phone=tg_phone,
+                      saved_contacts=saved_contacts)

    @classmethod
-    async def get_by_mxid(cls, mxid: UserID) -> User | None:
-        q = f'SELECT {cls.columns} FROM "user" WHERE mxid=$1'
-        return cls._from_row(await cls.db.fetchrow(q, mxid))
+    def get_by_tgid(cls, tgid: TelegramID) -> Optional['User']:
+        return cls._select_one_or_none(cls.c.tgid == tgid)

    @classmethod
-    async def find_by_username(cls, username: str) -> User | None:
-        q = f'SELECT {cls.columns} FROM "user" WHERE lower(tg_username)=$1'
-        return cls._from_row(await cls.db.fetchrow(q, username.lower()))
+    def get_by_mxid(cls, mxid: MatrixUserID) -> Optional['User']:
+        return cls._select_one_or_none(cls.c.mxid == mxid)

    @classmethod
-    async def all_with_tgid(cls) -> list[User]:
-        q = f'SELECT {cls.columns} FROM "user" WHERE tgid IS NOT NULL'
-        return [cls._from_row(row) for row in await cls.db.fetch(q)]
-
-    async def delete(self) -> None:
-        await self.db.execute('DELETE FROM "user" WHERE mxid=$1', self.mxid)
-
-    async def remove_tgid(self) -> None:
-        async with self.db.acquire() as conn, conn.transaction():
-            if self.tgid:
-                await conn.execute('DELETE FROM contact WHERE "user"=$1', self.tgid)
-                await conn.execute('DELETE FROM user_portal WHERE "user"=$1', self.tgid)
-            await Backfill.delete_all(self.mxid, conn=conn)
-            self.tgid = None
-            self.tg_username = None
-            self.tg_phone = None
-            self.is_bot = False
-            self.is_premium = False
-            self.saved_contacts = 0
-            await self.save(conn=conn)
+    def get_by_username(cls, username: str) -> Optional['User']:
+        return cls._select_one_or_none(cls.c.tg_username == username)

    @property
-    def _values(self):
-        return (
-            self.mxid,
-            self.tgid,
-            self.tg_username,
-            self.tg_phone,
-            self.is_bot,
-            self.is_premium,
-            self.saved_contacts,
-        )
+    def _edit_identity(self):
+        return self.c.mxid == self.mxid

-    async def save(self, conn: Connection | None = None) -> None:
-        q = """
-        UPDATE "user" SET tgid=$2, tg_username=$3, tg_phone=$4, is_bot=$5, is_premium=$6,
-                          saved_contacts=$7
-        WHERE mxid=$1
-        """
-        await (conn or self.db).execute(q, *self._values)
+    def insert(self) -> None:
+        with self.db.begin() as conn:
+            conn.execute(self.t.insert().values(
+                mxid=self.mxid, tgid=self.tgid, tg_username=self.tg_username,
+                tg_phone=self.tg_phone, saved_contacts=self.saved_contacts))

-    async def insert(self) -> None:
-        q = """
-        INSERT INTO "user" (mxid, tgid, tg_username, tg_phone, is_bot, is_premium, saved_contacts)
-        VALUES ($1, $2, $3, $4, $5, $6, $7)
-        """
-        await self.db.execute(q, *self._values)
+    @property
+    def contacts(self) -> Iterable[TelegramID]:
+        rows = self.db.execute(Contact.t.select().where(Contact.c.user == self.tgid))
+        for row in rows:
+            user, contact = row
+            yield contact

-    async def get_contacts(self) -> list[TelegramID]:
-        rows = await self.db.fetch('SELECT contact FROM contact WHERE "user"=$1', self.tgid)
-        return [TelegramID(row["contact"]) for row in rows]
+    @contacts.setter
+    def contacts(self, puppets: Iterable[TelegramID]) -> None:
+        with self.db.begin() as conn:
+            conn.execute(Contact.t.delete().where(Contact.c.user == self.tgid))
+            insert_puppets = [{"user": self.tgid, "contact": tgid} for tgid in puppets]
+            if insert_puppets:
+                conn.execute(Contact.t.insert(), insert_puppets)

-    async def set_contacts(self, puppets: Iterable[TelegramID]) -> None:
-        columns = ["user", "contact"]
-        records = [(self.tgid, puppet_id) for puppet_id in puppets]
-        async with self.db.acquire() as conn, conn.transaction():
-            await conn.execute('DELETE FROM contact WHERE "user"=$1', self.tgid)
-            if self.db.scheme == Scheme.POSTGRES:
-                await conn.copy_records_to_table("contact", records=records, columns=columns)
-            else:
-                q = 'INSERT INTO contact ("user", contact) VALUES ($1, $2)'
-                await conn.executemany(q, records)
+    @property
+    def portals(self) -> Iterable[Tuple[TelegramID, TelegramID]]:
+        rows = self.db.execute(UserPortal.t.select().where(UserPortal.c.user == self.tgid))
+        for row in rows:
+            user, portal, portal_receiver = row
+            yield (portal, portal_receiver)

-    async def get_portals(self) -> list[tuple[TelegramID, TelegramID]]:
-        q = 'SELECT portal, portal_receiver FROM user_portal WHERE "user"=$1'
-        rows = await self.db.fetch(q, self.tgid)
-        return [(TelegramID(row["portal"]), TelegramID(row["portal_receiver"])) for row in rows]
+    @portals.setter
+    def portals(self, portals: Iterable[Tuple[TelegramID, TelegramID]]) -> None:
+        with self.db.begin() as conn:
+            conn.execute(UserPortal.t.delete().where(UserPortal.c.user == self.tgid))
+            insert_portals = [{
+                "user": self.tgid,
+                "portal": tgid,
+                "portal_receiver": tg_receiver
+            } for tgid, tg_receiver in portals]
+            if insert_portals:
+                conn.execute(UserPortal.t.insert(), insert_portals)

-    async def set_portals(self, portals: Iterable[tuple[TelegramID, TelegramID]]) -> None:
-        columns = ["user", "portal", "portal_receiver"]
-        records = [(self.tgid, tgid, tg_receiver) for tgid, tg_receiver in portals]
-        async with self.db.acquire() as conn, conn.transaction():
-            await conn.execute('DELETE FROM user_portal WHERE "user"=$1', self.tgid)
-            if self.db.scheme == Scheme.POSTGRES:
-                await conn.copy_records_to_table("user_portal", records=records, columns=columns)
-            else:
-                q = 'INSERT INTO user_portal ("user", portal, portal_receiver) VALUES ($1, $2, $3)'
-                await conn.executemany(q, records)
+    def delete(self) -> None:
+        super().delete()
+        self.portals = []
+        self.contacts = []

-    async def register_portal(self, tgid: TelegramID, tg_receiver: TelegramID) -> None:
-        q = (
-            'INSERT INTO user_portal ("user", portal, portal_receiver) VALUES ($1, $2, $3) '
-            'ON CONFLICT ("user", portal, portal_receiver) DO NOTHING'
-        )
-        await self.db.execute(q, self.tgid, tgid, tg_receiver)

-    async def unregister_portal(self, tgid: TelegramID, tg_receiver: TelegramID) -> None:
-        q = 'DELETE FROM user_portal WHERE "user"=$1 AND portal=$2 AND portal_receiver=$3'
-        await self.db.execute(q, self.tgid, tgid, tg_receiver)
+class UserPortal(Base):
+    __tablename__ = "user_portal"
+
+    user = Column(Integer, ForeignKey("user.tgid", onupdate="CASCADE", ondelete="CASCADE"),
+                  primary_key=True)  # type: TelegramID
+    portal = Column(Integer, primary_key=True)  # type: TelegramID
+    portal_receiver = Column(Integer, primary_key=True)  # type: TelegramID
+
+    __table_args__ = (ForeignKeyConstraint(("portal", "portal_receiver"),
+                                           ("portal.tgid", "portal.tg_receiver"),
+                                           onupdate="CASCADE", ondelete="CASCADE"),)
+
+
+class Contact(Base):
+    __tablename__ = "contact"
+
+    user = Column(Integer, ForeignKey("user.tgid"), primary_key=True)  # type: TelegramID
+    contact = Column(Integer, ForeignKey("puppet.id"), primary_key=True)  # type: TelegramID
@@ -0,0 +1,69 @@
+# -*- coding: future_fstrings -*-
+# 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 sqlalchemy import Column, String, and_
+from typing import Dict, Optional
+
+from ..types import MatrixUserID, MatrixRoomID
+from .base import Base
+
+
+class UserProfile(Base):
+    __tablename__ = "mx_user_profile"
+
+    room_id = Column(String, primary_key=True)  # type: MatrixRoomID
+    user_id = Column(String, primary_key=True)  # type: MatrixUserID
+    membership = Column(String, nullable=False, default="leave")
+    displayname = Column(String, nullable=True)
+    avatar_url = Column(String, nullable=True)
+
+    def dict(self) -> Dict[str, str]:
+        return {
+            "membership": self.membership,
+            "displayname": self.displayname,
+            "avatar_url": self.avatar_url,
+        }
+
+    @classmethod
+    def get(cls, room_id: MatrixRoomID, user_id: MatrixUserID) -> Optional['UserProfile']:
+        rows = cls.db.execute(
+            cls.t.select().where(and_(cls.c.room_id == room_id, cls.c.user_id == user_id)))
+        try:
+            room_id, user_id, membership, displayname, avatar_url = next(rows)
+            return cls(room_id=room_id, user_id=user_id, membership=membership,
+                       displayname=displayname, avatar_url=avatar_url)
+        except StopIteration:
+            return None
+
+    @classmethod
+    def delete_all(cls, room_id: MatrixRoomID) -> None:
+        with cls.db.begin() as conn:
+            conn.execute(cls.t.delete().where(cls.c.room_id == room_id))
+
+    def update(self) -> None:
+        super().update(membership=self.membership, displayname=self.displayname,
+                       avatar_url=self.avatar_url)
+
+    @property
+    def _edit_identity(self):
+        return and_(self.c.room_id == self.room_id, self.c.user_id == self.user_id)
+
+    def insert(self) -> None:
+        with self.db.begin() as conn:
+            conn.execute(self.t.insert().values(room_id=self.room_id, user_id=self.user_id,
+                                                membership=self.membership,
+                                                displayname=self.displayname,
+                                                avatar_url=self.avatar_url))
@@ -1,672 +0,0 @@
-# Homeserver details
-homeserver:
-    # The address that this appservice can use to connect to the homeserver.
-    address: https://example.com
-    # The domain of the homeserver (for MXIDs, etc).
-    domain: example.com
-    # Whether or not to verify the SSL certificate of the homeserver.
-    # Only applies if address starts with https://
-    verify_ssl: true
-    # What software is the homeserver running?
-    # Standard Matrix homeservers like Synapse, Dendrite and Conduit should just use "standard" here.
-    software: standard
-    # Number of retries for all HTTP requests if the homeserver isn't reachable.
-    http_retry_count: 4
-    # The URL to push real-time bridge status to.
-    # If set, the bridge will make POST requests to this URL whenever a user's Telegram connection state changes.
-    # The bridge will use the appservice as_token to authorize requests.
-    status_endpoint: null
-    # Endpoint for reporting per-message status.
-    message_send_checkpoint_endpoint: null
-    # Whether asynchronous uploads via MSC2246 should be enabled for media.
-    # Requires a media repo that supports MSC2246.
-    async_media: false
-
-# Application service host/registration related details
-# Changing these values requires regeneration of the registration.
-appservice:
-    # The address that the homeserver can use to connect to this appservice.
-    address: http://localhost:29317
-    # When using https:// the TLS certificate and key files for the address.
-    tls_cert: false
-    tls_key: false
-
-    # The hostname and port where this appservice should listen.
-    hostname: 0.0.0.0
-    port: 29317
-    # The maximum body size of appservice API requests (from the homeserver) in mebibytes
-    # Usually 1 is enough, but on high-traffic bridges you might need to increase this to avoid 413s
-    max_body_size: 1
-
-    # The full URI to the database. SQLite and Postgres are supported.
-    # Format examples:
-    #   SQLite:   sqlite:filename.db
-    #   Postgres: postgres://username:password@hostname/dbname
-    database: postgres://username:password@hostname/dbname
-    # Additional arguments for asyncpg.create_pool() or sqlite3.connect()
-    # https://magicstack.github.io/asyncpg/current/api/index.html#asyncpg.pool.create_pool
-    # https://docs.python.org/3/library/sqlite3.html#sqlite3.connect
-    # For sqlite, min_size is used as the connection thread pool size and max_size is ignored.
-    # Additionally, SQLite supports init_commands as an array of SQL queries to run on connect (e.g. to set PRAGMAs).
-    database_opts:
-        min_size: 1
-        max_size: 10
-
-    # Public part of web server for out-of-Matrix interaction with the bridge.
-    # Used for things like login if the user wants to make sure the 2FA password isn't stored in
-    # the HS database.
-    public:
-        # Whether or not the public-facing endpoints should be enabled.
-        enabled: false
-        # The prefix to use in the public-facing endpoints.
-        prefix: /public
-        # The base URL where the public-facing endpoints are available. The prefix is not added
-        # implicitly.
-        external: https://example.com/public
-
-    # Provisioning API part of the web server for automated portal creation and fetching information.
-    # Used by things like mautrix-manager (https://github.com/tulir/mautrix-manager).
-    provisioning:
-        # Whether or not the provisioning API should be enabled.
-        enabled: true
-        # The prefix to use in the provisioning API endpoints.
-        prefix: /_matrix/provision
-        # The shared secret to authorize users of the API.
-        # Set to "generate" to generate and save a new token.
-        shared_secret: generate
-
-    # The unique ID of this appservice.
-    id: telegram
-    # Username of the appservice bot.
-    bot_username: telegrambot
-    # Display name and avatar for bot. Set to "remove" to remove display name/avatar, leave empty
-    # to leave display name/avatar as-is.
-    bot_displayname: Telegram bridge bot
-    bot_avatar: mxc://maunium.net/tJCRmUyJDsgRNgqhOgoiHWbX
-
-    # Whether or not to receive ephemeral events via appservice transactions.
-    # Requires MSC2409 support (i.e. Synapse 1.22+).
-    # You should disable bridge -> sync_with_custom_puppets when this is enabled.
-    ephemeral_events: true
-
-    # Authentication tokens for AS <-> HS communication. Autogenerated; do not modify.
-    as_token: "This value is generated when generating the registration"
-    hs_token: "This value is generated when generating the registration"
-
-# Prometheus telemetry config. Requires prometheus-client to be installed.
-metrics:
-    enabled: false
-    listen_port: 8000
-
-# Manhole config.
-manhole:
-    # Whether or not opening the manhole is allowed.
-    enabled: false
-    # The path for the unix socket.
-    path: /var/tmp/mautrix-telegram.manhole
-    # The list of UIDs who can be added to the whitelist.
-    # If empty, any UIDs can be specified in the open-manhole command.
-    whitelist:
-    - 0
-
-# Bridge config
-bridge:
-    # Localpart template of MXIDs for Telegram users.
-    # {userid} is replaced with the user ID of the Telegram user.
-    username_template: "telegram_{userid}"
-    # Localpart template of room aliases for Telegram portal rooms.
-    # {groupname} is replaced with the name part of the public channel/group invite link ( https://t.me/{} )
-    alias_template: "telegram_{groupname}"
-    # Displayname template for Telegram users.
-    # {displayname} is replaced with the display name of the Telegram user.
-    displayname_template: "{displayname} (Telegram)"
-
-    # Set the preferred order of user identifiers which to use in the Matrix puppet display name.
-    # In the (hopefully unlikely) scenario that none of the given keys are found, the numeric user
-    # ID is used.
-    #
-    # If the bridge is working properly, a phone number or an username should always be known, but
-    # the other one can very well be empty.
-    #
-    # Valid keys:
-    #   "full name"          (First and/or last name)
-    #   "full name reversed" (Last and/or first name)
-    #   "first name"
-    #   "last name"
-    #   "username"
-    #   "phone number"
-    displayname_preference:
-    - full name
-    - username
-    - phone number
-    # Maximum length of displayname
-    displayname_max_length: 100
-    # Remove avatars from Telegram ghost users when removed on Telegram. This is disabled by default
-    # as there's no way to determine whether an avatar is removed or just hidden from some users. If
-    # you're on a single-user instance, this should be safe to enable.
-    allow_avatar_remove: false
-    # Should contact names and profile pictures be allowed?
-    # This is only safe to enable on single-user instances.
-    allow_contact_info: false
-
-    # Maximum number of members to sync per portal when starting up. Other members will be
-    # synced when they send messages. The maximum is 10000, after which the Telegram server
-    # will not send any more members.
-    # -1 means no limit (which means it's limited to 10000 by the server)
-    max_initial_member_sync: 100
-    # Maximum number of participants in chats to bridge. Only applies when the portal is being created.
-    # If there are more members when trying to create a room, the room creation will be cancelled.
-    # -1 means no limit (which means all chats can be bridged)
-    max_member_count: -1
-    # Whether or not to sync the member list in channels.
-    # If no channel admins have logged into the bridge, the bridge won't be able to sync the member
-    # list regardless of this setting.
-    sync_channel_members: false
-    # Whether or not to skip deleted members when syncing members.
-    skip_deleted_members: true
-    # Whether or not to automatically synchronize contacts and chats of Matrix users logged into
-    # their Telegram account at startup.
-    startup_sync: false
-    # Number of most recently active dialogs to check when syncing chats.
-    # Set to 0 to remove limit.
-    sync_update_limit: 0
-    # Number of most recently active dialogs to create portals for when syncing chats.
-    # Set to 0 to remove limit.
-    sync_create_limit: 15
-    # Should all chats be scheduled to be created later?
-    # This is best used in combination with MSC2716 infinite backfill.
-    sync_deferred_create_all: false
-    # Whether or not to sync and create portals for direct chats at startup.
-    sync_direct_chats: false
-    # The maximum number of simultaneous Telegram deletions to handle.
-    # A large number of simultaneous redactions could put strain on your homeserver.
-    max_telegram_delete: 10
-    # Whether or not to automatically sync the Matrix room state (mostly unpuppeted displaynames)
-    # at startup and when creating a bridge.
-    sync_matrix_state: true
-    # Allow logging in within Matrix. If false, users can only log in using login-qr or the
-    # out-of-Matrix login website (see appservice.public config section)
-    allow_matrix_login: true
-    # Whether or not to make portals of publicly joinable channels/supergroups publicly joinable on Matrix.
-    public_portals: false
-    # Whether or not to use /sync to get presence, read receipts and typing notifications
-    # when double puppeting is enabled
-    sync_with_custom_puppets: false
-    # Whether or not to update the m.direct account data event when double puppeting is enabled.
-    # Note that updating the m.direct event is not atomic (except with mautrix-asmux)
-    # and is therefore prone to race conditions.
-    sync_direct_chat_list: false
-    # Servers to always allow double puppeting from
-    double_puppet_server_map:
-        example.com: https://example.com
-    # Allow using double puppeting from any server with a valid client .well-known file.
-    double_puppet_allow_discovery: false
-    # Shared secrets for https://github.com/devture/matrix-synapse-shared-secret-auth
-    #
-    # If set, custom puppets will be enabled automatically for local users
-    # instead of users having to find an access token and run `login-matrix`
-    # manually.
-    # If using this for other servers than the bridge's server,
-    # you must also set the URL in the double_puppet_server_map.
-    login_shared_secret_map:
-        example.com: foobar
-    # Set to false to disable link previews in messages sent to Telegram.
-    telegram_link_preview: true
-    # Whether or not the !tg join command should do a HTTP request
-    # to resolve redirects in invite links.
-    invite_link_resolve: false
-    # Send captions in the same message as images. This will send data compatible with both MSC2530 and MSC3552.
-    # This is currently not supported in most clients.
-    caption_in_message: false
-    # Maximum size of image in megabytes before sending to Telegram as a document.
-    image_as_file_size: 10
-    # Maximum number of pixels in an image before sending to Telegram as a document. Defaults to 4096x4096 = 16777216.
-    image_as_file_pixels: 16777216
-    # Enable experimental parallel file transfer, which makes uploads/downloads much faster by
-    # streaming from/to Matrix and using many connections for Telegram.
-    # Note that generating HQ thumbnails for videos is not possible with streamed transfers.
-    # This option uses internal Telethon implementation details and may break with minor updates.
-    parallel_file_transfer: false
-    # Whether or not created rooms should have federation enabled.
-    # If false, created portal rooms will never be federated.
-    federate_rooms: true
-    # Should the bridge send all unicode reactions as custom emoji reactions to Telegram?
-    # By default, the bridge only uses custom emojis for unicode emojis that aren't allowed in reactions.
-    always_custom_emoji_reaction: false
-    # Settings for converting animated stickers.
-    animated_sticker:
-        # Format to which animated stickers should be converted.
-        # disable - No conversion, send as-is (gzipped lottie)
-        # png - converts to non-animated png (fastest),
-        # gif - converts to animated gif
-        # webm - converts to webm video, requires ffmpeg executable with vp9 codec and webm container support
-        # webp - converts to animated webp, requires ffmpeg executable with webp codec/container support
-        target: gif
-        # Should video stickers be converted to the specified format as well?
-        convert_from_webm: false
-        # Arguments for converter. All converters take width and height.
-        args:
-            width: 256
-            height: 256
-            fps: 25 # only for webm, webp and gif (2, 5, 10, 20 or 25 recommended)
-    # Settings for converting animated emoji.
-    # Same as animated_sticker, but webm is not supported as the target
-    # (because inline images can only contain images, not videos).
-    animated_emoji:
-        target: webp
-        args:
-            width: 64
-            height: 64
-            fps: 25
-    # End-to-bridge encryption support options.
-    #
-    # See https://docs.mau.fi/bridges/general/end-to-bridge-encryption.html for more info.
-    encryption:
-        # Allow encryption, work in group chat rooms with e2ee enabled
-        allow: false
-        # Default to encryption, force-enable encryption in all portals the bridge creates
-        # This will cause the bridge bot to be in private chats for the encryption to work properly.
-        default: false
-        # Whether to use MSC2409/MSC3202 instead of /sync long polling for receiving encryption-related data.
-        appservice: false
-        # Require encryption, drop any unencrypted messages.
-        require: false
-        # Enable key sharing? If enabled, key requests for rooms where users are in will be fulfilled.
-        # You must use a client that supports requesting keys from other users to use this feature.
-        allow_key_sharing: false
-        # Options for deleting megolm sessions from the bridge.
-        delete_keys:
-            # Beeper-specific: delete outbound sessions when hungryserv confirms
-            # that the user has uploaded the key to key backup.
-            delete_outbound_on_ack: false
-            # Don't store outbound sessions in the inbound table.
-            dont_store_outbound: false
-            # Ratchet megolm sessions forward after decrypting messages.
-            ratchet_on_decrypt: false
-            # Delete fully used keys (index >= max_messages) after decrypting messages.
-            delete_fully_used_on_decrypt: false
-            # Delete previous megolm sessions from same device when receiving a new one.
-            delete_prev_on_new_session: false
-            # Delete megolm sessions received from a device when the device is deleted.
-            delete_on_device_delete: false
-            # Periodically delete megolm sessions when 2x max_age has passed since receiving the session.
-            periodically_delete_expired: false
-            # Delete inbound megolm sessions that don't have the received_at field used for
-            # automatic ratcheting and expired session deletion. This is meant as a migration
-            # to delete old keys prior to the bridge update.
-            delete_outdated_inbound: false
-        # What level of device verification should be required from users?
-        #
-        # Valid levels:
-        #   unverified - Send keys to all device in the room.
-        #   cross-signed-untrusted - Require valid cross-signing, but trust all cross-signing keys.
-        #   cross-signed-tofu - Require valid cross-signing, trust cross-signing keys on first use (and reject changes).
-        #   cross-signed-verified - Require valid cross-signing, plus a valid user signature from the bridge bot.
-        #                           Note that creating user signatures from the bridge bot is not currently possible.
-        #   verified - Require manual per-device verification
-        #              (currently only possible by modifying the `trust` column in the `crypto_device` database table).
-        verification_levels:
-            # Minimum level for which the bridge should send keys to when bridging messages from Telegram to Matrix.
-            receive: unverified
-            # Minimum level that the bridge should accept for incoming Matrix messages.
-            send: unverified
-            # Minimum level that the bridge should require for accepting key requests.
-            share: cross-signed-tofu
-        # Options for Megolm room key rotation. These options allow you to
-        # configure the m.room.encryption event content. See:
-        # https://spec.matrix.org/v1.3/client-server-api/#mroomencryption for
-        # more information about that event.
-        rotation:
-            # Enable custom Megolm room key rotation settings. Note that these
-            # settings will only apply to rooms created after this option is
-            # set.
-            enable_custom: false
-            # The maximum number of milliseconds a session should be used
-            # before changing it. The Matrix spec recommends 604800000 (a week)
-            # as the default.
-            milliseconds: 604800000
-            # The maximum number of messages that should be sent with a given a
-            # session before changing it. The Matrix spec recommends 100 as the
-            # default.
-            messages: 100
-
-            # Disable rotating keys when a user's devices change?
-            # You should not enable this option unless you understand all the implications.
-            disable_device_change_key_rotation: false
-
-    # Whether to explicitly set the avatar and room name for private chat portal rooms.
-    # If set to `default`, this will be enabled in encrypted rooms and disabled in unencrypted rooms.
-    # If set to `always`, all DM rooms will have explicit names and avatars set.
-    # If set to `never`, DM rooms will never have names and avatars set.
-    private_chat_portal_meta: default
-    # Disable generating reply fallbacks? Some extremely bad clients still rely on them,
-    # but they're being phased out and will be completely removed in the future.
-    disable_reply_fallbacks: false
-    # Should cross-chat replies from Telegram be bridged? Most servers and clients don't support this.
-    cross_room_replies: false
-    # Whether or not the bridge should send a read receipt from the bridge bot when a message has
-    # been sent to Telegram.
-    delivery_receipts: false
-    # Whether or not delivery errors should be reported as messages in the Matrix room.
-    delivery_error_reports: false
-    # Should errors in incoming message handling send a message to the Matrix room?
-    incoming_bridge_error_reports: false
-    # Whether the bridge should send the message status as a custom com.beeper.message_send_status event.
-    message_status_events: false
-    # Set this to true to tell the bridge to re-send m.bridge events to all rooms on the next run.
-    # This field will automatically be changed back to false after it,
-    # except if the config file is not writable.
-    resend_bridge_info: false
-    # When using double puppeting, should muted chats be muted in Matrix?
-    mute_bridging: false
-    # When using double puppeting, should pinned chats be moved to a specific tag in Matrix?
-    # The favorites tag is `m.favourite`.
-    pinned_tag: null
-    # Same as above for archived chats, the low priority tag is `m.lowpriority`.
-    archive_tag: null
-    # Whether or not mute status and tags should only be bridged when the portal room is created.
-    tag_only_on_create: true
-    # Should leaving the room on Matrix make the user leave on Telegram?
-    bridge_matrix_leave: true
-    # Should the user be kicked out of all portals when logging out of the bridge?
-    kick_on_logout: true
-    # Should the "* user joined Telegram" notice always be marked as read automatically?
-    always_read_joined_telegram_notice: true
-    # Should the bridge auto-create a group chat on Telegram when a ghost is invited to a room?
-    # Requires the user to have sufficient power level and double puppeting enabled.
-    create_group_on_invite: true
-    # Settings for backfilling messages from Telegram.
-    backfill:
-        # Allow backfilling at all?
-        enable: true
-        # Whether or not to enable backfilling in normal groups.
-        # Normal groups have numerous technical problems in Telegram, and backfilling normal groups
-        # will likely cause problems if there are multiple Matrix users in the group.
-        normal_groups: false
-
-        # If a backfilled chat is older than this number of hours, mark it as read even if it's unread on Telegram.
-        # Set to -1 to let any chat be unread.
-        unread_hours_threshold: 720
-
-        # Forward backfilling limits.
-        #
-        # Using a negative initial limit is not recommended, as it would try to backfill everything in a single batch.
-        forward_limits:
-            # Number of messages to backfill immediately after creating a portal.
-            initial:
-                user: 50
-                normal_group: 100
-                supergroup: 10
-                channel: 10
-            # Number of messages to backfill when syncing chats.
-            sync:
-                user: 100
-                normal_group: 100
-                supergroup: 100
-                channel: 100
-        # Timeout for forward backfills in seconds. If you have a high limit, you'll have to increase this too.
-        forward_timeout: 900
-
-        # Settings for incremental backfill of history. These only apply to Beeper, as upstream abandoned MSC2716.
-        incremental:
-            # Maximum number of messages to backfill per batch.
-            messages_per_batch: 100
-            # The number of seconds to wait after backfilling the batch of messages.
-            post_batch_delay: 20
-            # The maximum number of batches to backfill per portal, split by the chat type.
-            # If set to -1, all messages in the chat will eventually be backfilled.
-            max_batches:
-                # Direct chats
-                user: -1
-                # Normal groups. Note that the normal_groups option above must be enabled
-                # for these to be backfilled.
-                normal_group: -1
-                # Supergroups
-                supergroup: 10
-                # Broadcast channels
-                channel: -1
-
-    # Overrides for base power levels.
-    initial_power_level_overrides:
-        user: {}
-        group: {}
-
-    # Whether to bridge Telegram bot messages as m.notices or m.texts.
-    bot_messages_as_notices: true
-    bridge_notices:
-        # Whether or not Matrix bot messages (type m.notice) should be bridged.
-        default: false
-        # List of user IDs for whom the previous flag is flipped.
-        # e.g. if bridge_notices.default is false, notices from other users will not be bridged, but
-        #      notices from users listed here will be bridged.
-        exceptions: []
-
-    # An array of possible values for the $distinguisher variable in message formats.
-    # Each user gets one of the values here, based on a hash of their user ID.
-    # If the array is empty, the $distinguisher variable will also be empty.
-    relay_user_distinguishers: ["🟦", "🟣", "🟩", "⭕️", "🔶", "⬛️", "🔵", "🟢"]
-    # The formats to use when sending messages to Telegram via the relay bot.
-    # Text msgtypes (m.text, m.notice and m.emote) support HTML, media msgtypes don't.
-    #
-    # Available variables:
-    #   $sender_displayname - The display name of the sender (e.g. Example User)
-    #   $sender_username    - The username (Matrix ID localpart) of the sender (e.g. exampleuser)
-    #   $sender_mxid        - The Matrix ID of the sender (e.g. @exampleuser:example.com)
-    #   $distinguisher      - A random string from the options in the relay_user_distinguishers array.
-    #   $message            - The message content
-    message_formats:
-        m.text: "$distinguisher <b>$sender_displayname</b>: $message"
-        m.notice: "$distinguisher <b>$sender_displayname</b>: $message"
-        m.emote: "* $distinguisher <b>$sender_displayname</b> $message"
-        m.file: "$distinguisher <b>$sender_displayname</b> sent a file: $message"
-        m.image: "$distinguisher <b>$sender_displayname</b> sent an image: $message"
-        m.audio: "$distinguisher <b>$sender_displayname</b> sent an audio file: $message"
-        m.video: "$distinguisher <b>$sender_displayname</b> sent a video: $message"
-        m.location: "$distinguisher <b>$sender_displayname</b> sent a location: $message"
-    # Telegram doesn't have built-in emotes, this field specifies how m.emote's from authenticated
-    # users are sent to telegram. All fields in message_formats are supported. Additionally, the
-    # Telegram user info is available in the following variables:
-    #    $displayname - Telegram displayname
-    #    $username    - Telegram username (may not exist)
-    #    $mention     - Telegram @username or displayname mention (depending on which exists)
-    emote_format: "* $mention $formatted_body"
-
-    # The formats to use when sending state events to Telegram via the relay bot.
-    #
-    # Variables from `message_formats` that have the `sender_` prefix are available without the prefix.
-    # In name_change events, `$prev_displayname` is the previous displayname.
-    #
-    # Set format to an empty string to disable the messages for that event.
-    state_event_formats:
-        join: "$distinguisher <b>$displayname</b> joined the room."
-        leave: "$distinguisher <b>$displayname</b> left the room."
-        name_change: "$distinguisher <b>$prev_displayname</b> changed their name to $distinguisher <b>$displayname</b>"
-
-    # Filter rooms that can/can't be bridged. Can also be managed using the `filter` and
-    # `filter-mode` management commands.
-    #
-    # An empty blacklist will essentially disable the filter.
-    filter:
-        # Filter mode to use. Either "blacklist" or "whitelist".
-        # If the mode is "blacklist", the listed chats will never be bridged.
-        # If the mode is "whitelist", only the listed chats can be bridged.
-        mode: blacklist
-        # The list of group/channel IDs to filter.
-        list: []
-        # How to handle direct chats:
-        # If users is "null", direct chats will follow the previous settings.
-        # If users is "true", direct chats will always be bridged.
-        # If users is "false", direct chats will never be bridged.
-        users: true
-
-    # The prefix for commands. Only required in non-management rooms.
-    command_prefix: "!tg"
-
-    # Messages sent upon joining a management room.
-    # Markdown is supported. The defaults are listed below.
-    management_room_text:
-        # Sent when joining a room.
-        welcome: "Hello, I'm a Telegram bridge bot."
-        # Sent when joining a management room and the user is already logged in.
-        welcome_connected: "Use `help` for help."
-        # Sent when joining a management room and the user is not logged in.
-        welcome_unconnected: "Use `help` for help or `login` to log in."
-        # Optional extra text sent when joining a management room.
-        additional_help: ""
-
-    # Send each message separately (for readability in some clients)
-    management_room_multiple_messages: false
-
-    # Permissions for using the bridge.
-    # Permitted values:
-    #   relaybot - Only use the bridge via the relaybot, no access to commands.
-    #       user - Relaybot level + access to commands to create bridges.
-    #  puppeting - User level + logging in with a Telegram account.
-    #       full - Full access to use the bridge, i.e. previous levels + Matrix login.
-    #      admin - Full access to use the bridge and some extra administration commands.
-    # Permitted keys:
-    #        * - All Matrix users
-    #   domain - All users on that homeserver
-    #     mxid - Specific user
-    permissions:
-        "*": "relaybot"
-        "public.example.com": "user"
-        "example.com": "full"
-        "@admin:example.com": "admin"
-
-    # Options related to the message relay Telegram bot.
-    relaybot:
-        private_chat:
-            # List of users to invite to the portal when someone starts a private chat with the bot.
-            # If empty, private chats with the bot won't create a portal.
-            invite: []
-            # Whether or not to bridge state change messages in relaybot private chats.
-            state_changes: true
-            # When private_chat_invite is empty, this message is sent to users /starting the
-            # relaybot. Telegram's "markdown" is supported.
-            message: This is a Matrix bridge relaybot and does not support direct chats
-        # List of users to invite to all group chat portals created by the bridge.
-        group_chat_invite: []
-        # Whether or not the relaybot should not bridge events in unbridged group chats.
-        # If false, portals will be created when the relaybot receives messages, just like normal
-        # users. This behavior is usually not desirable, as it interferes with manually bridging
-        # the chat to another room.
-        ignore_unbridged_group_chat: true
-        # Whether or not to allow creating portals from Telegram.
-        authless_portals: true
-        # Whether or not to allow Telegram group admins to use the bot commands.
-        whitelist_group_admins: true
-        # Whether or not to ignore incoming events sent by the relay bot.
-        ignore_own_incoming_events: true
-        # List of usernames/user IDs who are also allowed to use the bot commands.
-        whitelist:
-        - myusername
-        - 12345678
-
-# Telegram config
-telegram:
-    # Get your own API keys at https://my.telegram.org/apps
-    api_id: 12345
-    api_hash: tjyd5yge35lbodk1xwzw2jstp90k55qz
-    # (Optional) Create your own bot at https://t.me/BotFather
-    bot_token: disabled
-
-    # Should the bridge request missed updates from Telegram when restarting?
-    catch_up: true
-    # Should incoming updates be handled sequentially to make sure order is preserved on Matrix?
-    sequential_updates: true
-    exit_on_update_error: false
-
-    # Telethon connection options.
-    connection:
-        # The timeout in seconds to be used when connecting.
-        timeout: 120
-        # How many times the reconnection should retry, either on the initial connection or when
-        # Telegram disconnects us. May be set to a negative or null value for infinite retries, but
-        # this is not recommended, since the program can get stuck in an infinite loop.
-        retries: 5
-        # The delay in seconds to sleep between automatic reconnections.
-        retry_delay: 1
-        # The threshold below which the library should automatically sleep on flood wait errors
-        # (inclusive). For instance, if a FloodWaitError for 17s occurs and flood_sleep_threshold
-        # is 20s, the library will sleep automatically. If the error was for 21s, it would raise
-        # the error instead. Values larger than a day (86400) will be changed to a day.
-        flood_sleep_threshold: 60
-        # How many times a request should be retried. Request are retried when Telegram is having
-        # internal issues, when there is a FloodWaitError less than flood_sleep_threshold, or when
-        # there's a migrate error. May take a negative or null value for infinite retries, but this
-        # is not recommended, since some requests can always trigger a call fail (such as searching
-        # for messages).
-        request_retries: 5
-        # Use IPv6 for Telethon connection
-        use_ipv6: false
-
-    # Device info sent to Telegram.
-    device_info:
-        # "auto" = OS name+version.
-        device_model: mautrix-telegram
-        # "auto" = Telethon version.
-        system_version: auto
-        # "auto" = mautrix-telegram version.
-        app_version: auto
-        lang_code: en
-        system_lang_code: en
-
-    # Custom server to connect to.
-    server:
-        # Set to true to use these server settings. If false, will automatically
-        # use production server assigned by Telegram. Set to false in production.
-        enabled: false
-        # The DC ID to connect to.
-        dc: 2
-        # The IP to connect to.
-        ip: 149.154.167.40
-        # The port to connect to. 443 may not work, 80 is better and both are equally secure.
-        port: 80
-
-    # Telethon proxy configuration.
-    # You must install PySocks from pip for proxies to work.
-    proxy:
-        # Allowed types: disabled, socks4, socks5, http, mtproxy
-        type: disabled
-        # Proxy IP address and port.
-        address: 127.0.0.1
-        port: 1080
-        # Whether or not to perform DNS resolving remotely. Only for socks/http proxies.
-        rdns: true
-        # Proxy authentication (optional). Put MTProxy secret in password field.
-        username: ""
-        password: ""
-
-# Python logging configuration.
-#
-# See section 16.7.2 of the Python documentation for more info:
-# https://docs.python.org/3.6/library/logging.config.html#configuration-dictionary-schema
-logging:
-    version: 1
-    formatters:
-        colored:
-            (): mautrix_telegram.util.ColorFormatter
-            format: "[%(asctime)s] [%(levelname)s@%(name)s] %(message)s"
-        normal:
-            format: "[%(asctime)s] [%(levelname)s@%(name)s] %(message)s"
-    handlers:
-        file:
-            class: logging.handlers.RotatingFileHandler
-            formatter: normal
-            filename: ./mautrix-telegram.log
-            maxBytes: 10485760
-            backupCount: 10
-        console:
-            class: logging.StreamHandler
-            formatter: colored
-    loggers:
-        mau:
-            level: DEBUG
-        telethon:
-            level: INFO
-        aiohttp:
-            level: INFO
-    root:
-        level: DEBUG
-        handlers: [file, console]
@@ -1,2 +1,8 @@
-from .from_matrix import matrix_reply_to_telegram, matrix_to_telegram
-from .from_telegram import telegram_text_to_matrix_html, telegram_to_matrix
+from .from_matrix import (matrix_reply_to_telegram, matrix_to_telegram, matrix_text_to_telegram,
+                          init_mx)
+from .from_telegram import telegram_reply_to_matrix, telegram_to_matrix
+from .. import context as c
+
+
+def init(context: c.Context) -> None:
+    init_mx(context)
@@ -1,5 +1,6 @@
+# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2021 Tulir Asokan
+# 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
@@ -13,98 +14,141 @@
 #
 # 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 __future__ import annotations
-
+from typing import Optional, List, Tuple, Callable, Pattern, Match, TYPE_CHECKING, Dict, Any
 import re
+import logging

-from telethon import TelegramClient
-from telethon.helpers import add_surrogate, del_surrogate, strip_text
-from telethon.tl.types import MessageEntityItalic, TypeMessageEntity
-
-from mautrix.types import MessageEventContent, RoomID
+from telethon.tl.types import (MessageEntityMention, MessageEntityMentionName, MessageEntityItalic,
+                               TypeMessageEntity)

+from ... import puppet as pu
+from ...types import TelegramID, MatrixRoomID
 from ...db import Message as DBMessage
-from ...types import TelegramID
-from .parser import MatrixParser
+from ..util import (add_surrogates, remove_surrogates, trim_reply_fallback_html,
+                    trim_reply_fallback_text)
+from .parser import ParsedMessage, parse_html

-command_regex = re.compile(r"^!([A-Za-z0-9@]+)")
-not_command_regex = re.compile(r"^\\(![A-Za-z0-9@]+)")
+if TYPE_CHECKING:
+    from ...context import Context

-MAX_LENGTH = 4096
-CUTOFF_TEXT = " [message cut]"
-CUT_MAX_LENGTH = MAX_LENGTH - len(CUTOFF_TEXT)
+log = logging.getLogger("mau.fmt.mx")  # type: logging.Logger
+should_bridge_plaintext_highlights = False  # type: bool
+
+command_regex = re.compile(r"^!([A-Za-z0-9@]+)")  # type: Pattern
+not_command_regex = re.compile(r"^\\(![A-Za-z0-9@]+)")  # type: Pattern
+plain_mention_regex = None  # type: Optional[Pattern]
+
+
+def plain_mention_to_html(match: Match) -> str:
+    puppet = pu.Puppet.find_by_displayname(match.group(2))
+    if puppet:
+        return (f"{match.group(1)}"
+                f"<a href='https://matrix.to/#/{puppet.mxid}'>"
+                f"{puppet.displayname}"
+                "</a>")
+    return "".join(match.groups())
+
+
+def cut_long_message(message: str, entities: List[TypeMessageEntity]) -> ParsedMessage:
+    if len(message) > 4096:
+        message = message[0:4082] + " [message cut]"
+        new_entities = []
+        for entity in entities:
+            if entity.offset > 4082:
+                continue
+            if entity.offset + entity.length > 4082:
+                entity.length = 4082 - entity.offset
+            new_entities.append(entity)
+        new_entities.append(MessageEntityItalic(4082, len(" [message cut]")))
+        entities = new_entities
+    return message, entities


 class FormatError(Exception):
    pass


-async def matrix_reply_to_telegram(
-    content: MessageEventContent, tg_space: TelegramID, room_id: RoomID | None = None
-) -> TelegramID | None:
-    event_id = content.get_reply_to()
-    if not event_id:
-        return
-    content.trim_reply_fallback()
-
-    message = await DBMessage.get_by_mxid(event_id, room_id, tg_space)
-    if message:
-        return message.tgid
-    return None
-
-
-async def matrix_to_telegram(
-    client: TelegramClient, *, text: str | None = None, html: str | None = None
-) -> tuple[str, list[TypeMessageEntity]]:
-    if html is not None:
-        return await _matrix_html_to_telegram(client, html)
-    elif text is not None:
-        return _matrix_text_to_telegram(text)
-    else:
-        raise ValueError("text or html must be provided to convert formatting")
-
-
-async def _matrix_html_to_telegram(
-    client: TelegramClient, html: str
-) -> tuple[str, list[TypeMessageEntity]]:
+def matrix_to_telegram(html: str) -> ParsedMessage:
    try:
        html = command_regex.sub(r"<command>\1</command>", html)
        html = html.replace("\t", " " * 4)
        html = not_command_regex.sub(r"\1", html)
+        if should_bridge_plaintext_highlights:
+            html = plain_mention_regex.sub(plain_mention_to_html, html)

-        parsed = await MatrixParser(client).parse(add_surrogate(html))
-        text, entities = _cut_long_message(parsed.text, parsed.telegram_entities)
-        text = del_surrogate(strip_text(text, entities))
+        text, entities = parse_html(add_surrogates(html))
+        text = remove_surrogates(text.strip())
+        text, entities = cut_long_message(text, entities)

        return text, entities
    except Exception as e:
        raise FormatError(f"Failed to convert Matrix format: {html}") from e


-def _cut_long_message(
-    message: str, entities: list[TypeMessageEntity]
-) -> tuple[str, list[TypeMessageEntity]]:
-    if len(message) > MAX_LENGTH:
-        message = message[0:CUT_MAX_LENGTH] + CUTOFF_TEXT
-        new_entities = []
-        for entity in entities:
-            if entity.offset > CUT_MAX_LENGTH:
-                continue
-            if entity.offset + entity.length > CUT_MAX_LENGTH:
-                entity.length = CUT_MAX_LENGTH - entity.offset
-            new_entities.append(entity)
-        new_entities.append(MessageEntityItalic(CUT_MAX_LENGTH, len(CUTOFF_TEXT)))
-        entities = new_entities
-    return message, entities
+def matrix_reply_to_telegram(content: Dict[str, Any], tg_space: TelegramID,
+                             room_id: Optional[MatrixRoomID] = None) -> Optional[TelegramID]:
+    relates_to = content.get("m.relates_to", None) or {}
+    if not relates_to:
+        return None
+    reply = (relates_to if relates_to.get("rel_type", None) == "m.reference"
+             else relates_to.get("m.in_reply_to", None) or {})
+    if not reply:
+        return None
+    room_id = room_id or reply.get("room_id", None)
+    event_id = reply.get("event_id", None)
+    if not event_id:
+        return
+
+    try:
+        if content["format"] == "org.matrix.custom.html":
+            content["formatted_body"] = trim_reply_fallback_html(content["formatted_body"])
+    except KeyError:
+        pass
+    content["body"] = trim_reply_fallback_text(content["body"])
+
+    message = DBMessage.get_by_mxid(event_id, room_id, tg_space)
+    if message:
+        return message.tgid
+    return None


-def _matrix_text_to_telegram(text: str) -> tuple[str, list[TypeMessageEntity]]:
+def matrix_text_to_telegram(text: str) -> ParsedMessage:
    text = command_regex.sub(r"/\1", text)
    text = text.replace("\t", " " * 4)
    text = not_command_regex.sub(r"\1", text)
-    entities = []
-    surrogated_text = add_surrogate(text)
-    if len(surrogated_text) > MAX_LENGTH:
-        surrogated_text, entities = _cut_long_message(surrogated_text, entities)
-        text = del_surrogate(surrogated_text)
+    if should_bridge_plaintext_highlights:
+        entities, pmr_replacer = plain_mention_to_text()
+        text = plain_mention_regex.sub(pmr_replacer, text)
+    else:
+        entities = []
    return text, entities
+
+
+def plain_mention_to_text() -> Tuple[List[TypeMessageEntity], Callable[[str], str]]:
+    entities = []
+
+    def replacer(match) -> str:
+        puppet = pu.Puppet.find_by_displayname(match.group(2))
+        if puppet:
+            offset = match.start()
+            length = match.end() - offset
+            if puppet.username:
+                entity = MessageEntityMention(offset, length)
+                text = f"@{puppet.username}"
+            else:
+                entity = MessageEntityMentionName(offset, length, user_id=puppet.tgid)
+                text = puppet.displayname
+            entities.append(entity)
+            return text
+        return "".join(match.groups())
+
+    return entities, replacer
+
+
+def init_mx(context: "Context") -> None:
+    global plain_mention_regex, should_bridge_plaintext_highlights
+    config = context.config
+    dn_template = config.get("bridge.displayname_template", "{displayname} (Telegram)")
+    dn_template = re.escape(dn_template).replace(re.escape("{displayname}"), "[^>]+")
+    plain_mention_regex = re.compile(f"^({dn_template})")
+    should_bridge_plaintext_highlights = config["bridge.plaintext_highlights"] or False
@@ -0,0 +1,66 @@
+# -*- coding: future_fstrings -*-
+# 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, Tuple
+
+from html.parser import HTMLParser
+
+
+class HTMLNode(list):
+    def __init__(self, tag: str, attrs: List[Tuple[str, str]]):
+        super().__init__()
+        self.tag = tag  # type: str
+        self.text = ""  # type: str
+        self.tail = ""  # type: str
+        self.attrib = dict(attrs)  # type: Dict[str, str]
+
+
+class NodeifyingParser(HTMLParser):
+    # From https://www.w3.org/TR/html5/syntax.html#writing-html-documents-elements
+    void_tags = ("area", "base", "br", "col", "command", "embed", "hr", "img", "input", "link",
+                 "meta", "param", "source", "track", "wbr")
+
+    def __init__(self):
+        super().__init__()
+        self.stack = [HTMLNode("html", [])]  # type: List[HTMLNode]
+
+    def handle_starttag(self, tag, attrs):
+        node = HTMLNode(tag, attrs)
+        self.stack[-1].append(node)
+        if tag not in self.void_tags:
+            self.stack.append(node)
+
+    def handle_startendtag(self, tag, attrs):
+        self.stack[-1].append(HTMLNode(tag, attrs))
+
+    def handle_endtag(self, tag):
+        if tag == self.stack[-1].tag:
+            self.stack.pop()
+
+    def handle_data(self, data):
+        if len(self.stack[-1]) > 0:
+            self.stack[-1][-1].tail += data
+        else:
+            self.stack[-1].text += data
+
+    def error(self, message):
+        pass
+
+
+def read_html(data: str) -> HTMLNode:
+    parser = NodeifyingParser()
+    parser.feed(data)
+    return parser.stack[0]
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Tulir Asokan	92830c3a64	Bump version to 0.6.0rc1	2019-09-03 00:23:35 +03:00
Tulir Asokan	00faab2213	Ignore Riot web brokenness in edits	2019-09-03 00:22:45 +03:00
Tulir Asokan	d6294ebb45	Fix some errors	2019-09-03 00:17:52 +03:00