Bump version to 0.10.0rc1

Fixes #375

.dockerignore

@@ -2,3 +2,9 @@
 .codeclimate.yml
 *.png
 *.md
+logs
+.venv
+start
+config.yaml
+registration.yaml
+*.db

.editorconfig

@@ -13,3 +13,6 @@ max_line_length = 99
 
 [*.{yaml,yml,py}]
 indent_style = space
+
+[.gitlab-ci.yml]
+indent_size = 2

.gitignore

@@ -1,11 +1,18 @@
-.idea/
+/.idea/
 
-.venv
+/.venv
+/env/
 pip-selfcheck.json
 *.pyc
 __pycache__
+/build
+/dist
+/*.egg-info
+/.eggs
 
-config.yaml
-registration.yaml
+/config.yaml
+/registration.yaml
 *.log*
 *.db
+*.pickle
+*.bak

.gitlab-ci.yml

@@ -0,0 +1,48 @@
+image: docker:stable
+
+stages:
+- build
+- manifest
+
+default:
+  before_script:
+  - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
+
+build amd64:
+  stage: build
+  tags:
+  - amd64
+  script:
+  - docker pull $CI_REGISTRY_IMAGE:latest || true
+  - docker build --pull --cache-from $CI_REGISTRY_IMAGE:latest --build-arg TARGETARCH=amd64 --tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-amd64 .
+  - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-amd64
+  - docker rmi $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-amd64
+  after_script:
+  - |
+    if [ "$CI_COMMIT_BRANCH" = "master" ]; then
+      apk add --update curl
+      rm -rf /var/cache/apk/*
+      curl "$NOVA_ADMIN_API_URL" -H "Content-Type: application/json" -d '{"password":"'"$NOVA_ADMIN_NIGHTLY_PASS"'","bridge":"'$NOVA_BRIDGE_TYPE'","image":"'$CI_REGISTRY_IMAGE':'$CI_COMMIT_SHA'-amd64"}'
+    fi
+
+build arm64:
+  stage: build
+  tags:
+  - arm64
+  script:
+  - docker pull $CI_REGISTRY_IMAGE:latest || true
+  - docker build --pull --cache-from $CI_REGISTRY_IMAGE:latest --build-arg TARGETARCH=arm64 --tag $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-arm64 .
+  - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-arm64
+  - docker rmi $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-arm64
+
+manifest:
+  stage: manifest
+  before_script:
+  - "mkdir -p $HOME/.docker && echo '{\"experimental\": \"enabled\"}' > $HOME/.docker/config.json"
+  - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
+  script:
+  - docker pull $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-amd64
+  - docker pull $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-arm64
+  - if [ "$CI_COMMIT_BRANCH" = "master" ]; then docker manifest create $CI_REGISTRY_IMAGE:latest $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-amd64 $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-arm64 && docker manifest push $CI_REGISTRY_IMAGE:latest; fi
+  - if [ "$CI_COMMIT_BRANCH" != "master" ]; then docker manifest create $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_NAME $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-amd64 $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-arm64 && docker manifest push $CI_REGISTRY_IMAGE:$CI_COMMIT_REF_NAME; fi
+  - docker rmi $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-amd64 $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA-arm64

.isort.cfg

@@ -0,0 +1,16 @@
+[settings]
+line_length=99
+indent=4
+
+multi_line_output=5
+
+sections=FUTURE,STDLIB,THIRDPARTY,TELETHON,MAUTRIX,FIRSTPARTY,LOCALFOLDER
+no_lines_before=LOCALFOLDER
+default_section=FIRSTPARTY
+
+known_thirdparty=aiohttp,sqlalchemy,alembic,commonmark,ruamel.yaml,PIL,moviepy,prometheus_client,yarl,mako,pkg_resources
+known_telethon=telethon,alchemysession,cryptg
+known_mautrix=mautrix
+
+balanced_wrapping=True
+length_sort=True

Dockerfile

@@ -1,40 +1,72 @@
-FROM docker.io/alpine:3.9
+FROM dock.mau.dev/tulir/lottieconverter:alpine-3.13
 
-ENV UID=1337 \
-    GID=1337 \
-    FFMPEG_BINARY=/usr/bin/ffmpeg
+ARG TARGETARCH=amd64
+
+#RUN echo $'\
+#@edge http://dl-cdn.alpinelinux.org/alpine/edge/main\n\
+#@edge http://dl-cdn.alpinelinux.org/alpine/edge/testing\n\
+#@edge http://dl-cdn.alpinelinux.org/alpine/edge/community' >> /etc/apk/repositories
 
-COPY . /opt/mautrix-telegram
-WORKDIR /opt/mautrix-telegram
 RUN apk add --no-cache \
+      python3 py3-pip py3-setuptools py3-wheel \
       py3-virtualenv \
       py3-pillow \
       py3-aiohttp \
-      py3-lxml \
       py3-magic \
       py3-sqlalchemy \
-      py3-markdown \
+      py3-telethon-session-sqlalchemy \
+      py3-alembic \
       py3-psycopg2 \
+      py3-ruamel.yaml \
+      py3-commonmark \
       # Indirect dependencies
-      py3-numpy \
-      py3-asn1crypto \
-      py3-future \
-      py3-markupsafe \
-      py3-mako \
-      py3-decorator \
-      py3-dateutil \
       py3-idna \
-      py3-six \
-      py3-asn1 \
-      py3-rsa \
+      #moviepy
+        py3-decorator \
+        py3-tqdm \
+        py3-requests \
+        #imageio
+          py3-numpy \
+      #py3-telethon@edge \ (outdated)
+        # Optional for socks proxies
+        py3-pysocks \
+        # cryptg
+          py3-cffi \
+	  py3-qrcode \
+      py3-brotli \
       # Other dependencies
-      python3-dev \
-      build-base \
       ffmpeg \
       ca-certificates \
       su-exec \
- && pip3 install .[all]
+      netcat-openbsd \
+      # encryption
+      olm-dev \
+      py3-pycryptodome \
+      py3-unpaddedbase64 \
+      py3-future \
+      bash \
+      curl \
+      jq \
+      yq
+
+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 \
+ && sed -Ei 's/psycopg2-binary.+//' optional-requirements.txt \
+ && pip3 install -r requirements.txt -r optional-requirements.txt \
+ && apk del .build-deps
+
+COPY . /opt/mautrix-telegram
+RUN apk add git && pip3 install .[speedups,hq_thumbnails,metrics,e2be] && 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
 
 VOLUME /data
+ENV UID=1337 GID=1337 \
+    FFMPEG_BINARY=/usr/bin/ffmpeg
 
 CMD ["/opt/mautrix-telegram/docker-run.sh"]

MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+include requirements.txt
+include optional-requirements.txt

README.md

@@ -1,9 +1,29 @@
 # mautrix-telegram
+![Languages](https://img.shields.io/github/languages/top/tulir/mautrix-telegram.svg)
+[![License](https://img.shields.io/github/license/tulir/mautrix-telegram.svg)](LICENSE)
+[![Release](https://img.shields.io/github/release/tulir/mautrix-telegram/all.svg)](https://github.com/tulir/mautrix-telegram/releases)
+[![GitLab CI](https://mau.dev/tulir/mautrix-telegram/badges/master/pipeline.svg)](https://mau.dev/tulir/mautrix-telegram/container_registry)
+[![Maintainability](https://img.shields.io/codeclimate/maintainability/tulir/mautrix-telegram.svg)](https://codeclimate.com/github/tulir/mautrix-telegram)
+
 A Matrix-Telegram hybrid puppeting/relaybot bridge.
 
-### [Wiki](https://github.com/tulir/mautrix-telegram/wiki)
+## Sponsors
+* [Joel Lehtonen / Zouppen](https://github.com/zouppen)
 
-### [Features & Roadmap](https://github.com/tulir/mautrix-telegram/blob/master/ROADMAP.md)
+### 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/index.html?bridge=telegram)
+  (or [with Docker](https://docs.mau.fi/bridges/python/setup/docker.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/tulir/mautrix-telegram/blob/master/ROADMAP.md)
+contains a general overview of what is supported by the bridge.
 
 ## Discussion
 Matrix room: [`#telegram:maunium.net`](https://matrix.to/#/#telegram:maunium.net)
@@ -11,4 +31,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](https://raw.githubusercontent.com/tulir/mautrix-telegram/master/preview.png)
+![Preview](preview.png)

ROADMAP.md

@@ -3,6 +3,7 @@
 * Matrix → Telegram
   * [x] Message content (text, formatting, files, etc..)
   * [x] Message redactions
+  * [x] Message edits
   * [ ] ‡ Message history
   * [x] Presence
   * [x] Typing notifications
@@ -21,9 +22,16 @@
     * [ ] ‡ Changes to displayname/avatar
 * Telegram → Matrix
   * [x] Message content (text, formatting, files, etc..)
+  * [ ] Advanced message content/media
+    * [x] Polls
+	* [x] Games
+	* [ ] Buttons
   * [x] Message deletions
   * [x] Message edits
-  * [ ] Message history
+  * [x] Message history
+    * [x] Manually (`!tg backfill`)
+    * [x] Automatically when creating portal
+    * [x] Automatically for missed messages
   * [x] Avatars
   * [x] Presence
   * [x] Typing notifications
@@ -45,9 +53,11 @@
     * [x] At startup
     * [x] When receiving invite or message
   * [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
+  * [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)
   * [ ] ‡ 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 [wiki](https://github.com/tulir/mautrix-telegram/wiki/End%E2%80%90to%E2%80%90bridge-encryption))
 
-† Information not automatically sent from source, i.e. implementation may not be possible  
+† 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

alembic/env.py

@@ -7,7 +7,8 @@ from os.path import abspath, dirname
 
 sys.path.insert(0, dirname(dirname(abspath(__file__))))
 
-from mautrix_telegram.db import Base
+from mautrix.util.db import Base
+import mautrix_telegram.db
 from mautrix_telegram.config import Config
 from alchemysession import AlchemySessionContainer
 
@@ -18,17 +19,9 @@ 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"))
+config.set_main_option("sqlalchemy.url", mxtg_config["appservice.database"].replace("%", "%%"))
 
-
-class FakeDB:
-    @staticmethod
-    def query_property():
-        return None
-
-
-AlchemySessionContainer.create_table_classes(FakeDB(), "telethon_", Base)
+AlchemySessionContainer.create_table_classes(None, "telethon_", Base)
 
 # Interpret the config file for Python logging.
 # This line sets up loggers basically.
@@ -61,7 +54,8 @@ def run_migrations_offline():
     """
     url = config.get_main_option("sqlalchemy.url")
     context.configure(
-        url=url, target_metadata=target_metadata, literal_binds=True)
+        url=url, target_metadata=target_metadata, literal_binds=True,
+        render_as_batch=True)
 
     with context.begin_transaction():
         context.run_migrations()
@@ -82,7 +76,8 @@ def run_migrations_online():
     with connectable.connect() as connection:
         context.configure(
             connection=connection,
-            target_metadata=target_metadata
+            target_metadata=target_metadata,
+            render_as_batch=True
         )
 
         with context.begin_transaction():

alembic/versions/17574c57f3f8_add_disable_updates_field_for_puppets.py

@@ -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")

alembic/versions/1fa46383a9d3_add_is_bot_field_to_puppets.py

@@ -17,7 +17,8 @@ depends_on = None
 
 
 def upgrade():
-    op.add_column('puppet', sa.Column('is_bot', sa.Boolean(), nullable=True))
+    with op.batch_alter_table("puppet") as batch_op:
+        batch_op.add_column(sa.Column('is_bot', sa.Boolean(), nullable=True))
 
 
 def downgrade():

alembic/versions/24f31fc8a72b_add_encrypted_field_for_portals.py

@@ -0,0 +1,27 @@
+"""Add encrypted field for portals
+
+Revision ID: 24f31fc8a72b
+Revises: a7c04a56041b
+Create Date: 2020-03-28 20:14:29.046699
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = "24f31fc8a72b"
+down_revision = "a7c04a56041b"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table("portal") as batch_op:
+        batch_op.add_column(sa.Column("encrypted", sa.Boolean(), nullable=False,
+                                      server_default=sa.sql.expression.false()))
+
+
+def downgrade():
+    with op.batch_alter_table("portal") as batch_op:
+        batch_op.drop_column("encrypted")

alembic/versions/30eca60587f1_add_megagroup_field_to_portals.py

@@ -16,7 +16,8 @@ depends_on = None
 
 
 def upgrade():
-    op.add_column('portal', sa.Column('megagroup', sa.Boolean()))
+    with op.batch_alter_table("portal") as batch_op:
+        batch_op.add_column(sa.Column('megagroup', sa.Boolean()))
 
 
 def downgrade():

alembic/versions/3e3745baa458_store_matrix_avatar_url_in_database.py

@@ -0,0 +1,32 @@
+"""Store Matrix avatar URL in database
+
+Revision ID: 3e3745baa458
+Revises: dff56c93da8d
+Create Date: 2020-06-15 14:32:10.454033
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '3e3745baa458'
+down_revision = 'dff56c93da8d'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('portal', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('avatar_url', sa.String(), nullable=True))
+
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('portal', schema=None) as batch_op:
+        batch_op.drop_column('avatar_url')
+
+    # ### end Alembic commands ###

alembic/versions/4f7d7ed5792a_switch_mx_user_profile_to_native_enum.py

@@ -0,0 +1,26 @@
+"""Switch mx_user_profile to native enum
+
+Revision ID: 4f7d7ed5792a
+Revises: 9e9c89b0b877
+Create Date: 2019-08-04 17:47:36.568120
+
+"""
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision = '4f7d7ed5792a'
+down_revision = '9e9c89b0b877'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    conn = op.get_bind()
+    conn.execute("UPDATE mx_user_profile SET membership=UPPER(membership)")
+    conn.execute("UPDATE mx_user_profile SET membership='LEAVE' WHERE membership='LEFT'")
+
+
+def downgrade():
+    conn = op.get_bind()
+    conn.execute("UPDATE mx_user_profile SET membership=LOWER(membership)")

alembic/versions/6ca3d74d51e4_move_state_store_to_main_database.py

@@ -5,14 +5,16 @@ 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 alembic import context, op
+import sqlalchemy.orm as orm
+import sqlalchemy as sa
+
+from mautrix.util.db import Base
+
 from mautrix_telegram.config import Config
-from mautrix_telegram.db import Base
 
 # revision identifiers, used by Alembic.
 revision = "6ca3d74d51e4"
@@ -22,7 +24,6 @@ depends_on = None
 
 
 class RoomState(Base):
-    query = None
     __tablename__ = "mx_room_state"
     __table_args__ = {"extend_existing": True}
 
@@ -31,7 +32,6 @@ class RoomState(Base):
 
 
 class UserProfile(Base):
-    query = None
     __tablename__ = "mx_user_profile"
     __table_args__ = {"extend_existing": True}
 
@@ -43,7 +43,6 @@ class UserProfile(Base):
 
 
 class Puppet(Base):
-    query = None
     __tablename__ = "puppet"
     __table_args__ = {"extend_existing": True}
 
@@ -57,7 +56,8 @@ class Puppet(Base):
 
 
 def upgrade():
-    op.add_column("puppet", sa.Column("matrix_registered", sa.Boolean(), nullable=False,
+    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),
@@ -82,7 +82,7 @@ def upgrade():
 
 def migrate_state_store():
     conn = op.get_bind()
-    session = orm.sessionmaker(bind=conn)()  # type: orm.Session
+    session: orm.Session = orm.sessionmaker(bind=conn)()
 
     try:
         with open("mx-state.json") as file:

alembic/versions/7de69cf5809e_add_matrix_redaction_state_to_message_.py

@@ -0,0 +1,25 @@
+"""Add Matrix redaction state to message table
+
+Revision ID: 7de69cf5809e
+Revises: 888275d58e57
+Create Date: 2020-12-19 12:39:57.368568
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = '7de69cf5809e'
+down_revision = '888275d58e57'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table('message', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('redacted', sa.Boolean(), server_default=sa.false(), nullable=True))
+
+
+def downgrade():
+    with op.batch_alter_table('message', schema=None) as batch_op:
+        batch_op.drop_column('redacted')

alembic/versions/888275d58e57_add_double_puppet_base_url_to_puppet_.py

@@ -0,0 +1,30 @@
+"""Add double puppet base URL to puppet table
+
+Revision ID: 888275d58e57
+Revises: a328bf4f0932
+Create Date: 2020-10-14 18:52:00.730666
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = '888275d58e57'
+down_revision = 'a328bf4f0932'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('puppet', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('base_url', sa.Text(), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('puppet', schema=None) as batch_op:
+        batch_op.drop_column('base_url')
+    # ### end Alembic commands ###

alembic/versions/990f4395afc6_store_displayname_contact_status_in_.py

@@ -0,0 +1,32 @@
+"""Store displayname contact status in puppet table
+
+Revision ID: 990f4395afc6
+Revises: 7de69cf5809e
+Create Date: 2021-01-01 11:56:54.610681
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = '990f4395afc6'
+down_revision = '7de69cf5809e'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('puppet', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('displayname_contact', sa.Boolean(), server_default=sa.true(), nullable=False))
+
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('puppet', schema=None) as batch_op:
+        batch_op.drop_column('displayname_contact')
+
+    # ### end Alembic commands ###

alembic/versions/9e9c89b0b877_add_edit_index_to_messages.py

@@ -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")

alembic/versions/a328bf4f0932_store_encryption_state_event_in_db.py

@@ -0,0 +1,38 @@
+"""Store encryption state event in db
+
+Revision ID: a328bf4f0932
+Revises: ccbaff858240
+Create Date: 2020-07-11 21:31:27.059813
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+from mautrix.client.state_store.sqlalchemy import SerializableType
+from mautrix.types import RoomEncryptionStateEventContent
+
+# revision identifiers, used by Alembic.
+revision = 'a328bf4f0932'
+down_revision = 'ccbaff858240'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('mx_room_state', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('encryption',
+                                      SerializableType(RoomEncryptionStateEventContent),
+                                      nullable=True))
+        batch_op.add_column(sa.Column('has_full_member_list', sa.Boolean(), nullable=True))
+        batch_op.add_column(sa.Column('is_encrypted', sa.Boolean(), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('mx_room_state', schema=None) as batch_op:
+        batch_op.drop_column('is_encrypted')
+        batch_op.drop_column('has_full_member_list')
+        batch_op.drop_column('encryption')
+    # ### end Alembic commands ###

alembic/versions/a7c04a56041b_store_custom_puppet_next_batch_in_.py

@@ -0,0 +1,26 @@
+"""Store custom puppet next_batch in database
+
+Revision ID: a7c04a56041b
+Revises: 4f7d7ed5792a
+Create Date: 2019-08-06 23:08:51.087651
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = "a7c04a56041b"
+down_revision = "4f7d7ed5792a"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table("puppet") as batch_op:
+        batch_op.add_column(sa.Column("next_batch", sa.String(), nullable=True))
+
+
+def downgrade():
+    with op.batch_alter_table("puppet") as batch_op:
+        batch_op.drop_column("next_batch")

alembic/versions/bfc0a39bfe02_store_displayname_quality_in_puppet_.py

@@ -0,0 +1,32 @@
+"""Store displayname quality in puppet table
+
+Revision ID: bfc0a39bfe02
+Revises: ec1d3dcc77e9
+Create Date: 2021-03-23 20:03:08.825333
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = 'bfc0a39bfe02'
+down_revision = 'ec1d3dcc77e9'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('puppet', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('displayname_quality', sa.Integer(), server_default='0', nullable=False))
+
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('puppet', schema=None) as batch_op:
+        batch_op.drop_column('displayname_quality')
+
+    # ### end Alembic commands ###

alembic/versions/ccbaff858240_switch_to_mautrix_python_crypto.py

@@ -0,0 +1,71 @@
+"""Switch to mautrix-python crypto
+
+Revision ID: ccbaff858240
+Revises: 3e3745baa458
+Create Date: 2020-07-08 19:06:12.588047
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision = 'ccbaff858240'
+down_revision = '3e3745baa458'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('nio_account')
+    op.drop_table('nio_device_key')
+    op.drop_table('nio_outgoing_key_request')
+    op.drop_table('nio_olm_session')
+    op.drop_table('nio_megolm_inbound_session')
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('nio_megolm_inbound_session',
+    sa.Column('session_id', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.Column('sender_key', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.Column('fp_key', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.Column('room_id', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.Column('session', postgresql.BYTEA(), autoincrement=False, nullable=False),
+    sa.Column('forwarded_chains', postgresql.BYTEA(), autoincrement=False, nullable=False),
+    sa.PrimaryKeyConstraint('session_id', name='nio_megolm_inbound_session_pkey')
+    )
+    op.create_table('nio_olm_session',
+    sa.Column('session_id', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.Column('sender_key', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.Column('session', postgresql.BYTEA(), autoincrement=False, nullable=False),
+    sa.Column('created_at', postgresql.TIMESTAMP(), autoincrement=False, nullable=False),
+    sa.Column('last_used', postgresql.TIMESTAMP(), autoincrement=False, nullable=False),
+    sa.PrimaryKeyConstraint('session_id', name='nio_olm_session_pkey')
+    )
+    op.create_table('nio_outgoing_key_request',
+    sa.Column('request_id', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.Column('session_id', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.Column('room_id', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.Column('algorithm', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.PrimaryKeyConstraint('request_id', name='nio_outgoing_key_request_pkey')
+    )
+    op.create_table('nio_device_key',
+    sa.Column('user_id', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.Column('device_id', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.Column('display_name', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.Column('deleted', sa.BOOLEAN(), autoincrement=False, nullable=False),
+    sa.Column('keys', postgresql.BYTEA(), autoincrement=False, nullable=False),
+    sa.PrimaryKeyConstraint('user_id', 'device_id', name='nio_device_key_pkey')
+    )
+    op.create_table('nio_account',
+    sa.Column('user_id', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.Column('device_id', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
+    sa.Column('shared', sa.BOOLEAN(), autoincrement=False, nullable=False),
+    sa.Column('sync_token', sa.TEXT(), autoincrement=False, nullable=False),
+    sa.Column('account', postgresql.BYTEA(), autoincrement=False, nullable=False),
+    sa.PrimaryKeyConstraint('user_id', 'device_id', name='nio_account_pkey')
+    )
+    # ### end Alembic commands ###

alembic/versions/d3c922a6acd2_add_decryption_info_field_for_.py

@@ -0,0 +1,26 @@
+"""Add decryption info field for reuploaded telegram files
+
+Revision ID: d3c922a6acd2
+Revises: 24f31fc8a72b
+Create Date: 2020-03-30 20:07:17.340346
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'd3c922a6acd2'
+down_revision = '24f31fc8a72b'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table("telegram_file") as batch_op:
+        batch_op.add_column(sa.Column("decryption_info", sa.Text(), nullable=True))
+
+
+def downgrade():
+    with op.batch_alter_table("telegram_file") as batch_op:
+        batch_op.drop_column("decryption_info")

alembic/versions/dff56c93da8d_add_matrix_nio_state_store_to_main_db.py

@@ -0,0 +1,71 @@
+"""Add matrix-nio state store to main db
+
+Revision ID: dff56c93da8d
+Revises: d3c922a6acd2
+Create Date: 2020-03-31 22:04:04.014048
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'dff56c93da8d'
+down_revision = 'd3c922a6acd2'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('nio_account',
+    sa.Column('user_id', sa.String(length=255), nullable=False),
+    sa.Column('device_id', sa.String(length=255), nullable=False),
+    sa.Column('shared', sa.Boolean(), nullable=False),
+    sa.Column('sync_token', sa.Text(), nullable=False),
+    sa.Column('account', sa.LargeBinary(), nullable=False),
+    sa.PrimaryKeyConstraint('user_id', 'device_id')
+    )
+    op.create_table('nio_device_key',
+    sa.Column('user_id', sa.String(length=255), nullable=False),
+    sa.Column('device_id', sa.String(length=255), nullable=False),
+    sa.Column('display_name', sa.String(length=255), nullable=False),
+    sa.Column('deleted', sa.Boolean(), nullable=False),
+    sa.Column('keys', sa.PickleType(), nullable=False),
+    sa.PrimaryKeyConstraint('user_id', 'device_id')
+    )
+    op.create_table('nio_megolm_inbound_session',
+    sa.Column('session_id', sa.String(length=255), nullable=False),
+    sa.Column('sender_key', sa.String(length=255), nullable=False),
+    sa.Column('fp_key', sa.String(length=255), nullable=False),
+    sa.Column('room_id', sa.String(length=255), nullable=False),
+    sa.Column('session', sa.LargeBinary(), nullable=False),
+    sa.Column('forwarded_chains', sa.PickleType(), nullable=False),
+    sa.PrimaryKeyConstraint('session_id')
+    )
+    op.create_table('nio_olm_session',
+    sa.Column('session_id', sa.String(length=255), nullable=False),
+    sa.Column('sender_key', sa.String(length=255), nullable=False),
+    sa.Column('session', sa.LargeBinary(), nullable=False),
+    sa.Column('created_at', sa.DateTime(), nullable=False),
+    sa.Column('last_used', sa.DateTime(), nullable=False),
+    sa.PrimaryKeyConstraint('session_id')
+    )
+    op.create_table('nio_outgoing_key_request',
+    sa.Column('request_id', sa.String(length=255), nullable=False),
+    sa.Column('session_id', sa.String(length=255), nullable=False),
+    sa.Column('room_id', sa.String(length=255), nullable=False),
+    sa.Column('algorithm', sa.String(length=255), nullable=False),
+    sa.PrimaryKeyConstraint('request_id')
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('nio_outgoing_key_request')
+    op.drop_table('nio_olm_session')
+    op.drop_table('nio_megolm_inbound_session')
+    op.drop_table('nio_device_key')
+    op.drop_table('nio_account')
+    # ### end Alembic commands ###

alembic/versions/ec1d3dcc77e9_switch_telegram_ids_to_bigints.py

@@ -0,0 +1,44 @@
+"""Switch Telegram IDs to bigints
+
+Revision ID: ec1d3dcc77e9
+Revises: 990f4395afc6
+Create Date: 2021-03-09 21:36:58.443727
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision = 'ec1d3dcc77e9'
+down_revision = '990f4395afc6'
+branch_labels = None
+depends_on = None
+
+
+columns_to_upgrade = (
+    ("bot_chat", "id"),
+    ("message", "tgid"),
+    ("message", "tg_space"),
+    ("portal", "tgid"),
+    ("portal", "tg_receiver"),
+    ("puppet", "id"),
+    ("puppet", "displayname_source"),
+    ("user", "tgid"),
+    ("user_portal", "user"),
+    ("user_portal", "portal"),
+    ("user_portal", "portal_receiver"),
+    ("contact", "user"),
+    ("contact", "contact"),
+)
+
+
+def upgrade():
+    if op.get_context().dialect.name == "postgresql":
+        for table, column in columns_to_upgrade:
+            op.alter_column(table, column, existing_type=sa.Integer, type_=sa.BigInteger)
+
+
+def downgrade():
+    if op.get_context().dialect.name == "postgresql":
+        for table, column in columns_to_upgrade:
+            op.alter_column(table, column, existing_type=sa.BigInteger, type_=sa.Integer)

docker-run.sh

@@ -13,8 +13,6 @@ sed -i "s#sqlite:///mautrix-telegram.db#sqlite:////data/mautrix-telegram.db#" /d
 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
@@ -28,12 +26,12 @@ fi
 
 if [ ! -f /data/registration.yaml ]; then
 	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 "Copy that over to synapses app service directory."
 	fixperms
 	exit
 fi
 
+# Check that database is in the right state
+alembic -x config=/data/config.yaml upgrade head
+
 fixperms
 exec su-exec $UID:$GID python3 -m mautrix_telegram -c /data/config.yaml

example-config.yaml

@@ -1,305 +0,0 @@
-# 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
-
-    # 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"
-
-# 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
-    # Show message editing as a reply to the original message.
-    # If this is false, message edits are not shown at all, as Matrix does not support editing yet.
-    edits_as_replies: true
-    # Highlight changed/added parts in edits. Requires lxml.
-    highlight_edits: 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.
-    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
-
-    # 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
-    # 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]

helm/mautrix-telegram/.editorconfig

@@ -0,0 +1,2 @@
+[*.{yaml,yml}]
+indent_size = 2

helm/mautrix-telegram/.gitignore

@@ -0,0 +1 @@
+charts/*

helm/mautrix-telegram/.helmignore

@@ -0,0 +1,22 @@
+# Patterns to ignore when building packages.
+# This supports shell glob matching, relative path matching, and
+# negation (prefixed with !). Only one pattern per line.
+.DS_Store
+# Common VCS dirs
+.git/
+.gitignore
+.bzr/
+.bzrignore
+.hg/
+.hgignore
+.svn/
+# Common backup files
+*.swp
+*.bak
+*.tmp
+*~
+# Various IDEs
+.project
+.idea/
+*.tmproj
+.vscode/

helm/mautrix-telegram/Chart.yaml

@@ -0,0 +1,14 @@
+apiVersion: v1
+name: mautrix-telegram
+version: 0.1.0
+appVersion: "0.7.0"
+description: A Matrix-Telegram hybrid puppeting/relaybot bridge.
+keywords:
+  - matrix
+  - bridge
+  - telegram
+maintainers:
+  - name: Tulir Asokan
+    email: tulir@maunium.net
+sources:
+  - https://github.com/tulir/mautrix-telegram

helm/mautrix-telegram/requirements.lock

@@ -0,0 +1,6 @@
+dependencies:
+- name: postgresql
+  repository: https://kubernetes-charts.storage.googleapis.com/
+  version: 6.5.0
+digest: sha256:85139e9d4207e49c11c5f84d7920d0135cffd3d427f3f3638d4e51258990de2a
+generated: "2019-10-23T22:11:37.005827507+03:00"

helm/mautrix-telegram/requirements.yaml

@@ -0,0 +1,5 @@
+dependencies:
+  - name: postgresql
+    version: 6.5.0
+    repository: https://kubernetes-charts.storage.googleapis.com/
+    condition: postgresql.enabled

helm/mautrix-telegram/templates/NOTES.txt

@@ -0,0 +1,21 @@
+Your registration file is below. Save it into a YAML file and give the path to that file to synapse:
+
+id: {{ .Values.appservice.id }}
+as_token: {{ .Values.appservice.asToken }}
+hs_token: {{ .Values.appservice.hsToken }}
+namespaces:
+    users:
+        - exclusive: true
+          regex: "@{{ .Values.bridge.username_template | replace "{userid}" ".+"}}:{{ .Values.homeserver.domain }}"
+          {{- if .Values.appservice.communityID }}
+          group_id: {{ .Values.appservice.communityID }}
+          {{- end }}
+    aliases:
+        - exclusive: true
+          regex: "@{{ .Values.bridge.alias_template | replace "{groupname}" ".+"}}:{{ .Values.homeserver.domain }}"
+          {{- if .Values.appservice.communityID }}
+          group_id: {{ .Values.appservice.communityID }}
+          {{- end }}
+url: {{ .Values.appservice.address }}
+sender_localpart: {{ .Values.appservice.botUsername }}
+rate_limited: false

helm/mautrix-telegram/templates/_helpers.tpl

@@ -0,0 +1,55 @@
+{{/*
+Expand the name of the chart.
+*/}}
+{{- define "mautrix-telegram.name" -}}
+{{- default .Chart.Name .Values.nameOverride | trunc 63 | trimSuffix "-" -}}
+{{- end -}}
+
+{{/*
+Create a default fully qualified app name.
+We truncate at 63 chars because some Kubernetes name fields are limited to this (by the DNS naming spec).
+If release name contains chart name it will be used as a full name.
+*/}}
+{{- define "mautrix-telegram.fullname" -}}
+{{- if .Values.fullnameOverride -}}
+{{- .Values.fullnameOverride | trunc 63 | trimSuffix "-" -}}
+{{- else -}}
+{{- $name := default .Chart.Name .Values.nameOverride -}}
+{{- if contains $name .Release.Name -}}
+{{- .Release.Name | trunc 63 | trimSuffix "-" -}}
+{{- else -}}
+{{- printf "%s-%s" .Release.Name $name | trunc 63 | trimSuffix "-" -}}
+{{- end -}}
+{{- end -}}
+{{- end -}}
+
+{{/*
+Create chart name and version as used by the chart label.
+*/}}
+{{- define "mautrix-telegram.chart" -}}
+{{- printf "%s-%s" .Chart.Name .Chart.Version | replace "+" "_" | trunc 63 | trimSuffix "-" -}}
+{{- end -}}
+
+{{/*
+Common labels
+*/}}
+{{- define "mautrix-telegram.labels" -}}
+app.kubernetes.io/name: {{ include "mautrix-telegram.name" . }}
+helm.sh/chart: {{ include "mautrix-telegram.chart" . }}
+app.kubernetes.io/instance: {{ .Release.Name }}
+{{- if .Chart.AppVersion }}
+app.kubernetes.io/version: {{ .Chart.AppVersion | quote }}
+{{- end }}
+app.kubernetes.io/managed-by: {{ .Release.Service }}
+{{- end -}}
+
+{{/*
+Create the name of the service account to use
+*/}}
+{{- define "mautrix-telegram.serviceAccountName" -}}
+{{- if .Values.serviceAccount.create -}}
+    {{ default (include "mautrix-telegram.fullname" .) .Values.serviceAccount.name }}
+{{- else -}}
+    {{ default "default" .Values.serviceAccount.name }}
+{{- end -}}
+{{- end -}}

helm/mautrix-telegram/templates/configmap.yaml

@@ -0,0 +1,57 @@
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: {{ template "mautrix-telegram.fullname" . }}
+  labels:
+    app.kubernetes.io/managed-by: {{ .Release.Service }}
+    app.kubernetes.io/instance: {{ .Release.Name }}
+    helm.sh/chart: {{ .Chart.Name }}-{{ .Chart.Version }}
+    app.kubernetes.io/name: {{ template "mautrix-telegram.name" . }}
+data:
+  config.yaml: |
+    homeserver:
+      address: {{ .Values.homeserver.address }}
+      domain: {{ .Values.homeserver.domain }}
+      verify_ssl: {{ .Values.homeserver.verifySSL }}
+
+    appservice:
+      address: http://{{ include "mautrix-telegram.fullname" . }}:{{ .Values.service.port }}
+
+      hostname: 0.0.0.0
+      port: {{ .Values.service.port }}
+      max_body_size: {{ .Values.appservice.maxBodySize }}
+
+      {{- if .Values.postgresql.enabled }}
+      database: "postgres://postgres:{{ .Values.postgresql.postgresqlPassword }}@{{ .Release.Name }}-postgresql/{{ .Values.postgresql.postgresqlDatabase }}"
+      {{- else }}
+      database: {{ .Values.appservice.database | quote }}
+      {{- end }}
+
+      public:
+        {{- toYaml .Values.appservice.public | nindent 8 }}
+
+      provisioning:
+        {{- toYaml .Values.appservice.provisioning | nindent 8 }}
+
+      id: {{ .Values.appservice.id }}
+      bot_username: {{ .Values.appservice.botUsername }}
+      bot_displayname: {{ .Values.appservice.botDisplayname }}
+      bot_avatar:  {{ .Values.appservice.botAvatar }}
+
+      community_id: {{ .Values.appservice.communityID }}
+
+      as_token: {{ .Values.appservice.asToken }}
+      hs_token: {{ .Values.appservice.hsToken }}
+
+    metrics:
+      {{- toYaml .Values.metrics | nindent 6 }}
+
+    bridge:
+      {{- toYaml .Values.bridge | nindent 6 }}
+
+    telegram:
+      {{- toYaml .Values.telegram | nindent 6 }}
+
+    logging:
+      {{- toYaml .Values.logging | nindent 6 }}
+  registration.yaml: ""

helm/mautrix-telegram/templates/deployment.yaml

@@ -0,0 +1,69 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: {{ include "mautrix-telegram.fullname" . }}
+  labels:
+    {{- include "mautrix-telegram.labels" . | nindent 4 }}
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: {{ include "mautrix-telegram.name" . }}
+      app.kubernetes.io/instance: {{ .Release.Name }}
+  template:
+    {{- if .Values.podAnnotations }}
+    annotations:
+      {{- toYaml .Values.podAnnotations | nindent 6 }}
+    {{- end }}
+    metadata:
+      labels:
+        app.kubernetes.io/name: {{ include "mautrix-telegram.name" . }}
+        app.kubernetes.io/instance: {{ .Release.Name }}
+    spec:
+      serviceAccountName: {{ template "mautrix-telegram.serviceAccountName" . }}
+      containers:
+        - name: {{ .Chart.Name }}
+          securityContext:
+            {{- toYaml .Values.securityContext | nindent 12 }}
+          image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
+          imagePullPolicy: {{ .Values.image.pullPolicy }}
+          volumeMounts:
+            - mountPath: /data
+              name: config-volume
+          ports:
+            - name: http
+              containerPort: {{ .Values.service.port }}
+              protocol: TCP
+          livenessProbe:
+            httpGet:
+              path: /_matrix/mau/live
+              port: http
+            initialDelaySeconds: 60
+            periodSeconds: 5
+          readinessProbe:
+            httpGet:
+              path: /_matrix/mau/ready
+              port: http
+            initialDelaySeconds: 60
+            periodSeconds: 5
+          resources:
+            {{- toYaml .Values.resources | nindent 12 }}
+      volumes:
+        - name: config-volume
+          configMap:
+            name: {{ template "mautrix-telegram.fullname" . }}
+
+      securityContext:
+        {{- toYaml .Values.podSecurityContext | nindent 8 }}
+      {{- with .Values.nodeSelector }}
+      nodeSelector:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}
+      {{- with .Values.affinity }}
+      affinity:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}
+      {{- with .Values.tolerations }}
+      tolerations:
+        {{- toYaml . | nindent 8 }}
+      {{- end }}

helm/mautrix-telegram/templates/service.yaml

@@ -0,0 +1,16 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ include "mautrix-telegram.fullname" . }}
+  labels:
+{{ include "mautrix-telegram.labels" . | indent 4 }}
+spec:
+  type: {{ .Values.service.type }}
+  ports:
+    - port: {{ .Values.service.port }}
+      targetPort: http
+      protocol: TCP
+      name: http
+  selector:
+    app.kubernetes.io/name: {{ include "mautrix-telegram.name" . }}
+    app.kubernetes.io/instance: {{ .Release.Name }}

helm/mautrix-telegram/templates/serviceaccount.yaml

@@ -0,0 +1,8 @@
+{{- if .Values.serviceAccount.create -}}
+apiVersion: v1
+kind: ServiceAccount
+metadata:
+  name: {{ template "mautrix-telegram.serviceAccountName" . }}
+  labels:
+{{ include "mautrix-telegram.labels" . | indent 4 }}
+{{- end -}}

helm/mautrix-telegram/values.yaml

@@ -0,0 +1,141 @@
+image:
+  repository: dock.mau.dev/tulir/mautrix-telegram
+  tag: latest
+  pullPolicy: IfNotPresent
+
+nameOverride: ""
+fullnameOverride: ""
+
+serviceAccount:
+  # Specifies whether a service account should be created
+  create: true
+  # The name of the service account to use.
+  # If not set and create is true, a name is generated using the fullname template
+  name:
+
+service:
+  type: ClusterIP
+  port: 29317
+
+resources: {}
+  # limits:
+  #   cpu: 100m
+  #   memory: 128Mi
+  # requests:
+  #   cpu: 100m
+  #   memory: 128Mi
+
+nodeSelector: {}
+
+tolerations: []
+
+affinity: {}
+
+# Postgres pod configs
+postgresql:
+  enabled: true
+  postgresqlDatabase: mxtg
+  postgresqlPassword: SET TO RANDOM STRING
+  persistence:
+    size: 2Gi
+  resources:
+    requests:
+      memory: 256Mi
+      cpu: 100m
+
+# 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://
+  verifySSL: true
+
+# Application service host/registration related details
+# Changing these values requires regeneration of the registration.
+appservice:
+  # 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
+  maxBodySize: 1
+
+  # 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.
+    shared_secret: SET TO RANDOM STRING
+
+  id: telegram
+  botUsername: telegrambot
+  # Display name and avatar for bot. Set to "remove" to remove display name/avatar, leave empty
+  # to leave display name/avatar as-is.
+  botDisplayname: Telegram bridge bot
+  botAvatar: mxc://maunium.net/tJCRmUyJDsgRNgqhOgoiHWbX
+
+  # Community ID for bridged users (changes registration file) and rooms.
+  # Must be created manually.
+  communityID: false
+
+  # Authentication tokens for AS <-> HS communication. Autogenerated; do not modify.
+  asToken: SET TO RANDOM STRING
+  hsToken: SET TO RANDOM STRING
+
+# The keys below can be used to override the configs in the base config:
+# https://github.com/tulir/mautrix-telegram/blob/master/example-config.yaml
+# Note that the "appservice" and "homeserver" sections are above and slightly different than the base.
+
+# 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}"
+
+  # 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"
+
+# Prometheus telemetry config.
+metrics:
+  enabled: false
+  listen_port: 8000
+
+# 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: 123456789:

mautrix_telegram/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "0.5.0rc1"
+__version__ = "0.10.0rc1"
 __author__ = "Tulir Asokan <tulir@maunium.net>"

mautrix_telegram/__main__.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,131 +13,121 @@
 #
 # 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 Awaitable, List, Any
-from time import time
-import argparse
-import asyncio
-import logging.config
-import sys
-import copy
-import signal
+from typing import Optional
 
-from sqlalchemy import orm
-import sqlalchemy as sql
-
-from mautrix_appservice import AppService
 from alchemysession import AlchemySessionContainer
 
+from mautrix.types import UserID, RoomID
+from mautrix.bridge import Bridge
+from mautrix.util.db import Base
+
 from .web.provisioning import ProvisioningAPI
 from .web.public import PublicBridgeWebsite
+from .commands.manhole import ManholeState
 from .abstract_user import init as init_abstract_user
-from .bot import init as init_bot
+from .bot import Bot, init as init_bot
 from .config import Config
 from .context import Context
-from .db import Base, init as init_db
+from .db import 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 .portal import Portal, init as init_portal
+from .puppet import Puppet, init as init_puppet
 from .user import User, init as init_user
-from . import __version__
+from .version import version, linkified_version
 
-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()
+try:
+    import prometheus_client as prometheus
+except ImportError:
+    prometheus = None
 
-config = Config(args.config, args.registration, args.base_config)
-config.load()
-config.update()
 
-if args.generate_registration:
-    config.generate_registration()
-    config.save()
-    print(f"Registration generated and saved to {config.registration_path}")
-    sys.exit(0)
+class TelegramBridge(Bridge):
+    module = "mautrix_telegram"
+    name = "mautrix-telegram"
+    command = "python -m mautrix-telegram"
+    description = "A Matrix-Telegram puppeting bridge."
+    repo_url = "https://github.com/tulir/mautrix-telegram"
+    real_user_content_key = "net.maunium.telegram.puppet"
+    version = version
+    markdown_version = linkified_version
+    config_class = Config
+    matrix_class = MatrixHandler
 
-logging.config.dictConfig(copy.deepcopy(config["logging"]))
-log = logging.getLogger("mau.init")  # type: logging.Logger
-log.debug(f"Initializing mautrix-telegram {__version__}")
+    config: Config
+    session_container: AlchemySessionContainer
+    bot: Bot
+    manhole: Optional[ManholeState]
 
-db_engine = sql.create_engine(config["appservice.database"] or "sqlite:///mautrix-telegram.db")
-db_factory = orm.sessionmaker(bind=db_engine)
-db_session = orm.scoping.scoped_session(db_factory)
-Base.metadata.bind = db_engine
+    def prepare_db(self) -> None:
+        super().prepare_db()
+        init_db(self.db)
+        self.session_container = AlchemySessionContainer(
+            engine=self.db, table_base=Base, session=False,
+            table_prefix="telethon_", manage_tables=False)
 
-session_container = AlchemySessionContainer(engine=db_engine, session=db_session,
-                                            table_base=Base, table_prefix="telethon_",
-                                            manage_tables=False)
-session_container.core_mode = True
+    def _prepare_website(self, context: Context) -> None:
+        if self.config["appservice.public.enabled"]:
+            public_website = PublicBridgeWebsite(self.loop)
+            self.az.app.add_subapp(self.config["appservice.public.prefix"], public_website.app)
+            context.public_website = public_website
 
-loop = asyncio.get_event_loop()  # type: asyncio.AbstractEventLoop
+        if self.config["appservice.provisioning.enabled"]:
+            provisioning_api = ProvisioningAPI(context)
+            self.az.app.add_subapp(self.config["appservice.provisioning.prefix"],
+                                   provisioning_api.app)
+            context.provisioning_api = provisioning_api
 
-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
-                     })
+    def prepare_bridge(self) -> None:
+        self.bot = init_bot(self.config)
+        context = Context(self.az, self.config, self.loop, self.session_container, self, self.bot)
+        self._prepare_website(context)
+        self.matrix = context.mx = MatrixHandler(context)
+        self.manhole = None
 
-context = Context(appserv, db_session, config, loop, session_container)
+        init_abstract_user(context)
+        init_formatter(context)
+        init_portal(context)
+        self.add_startup_actions(init_puppet(context))
+        self.add_startup_actions(init_user(context))
+        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())
 
-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 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")
+        for portal in Portal.all():
+            await portal.update_bridge_info()
+        self.log.info("Finished re-sending bridge info state events")
 
-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
+    def prepare_stop(self) -> None:
+        for puppet in Puppet.by_custom_mxid.values():
+            puppet.stop()
+        self.shutdown_actions = (user.stop() for user in User.by_tgid.values())
+        if self.manhole:
+            self.manhole.close()
+            self.manhole = None
 
-with appserv.run(config["appservice.hostname"], config["appservice.port"]) as start:
-    start_ts = time()
-    init_db(db_engine)
-    init_abstract_user(context)
-    context.bot = init_bot(context)
-    context.mx = MatrixHandler(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 get_user(self, user_id: UserID, create: bool = True) -> User:
+        user = User.get_by_mxid(user_id, create=create)
+        if user:
+            await user.ensure_started()
+        return user
 
-    if context.bot:
-        startup_actions.append(context.bot.start())
+    async def get_portal(self, room_id: RoomID) -> Portal:
+        return Portal.get_by_mxid(room_id)
 
-    signal.signal(signal.SIGINT, signal.default_int_handler)
-    signal.signal(signal.SIGTERM, signal.default_int_handler)
+    async def get_puppet(self, user_id: UserID, create: bool = False) -> Puppet:
+        return await Puppet.get_by_mxid(user_id, create=create)
 
-    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)
+    async def get_double_puppet(self, user_id: UserID) -> Puppet:
+        return await Puppet.get_by_custom_mxid(user_id)
+
+    def is_bridge_ghost(self, user_id: UserID) -> bool:
+        return bool(Puppet.get_id_from_mxid(user_id))
+
+
+TelegramBridge().run()

mautrix_telegram/abstract_user.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 Tulir Asokan
+# Copyright (C) 2020 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
@@ -14,28 +13,36 @@
 #
 # 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 Tuple, Optional, List, Union, TYPE_CHECKING
+from typing import Tuple, Optional, Union, Dict, Type, Any, TYPE_CHECKING
 from abc import ABC, abstractmethod
 import asyncio
 import logging
 import platform
+import time
 
-from sqlalchemy import orm
+from telethon.sessions import Session
+from telethon.network import (ConnectionTcpMTProxyRandomizedIntermediate, ConnectionTcpFull,
+                              Connection)
 from telethon.tl.patched import MessageService, Message
 from telethon.tl.types import (
-    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)
+    Channel, Chat, MessageActionChannelMigrateFrom, PeerUser, TypeUpdate, UpdatePinnedMessages,
+    UpdatePinnedChannelMessages, UpdateChatParticipantAdmin, UpdateChatParticipants, PeerChat,
+    UpdateChatUserTyping, UpdateDeleteChannelMessages, UpdateNewMessage, UpdateDeleteMessages,
+    UpdateEditChannelMessage, UpdateEditMessage, UpdateNewChannelMessage, UpdateReadHistoryOutbox,
+    UpdateShortChatMessage, UpdateShortMessage, UpdateUserName, UpdateUserPhoto, UpdateUserStatus,
+    UpdateUserTyping, User, UserStatusOffline, UserStatusOnline, UpdateReadHistoryInbox,
+    UpdateReadChannelInbox, MessageEmpty)
 
-from mautrix_appservice import MatrixRequestError, AppService
+from mautrix.types import UserID, PresenceState
+from mautrix.errors import MatrixError
+from mautrix.appservice import AppService
+from mautrix.util.logging import TraceLogger
+from mautrix.util.opt_prometheus import Histogram, Counter
 from alchemysession import AlchemySessionContainer
 
 from . import portal as po, puppet as pu, __version__
 from .db import Message as DBMessage
-from .types import TelegramID, MatrixUserID
+from .types import TelegramID
 from .tgclient import MautrixTelegramClient
 
 if TYPE_CHECKING:
@@ -43,81 +50,125 @@ if TYPE_CHECKING:
     from .config import Config
     from .bot import Bot
 
-config = None  # type: Config
+config: Optional['Config'] = None
 # Value updated from config in init()
-MAX_DELETIONS = 10  # type: int
+MAX_DELETIONS: int = 10
 
 UpdateMessage = Union[UpdateShortChatMessage, UpdateShortMessage, UpdateNewChannelMessage,
                       UpdateNewMessage, UpdateEditMessage, UpdateEditChannelMessage]
 UpdateMessageContent = Union[UpdateShortMessage, UpdateShortChatMessage, Message, MessageService]
 
+UPDATE_TIME = Histogram("bridge_telegram_update", "Time spent processing Telegram updates",
+                        ("update_type",))
+UPDATE_ERRORS = Counter("bridge_telegram_update_error",
+                        "Number of fatal errors while handling Telegram updates", ("update_type",))
+
 
 class AbstractUser(ABC):
-    session_container = None  # type: AlchemySessionContainer
-    loop = None  # type: asyncio.AbstractEventLoop
-    log = None  # type: logging.Logger
-    db = None  # type: orm.Session
-    az = None  # type: AppService
-    bot = None  # type: Bot
-    ignore_incoming_bot_events = True  # type: bool
+    session_container: AlchemySessionContainer = None
+    loop: asyncio.AbstractEventLoop = None
+    log: TraceLogger
+    az: AppService
+    relaybot: Optional['Bot']
+    ignore_incoming_bot_events: bool = True
+
+    client: Optional[MautrixTelegramClient]
+    mxid: Optional[UserID]
+
+    tgid: Optional[TelegramID]
+    username: Optional['str']
+    is_bot: bool
+
+    is_relaybot: bool
+
+    puppet_whitelisted: bool
+    whitelisted: bool
+    relaybot_whitelisted: bool
+    matrix_puppet_whitelisted: bool
+    is_admin: bool
 
     def __init__(self) -> None:
-        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]
+        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
 
     @property
     def connected(self) -> bool:
         return self.client and self.client.is_connected()
 
     @property
-    def _proxy_settings(self) -> Optional[Tuple[int, str, str, str, str, str]]:
+    def _proxy_settings(self) -> Tuple[Type[Connection], Optional[Tuple[Any, ...]]]:
         proxy_type = config["telegram.proxy.type"].lower()
+        connection = ConnectionTcpFull
+        connection_data = (config["telegram.proxy.address"],
+                           config["telegram.proxy.port"],
+                           config["telegram.proxy.rdns"],
+                           config["telegram.proxy.username"],
+                           config["telegram.proxy.password"])
         if proxy_type == "disabled":
-            return None
+            connection_data = None
         elif proxy_type == "socks4":
-            proxy_type = 1
+            connection_data = (1,) + connection_data
         elif proxy_type == "socks5":
-            proxy_type = 2
+            connection_data = (2,) + connection_data
         elif proxy_type == "http":
-            proxy_type = 3
+            connection_data = (3,) + connection_data
+        elif proxy_type == "mtproxy":
+            connection = ConnectionTcpMTProxyRandomizedIntermediate
+            connection_data = (connection_data[0], connection_data[1], connection_data[4])
 
-        return (proxy_type,
-                config["telegram.proxy.address"], config["telegram.proxy.port"],
-                config["telegram.proxy.rdns"],
-                config["telegram.proxy.username"], config["telegram.proxy.password"])
+        return connection, connection_data
 
     def _init_client(self) -> None:
         self.log.debug(f"Initializing client for {self.name}")
-        device = f"{platform.system()} {platform.release()}"
-        sysversion = MautrixTelegramClient.__version__
+
         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)}")
-        self.client = MautrixTelegramClient(session=self.session,
-                                            api_id=config["telegram.api_id"],
-                                            api_hash=config["telegram.api_hash"],
-                                            loop=self.loop,
-                                            app_version=__version__,
-                                            system_version=sysversion,
-                                            device_model=device,
-                                            timeout=120,
-                                            base_logger=base_logger,
-                                            proxy=self._proxy_settings)
+
+        device = config["telegram.device_info.device_model"]
+        sysversion = config["telegram.device_info.system_version"]
+        appversion = config["telegram.device_info.app_version"]
+        connection, proxy = self._proxy_settings
+
+        assert isinstance(self.session, Session)
+
+        self.client = MautrixTelegramClient(
+            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=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"],
+            connection=connection,
+            proxy=proxy,
+            raise_last_call_error=True,
+
+            loop=self.loop,
+            base_logger=base_logger
+        )
         self.client.add_event_handler(self._update_catch)
 
     @abstractmethod
@@ -129,28 +180,23 @@ class AbstractUser(ABC):
         raise NotImplementedError()
 
     @abstractmethod
-    def register_portal(self, portal: po.Portal) -> None:
+    async def register_portal(self, portal: po.Portal) -> None:
         raise NotImplementedError()
 
     @abstractmethod
-    def unregister_portal(self, portal: po.Portal) -> None:
+    async def unregister_portal(self, tgid: int, tg_receiver: int) -> 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")
-
-    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)))]
+            self.log.exception(f"Failed to handle Telegram update {update}")
+            UPDATE_ERRORS.labels(update_type=update_type).inc()
+        UPDATE_TIME.labels(update_type=update_type).observe(time.time() - start_time)
 
     @property
     @abstractmethod
@@ -158,7 +204,8 @@ 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
@@ -169,17 +216,15 @@ class AbstractUser(ABC):
         if not self.client:
             self._init_client()
         await self.client.connect()
-        self.log.debug("%s connected: %s", self.mxid, self.connected)
+        self.log.debug(f"{'Bot' if self.is_relaybot else self.mxid} connected: {self.connected}")
         return self
 
     async def ensure_started(self, even_if_no_session=False) -> 'AbstractUser':
-        if not self.puppet_whitelisted or self.connected:
+        if self.connected:
             return self
-        session_count = self.session_container.Session.query.filter(
-            self.session_container.Session.session_id == self.mxid).count()
-        self.log.debug("ensure_started(%s, even_if_no_session=%s, session_count=%s)",
-                       self.mxid, even_if_no_session, session_count)
-        if even_if_no_session or session_count > 0:
+        if even_if_no_session or self.session_container.has_session(self.mxid):
+            self.log.debug("Starting client due to ensure_started"
+                           f"(even_if_no_session={even_if_no_session})")
             await self.start(delete_unless_authenticated=not even_if_no_session)
         return self
 
@@ -190,6 +235,8 @@ class AbstractUser(ABC):
     # region Telegram update handling
 
     async def _update(self, update: TypeUpdate) -> None:
+        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)
@@ -205,29 +252,32 @@ class AbstractUser(ABC):
             await self.update_admin(update)
         elif isinstance(update, UpdateChatParticipants):
             await self.update_participants(update)
-        elif isinstance(update, (UpdateChannelPinnedMessage, UpdateChatPinnedMessage)):
+        elif isinstance(update, (UpdatePinnedMessages, UpdatePinnedChannelMessages)):
             await self.update_pinned_messages(update)
         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)
         else:
-            self.log.debug("Unhandled update: %s", update)
+            self.log.trace("Unhandled update: %s", update)
 
-    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))
+    async def update_pinned_messages(self, update: Union[UpdatePinnedMessages,
+                                                         UpdatePinnedChannelMessages]) -> None:
+        if isinstance(update, UpdatePinnedMessages):
+            portal = po.Portal.get_by_entity(update.peer, receiver_id=self.tgid)
         else:
             portal = po.Portal.get_by_tgid(TelegramID(update.channel_id))
         if portal and portal.mxid:
-            await portal.receive_telegram_pin_id(update.id, self.tgid)
+            await portal.receive_telegram_pin_ids(update.messages, self.tgid,
+                                                  remove=not update.pinned)
 
     @staticmethod
     async def update_participants(update: UpdateChatParticipants) -> None:
         portal = po.Portal.get_by_tgid(TelegramID(update.participants.chat_id))
         if portal and portal.mxid:
-            await portal.update_telegram_participants(update.participants.participants)
+            await portal.update_power_levels(update.participants.participants)
 
     async def update_read_receipt(self, update: UpdateReadHistoryOutbox) -> None:
         if not isinstance(update.peer, PeerUser):
@@ -239,16 +289,42 @@ class AbstractUser(ABC):
             return
 
         # We check that these are user read receipts, so tg_space is always the user ID.
-        message = DBMessage.get_by_tgid(TelegramID(update.max_id), self.tgid)
+        message = DBMessage.get_one_by_tgid(TelegramID(update.max_id), self.tgid, edit_index=-1)
         if not message:
             return
 
         puppet = pu.Puppet.get(TelegramID(update.peer.user_id))
         await puppet.intent.mark_read(portal.mxid, message.mxid)
 
+    async def update_own_read_receipt(self, update: Union[UpdateReadHistoryInbox,
+                                                          UpdateReadChannelInbox]) -> None:
+        puppet = pu.Puppet.get(self.tgid)
+        if not puppet.is_real_user:
+            return
+
+        if isinstance(update, UpdateReadChannelInbox):
+            portal = po.Portal.get_by_tgid(TelegramID(update.channel_id))
+        elif isinstance(update.peer, PeerChat):
+            portal = po.Portal.get_by_tgid(TelegramID(update.peer.chat_id))
+        elif isinstance(update.peer, PeerUser):
+            portal = po.Portal.get_by_tgid(TelegramID(update.peer.user_id), self.tgid)
+        else:
+            self.log.debug("Unexpected own read receipt peer: %s", update.peer)
+            return
+
+        if not portal or not portal.mxid:
+            return
+
+        tg_space = portal.tgid if portal.peer_type == "channel" else self.tgid
+        message = DBMessage.get_one_by_tgid(TelegramID(update.max_id), tg_space, edit_index=-1)
+        if not message:
+            return
+
+        await puppet.intent.mark_read(portal.mxid, message.mxid)
+
     async def update_admin(self, update: UpdateChatParticipantAdmin) -> None:
         # TODO duplication not checked
-        portal = po.Portal.get_by_tgid(TelegramID(update.chat_id), peer_type="chat")
+        portal = po.Portal.get_by_tgid(TelegramID(update.chat_id))
         if not portal or not portal.mxid:
             return
 
@@ -258,7 +334,7 @@ class AbstractUser(ABC):
         if isinstance(update, UpdateUserTyping):
             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")
+            portal = po.Portal.get_by_tgid(TelegramID(update.chat_id))
 
         if not portal or not portal.mxid:
             return
@@ -266,34 +342,46 @@ class AbstractUser(ABC):
         sender = pu.Puppet.get(TelegramID(update.user_id))
         await portal.handle_telegram_typing(sender, update)
 
+    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))
+            puppets = ((pu.Puppet.get(TelegramID(user.id)), user) for user in users)
+            await asyncio.gather(*[puppet.try_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: Union[UpdateUserName, UpdateUserPhoto]) -> None:
         # TODO duplication not checked
         puppet = pu.Puppet.get(TelegramID(update.user_id))
         if isinstance(update, UpdateUserName):
             puppet.username = update.username
             if await puppet.update_displayname(self, update):
-                puppet.save()
+                await puppet.save()
         elif isinstance(update, UpdateUserPhoto):
-            if await puppet.update_avatar(self, update.photo.photo_big):
-                puppet.save()
+            if await puppet.update_avatar(self, update.photo):
+                await puppet.save()
         else:
-            self.log.warning("Unexpected other user info update: %s", update)
+            self.log.warning(f"Unexpected other user info update: {type(update)}")
 
     async def update_status(self, update: UpdateUserStatus) -> None:
         puppet = pu.Puppet.get(TelegramID(update.user_id))
         if isinstance(update.status, UserStatusOnline):
-            await puppet.default_mxid_intent.set_presence("online")
+            await puppet.default_mxid_intent.set_presence(PresenceState.ONLINE)
         elif isinstance(update.status, UserStatusOffline):
-            await puppet.default_mxid_intent.set_presence("offline")
+            await puppet.default_mxid_intent.set_presence(PresenceState.OFFLINE)
         else:
-            self.log.warning("Unexpected user status update: %s", update)
+            self.log.warning(f"Unexpected user status update: type({update})")
         return
 
     def get_message_details(self, update: UpdateMessage) -> Tuple[UpdateMessageContent,
                                                                   Optional[pu.Puppet],
                                                                   Optional[po.Portal]]:
         if isinstance(update, UpdateShortChatMessage):
-            portal = po.Portal.get_by_tgid(TelegramID(update.chat_id), peer_type="chat")
+            portal = po.Portal.get_by_tgid(TelegramID(update.chat_id))
+            if not portal:
+                self.log.warning(f"Received message in chat with unknown type {update.chat_id}")
             sender = pu.Puppet.get(TelegramID(update.from_id))
         elif isinstance(update, UpdateShortMessage):
             portal = po.Portal.get_by_tgid(TelegramID(update.user_id), self.tgid, "user")
@@ -301,94 +389,103 @@ class AbstractUser(ABC):
         elif isinstance(update, (UpdateNewMessage, UpdateNewChannelMessage,
                                  UpdateEditMessage, UpdateEditChannelMessage)):
             update = update.message
-            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)
+            if isinstance(update, MessageEmpty):
+                return update, None, None
+            portal = po.Portal.get_by_entity(update.peer_id, receiver_id=self.tgid)
+            if update.out:
+                sender = pu.Puppet.get(self.tgid)
+            elif isinstance(update.from_id, PeerUser):
+                sender = pu.Puppet.get(TelegramID(update.from_id.user_id))
             else:
-                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
+                sender = None
         else:
-            self.log.warning(
-                f"Unexpected message type in User#get_message_details: {type(update)}")
+            self.log.warning("Unexpected message type in User#get_message_details: "
+                             f"{type(update)}")
             return update, None, None
         return update, sender, portal
 
     @staticmethod
-    async def _try_redact(portal: po.Portal, message: DBMessage) -> None:
+    async def _try_redact(message: DBMessage) -> None:
+        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 MatrixRequestError:
+        except MatrixError:
             pass
 
     async def delete_message(self, update: UpdateDeleteMessages) -> None:
         if len(update.messages) > MAX_DELETIONS:
             return
 
-        for message in update.messages:
-            message = DBMessage.get_by_tgid(TelegramID(message), self.tgid)
-            if not message:
-                continue
-            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(portal, message)
+        for message_id in update.messages:
+            for message in DBMessage.get_all_by_tgid(TelegramID(message_id), self.tgid):
+                if message.redacted:
+                    continue
+                message.delete()
+                number_left = DBMessage.count_spaces_by_mxid(message.mxid, message.mx_room)
+                if number_left == 0:
+                    await self._try_redact(message)
 
     async def delete_channel_message(self, update: UpdateDeleteChannelMessages) -> None:
         if len(update.messages) > MAX_DELETIONS:
             return
 
-        portal = po.Portal.get_by_tgid(TelegramID(update.channel_id))
-        if not portal:
-            return
+        channel_id = TelegramID(update.channel_id)
 
-        for message in update.messages:
-            message = DBMessage.get_by_tgid(TelegramID(message), portal.tgid)
-            if not message:
-                continue
-            message.delete()
-            await self._try_redact(portal, message)
+        for message_id in update.messages:
+            for message in DBMessage.get_all_by_tgid(TelegramID(message_id), channel_id):
+                if message.redacted:
+                    continue
+                message.delete()
+                await self._try_redact(message)
 
     async def update_message(self, original_update: UpdateMessage) -> None:
         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)
+        if not portal:
+            return
+        elif portal and not portal.allow_bridging:
+            self.log.debug(f"Ignoring message in portal {portal.tgid_log} (bridging disallowed)")
             return
 
-        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)
+        if self.is_relaybot:
+            if update.is_private:
+                if not config["bridge.relaybot.private_chat.invite"]:
+                    self.log.debug(f"Ignoring private message to bot from {sender.id}")
+                    return
+            elif not portal.mxid and config["bridge.relaybot.ignore_unbridged_group_chat"]:
+                self.log.debug("Ignoring message received by bot"
+                               f" 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(f"Ignoring relaybot-sent message %s to %s", update.id, portal.tgid_log)
             return
 
+        await portal.backfill_lock.wait(update.id)
+
         if isinstance(update, MessageService):
             if isinstance(update.action, MessageActionChannelMigrateFrom):
-                self.log.debug(f"Ignoring action %s to %s by %d", update.action,
-                               portal.tgid_log,
-                               sender.id)
+                self.log.trace(f"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)
                 return
-            self.log.debug("Handling action %s to %s by %d", update.action, portal.tgid_log,
-                           sender.id)
+            self.log.trace("Handling action %s to %s by %d", update.action, portal.tgid_log,
+                           (sender.id if sender else 0))
             return await portal.handle_telegram_action(self, sender, update)
 
-        user = sender.tgid if sender else "admin"
         if isinstance(original_update, (UpdateEditMessage, UpdateEditChannelMessage)):
-            if config["bridge.edits_as_replies"]:
-                self.log.debug("Handling edit %s to %s by %s", update, portal.tgid_log, user)
-                return await portal.handle_telegram_edit(self, sender, update)
-            return
-
-        self.log.debug("Handling message %s to %s by %s", update, portal.tgid_log, user)
+            return await portal.handle_telegram_edit(self, sender, update)
         return await portal.handle_telegram_message(self, sender, update)
 
     # endregion
 
 
-def init(context: "Context") -> None:
+def init(context: 'Context') -> None:
     global config, MAX_DELETIONS
-    AbstractUser.az, AbstractUser.db, config, AbstractUser.loop, AbstractUser.relaybot = context.core
+    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)

mautrix_telegram/bot.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,21 +13,21 @@
 #
 # 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 Awaitable, Callable, Dict, List, Optional, Pattern, TYPE_CHECKING
+from typing import Awaitable, Callable, Dict, List, Optional, Tuple, TYPE_CHECKING
 import logging
-import re
 
 from telethon.tl.patched import Message, MessageService
 from telethon.tl.types import (
     ChannelParticipantAdmin, ChannelParticipantCreator, ChatForbidden, ChatParticipantAdmin,
-    ChatParticipantCreator, InputChannel, InputUser, MessageActionChatAddUser,
+    ChatParticipantCreator, InputChannel, InputUser, MessageActionChatAddUser, PeerUser,
     MessageActionChatDeleteUser, MessageEntityBotCommand, PeerChannel, PeerChat, TypePeer,
-    UpdateNewChannelMessage, UpdateNewMessage)
+    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 .types import MatrixUserID
+from mautrix.types import UserID
+
 from .abstract_user import AbstractUser
 from .db import BotChat
 from .types import TelegramID
@@ -36,30 +35,45 @@ from . import puppet as pu, portal as po, user as u
 
 if TYPE_CHECKING:
     from .config import Config
-    from .context import Context
 
-config = None  # type: Config
+config: Optional['Config'] = None
 
 ReplyFunc = Callable[[str], Awaitable[Message]]
 
 
 class Bot(AbstractUser):
-    log = logging.getLogger("mau.bot")  # type: logging.Logger
-    mxid_regex = re.compile("@.+:.+")  # type: Pattern
+    log: logging.Logger = logging.getLogger("mau.user.bot")
+
+    token: str
+    chats: Dict[int, str]
+    tg_whitelist: List[int]
+    whitelist_group_admins: bool
+    _me_info: Optional[User]
+    _me_mxid: Optional[UserID]
 
     def __init__(self, token: str) -> None:
         super().__init__()
-        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 = {chat.id: chat.type for chat in BotChat.all()}  # type: Dict[int, str]
-        self.tg_whitelist = []  # type: List[int]
+        self.token = token
+        self.tgid = None
+        self.mxid = None
+        self.puppet_whitelisted = True
+        self.whitelisted = True
+        self.relaybot_whitelisted = True
+        self.username = None
+        self.is_relaybot = True
+        self.is_bot = True
+        self.chats = {}
+        self.tg_whitelist = []
         self.whitelist_group_admins = (config["bridge.relaybot.whitelist_group_admins"]
-                                       or False)  # type: bool
+                                       or False)
+        self._me_info = None
+        self._me_mxid = None
+
+    async def get_me(self, use_cache: bool = True) -> Tuple[User, UserID]:
+        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 = config["bridge.relaybot.whitelist"] or []
@@ -74,6 +88,7 @@ class Bot(AbstractUser):
                 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 BotChat.all()}
         await super().start(delete_unless_authenticated)
         if not await self.is_logged_in():
             await self.client.sign_in(bot_token=self.token)
@@ -83,7 +98,7 @@ class Bot(AbstractUser):
     async def post_login(self) -> None:
         await self.init_permissions()
         info = await self.client.get_me()
-        self.tgid = info.id
+        self.tgid = TelegramID(info.id)
         self.username = info.username
         self.mxid = pu.Puppet.get_mxid_from_id(self.tgid)
 
@@ -102,17 +117,11 @@ class Bot(AbstractUser):
             except (ChannelPrivateError, ChannelInvalidError):
                 self.remove_chat(TelegramID(channel_id.channel_id))
 
-        if config["bridge.catch_up"]:
-            try:
-                await self.client.catch_up()
-            except Exception:
-                self.log.exception("Failed to run catch_up() for bot")
-
-    def register_portal(self, portal: po.Portal) -> None:
+    async def register_portal(self, portal: po.Portal) -> None:
         self.add_chat(portal.tgid, portal.peer_type)
 
-    def unregister_portal(self, portal: po.Portal) -> None:
-        self.remove_chat(portal.tgid)
+    async def unregister_portal(self, tgid: int, tg_receiver: int) -> None:
+        self.remove_chat(tgid)
 
     def add_chat(self, chat_id: TelegramID, chat_type: str) -> None:
         if chat_id not in self.chats:
@@ -124,7 +133,7 @@ class Bot(AbstractUser):
             del self.chats[chat_id]
         except KeyError:
             pass
-        BotChat.delete(chat_id)
+        BotChat.delete_by_id(chat_id)
 
     async def _can_use_commands(self, chat: TypePeer, tgid: TelegramID) -> bool:
         if tgid in self.tg_whitelist:
@@ -138,7 +147,7 @@ class Bot(AbstractUser):
         if self.whitelist_group_admins:
             if isinstance(chat, PeerChannel):
                 p = await self.client(GetParticipantRequest(chat, tgid))
-                return isinstance(p, (ChannelParticipantCreator, ChannelParticipantAdmin))
+                return isinstance(p.participant, (ChannelParticipantCreator, ChannelParticipantAdmin))
             elif isinstance(chat, PeerChat):
                 chat = await self.client(GetFullChatRequest(chat.chat_id))
                 participants = chat.full_chat.participants.participants
@@ -148,7 +157,7 @@ class Bot(AbstractUser):
         return False
 
     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):
+        if not await self._can_use_commands(event.to_id, TelegramID(event.from_id)):
             await reply("You do not have the permission to use that command.")
             return False
         return True
@@ -157,7 +166,7 @@ class Bot(AbstractUser):
         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)
@@ -170,15 +179,15 @@ class Bot(AbstractUser):
                     "Portal is not public. Use `/invite <mxid>` to get an invite.")
 
     async def handle_command_invite(self, portal: po.Portal, reply: ReplyFunc,
-                                    mxid_input: MatrixUserID) -> Message:
+                                    mxid_input: UserID) -> 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 not self.mxid_regex.match(mxid_input):
+        if mxid_input[0] != '@' or mxid_input.find(':') < 2:
             return await reply("That doesn't look like a Matrix ID.")
-        user = await u.User.get_by_mxid(MatrixUserID(mxid_input)).ensure_started()
+        user = await u.User.get_by_mxid(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():
@@ -186,7 +195,7 @@ class Bot(AbstractUser):
             return await reply("That user seems to be logged in. "
                                f"Just invite [{displayname}](tg://user?id={user.tgid})")
         else:
-            await portal.main_intent.invite(portal.mxid, user.mxid)
+            await portal.main_intent.invite_user(portal.mxid, user.mxid)
             return await reply(f"Invited `{user.mxid}` to the portal.")
 
     @staticmethod
@@ -195,7 +204,12 @@ class Bot(AbstractUser):
         # 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}")
-        return reply(str(-message.to_id.chat_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.from_id}.")
+        else:
+            return reply("Failed to find chat ID.")
 
     def match_command(self, text: str, command: str) -> bool:
         text = text.lower()
@@ -214,45 +228,56 @@ class Bot(AbstractUser):
 
     async def handle_command(self, message: Message) -> None:
         def reply(reply_text: str) -> Awaitable[Message]:
-            return self.client.send_message(message.to_id, reply_text, reply_to=message.id)
+            return self.client.send_message(message.chat_id, reply_text, reply_to=message.id)
 
         text = message.message
 
-        if self.match_command(text, "id"):
+        if self.match_command(text, "start"):
+            pcm = config["bridge.relaybot.private_chat.message"]
+            if pcm:
+                await reply(pcm)
+            return
+        elif self.match_command(text, "id"):
             await self.handle_command_id(message, reply)
             return
+        elif message.is_private:
+            return
 
         portal = po.Portal.get_by_entity(message.to_id)
 
-        if self.match_command(text, "portal"):
+        is_portal_cmd = self.match_command(text, "portal")
+        is_invite_cmd = self.match_command(text, "invite")
+        if is_portal_cmd or is_invite_cmd:
             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)
+            if is_portal_cmd:
+                await self.handle_command_portal(portal, reply)
+            elif is_invite_cmd:
+                try:
+                    mxid = text[text.index(" ") + 1:]
+                except ValueError:
+                    mxid = ""
+                await self.handle_command_invite(portal, reply, mxid_input=UserID(mxid))
 
     def handle_service_message(self, message: MessageService) -> None:
-        to_id = message.to_id
-        if isinstance(to_id, PeerChannel):
-            to_id = to_id.channel_id
+        to_peer = message.to_id
+        if isinstance(to_peer, PeerChannel):
+            to_id = TelegramID(to_peer.channel_id)
             chat_type = "channel"
-        elif isinstance(to_id, PeerChat):
-            to_id = to_id.chat_id
+        elif isinstance(to_peer, PeerChat):
+            to_id = TelegramID(to_peer.chat_id)
             chat_type = "chat"
         else:
             return
 
         action = message.action
         if isinstance(action, MessageActionChatAddUser) and self.tgid in action.users:
-            self.add_chat(TelegramID(to_id), chat_type)
+            self.add_chat(to_id, chat_type)
         elif isinstance(action, MessageActionChatDeleteUser) and action.user_id == self.tgid:
-            self.remove_chat(TelegramID(to_id))
+            self.remove_chat(to_id)
+        elif isinstance(action, MessageActionChatMigrateTo):
+            self.remove_chat(to_id)
+            self.add_chat(TelegramID(action.channel_id), "channel")
 
     async def update(self, update) -> bool:
         if not isinstance(update, (UpdateNewMessage, UpdateNewChannelMessage)):
@@ -263,10 +288,10 @@ class Bot(AbstractUser):
 
         is_command = (isinstance(update.message, Message)
                       and update.message.entities and len(update.message.entities) > 0
-                      and isinstance(update.message.entities[0], MessageEntityBotCommand))
+                      and isinstance(update.message.entities[0], MessageEntityBotCommand)
+                      and update.message.entities[0].offset == 0)
         if is_command:
             await self.handle_command(update.message)
-            return True
         return False
 
     def is_in_chat(self, peer_id) -> bool:
@@ -277,9 +302,9 @@ class Bot(AbstractUser):
         return "bot"
 
 
-def init(context: 'Context') -> Optional[Bot]:
+def init(cfg: 'Config') -> Optional[Bot]:
     global config
-    config = context.config
+    config = cfg
     token = config["telegram.bot_token"]
     if token and not token.lower().startswith("disable"):
         return Bot(token)

mautrix_telegram/commands/__init__.py

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

mautrix_telegram/commands/clean_rooms.py

@@ -1,178 +0,0 @@
-# -*- coding: future_fstrings -*-
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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.")

mautrix_telegram/commands/handler.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,23 +13,30 @@
 #
 # 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 Awaitable, Callable, Dict, List, NamedTuple, Optional
-import traceback
-import logging
-
-import commonmark
+"""This module contains classes handling commands issued by Matrix users."""
+from typing import Awaitable, Callable, List, Optional, NamedTuple, Any
 
 from telethon.errors import FloodWaitError
 
-from ..types import MatrixRoomID
+from mautrix.types import RoomID, EventID, MessageEventContent
+from mautrix.bridge.commands import (HelpSection, CommandEvent as BaseCommandEvent,
+                                     CommandHandler as BaseCommandHandler,
+                                     CommandProcessor as BaseCommandProcessor,
+                                     CommandHandlerFunc, command_handler as base_command_handler)
+
 from ..util import format_duration
-from .. import user as u, context as c
+from .. import user as u, context as c, portal as po
 
-command_handlers = {}  # type: Dict[str, CommandHandler]
 
-HelpSection = NamedTuple('HelpSection', [('name', str), ('order', int), ('description', str)])
+class HelpCacheKey(NamedTuple):
+    is_management: bool
+    is_portal: bool
+    puppet_whitelisted: bool
+    matrix_puppet_whitelisted: bool
+    is_admin: bool
+    is_logged_in: bool
+
 
-SECTION_GENERAL = HelpSection("General", 0, "")
 SECTION_AUTH = HelpSection("Authentication", 10, "")
 SECTION_CREATING_PORTALS = HelpSection("Creating portals", 20, "")
 SECTION_PORTAL_MANAGEMENT = HelpSection("Portal management", 30, "")
@@ -38,169 +44,80 @@ SECTION_MISC = HelpSection("Miscellaneous", 40, "")
 SECTION_ADMIN = HelpSection("Administration", 50, "")
 
 
-class HtmlEscapingRenderer(commonmark.HtmlRenderer):
-    def __init__(self, allow_html: bool = False):
-        super().__init__()
-        self.allow_html = allow_html
+class CommandEvent(BaseCommandEvent):
+    sender: u.User
+    portal: po.Portal
 
-    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()
-
-
-class CommandEvent:
-    def __init__(self, processor: 'CommandProcessor', room: MatrixRoomID, 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
+    def __init__(self, processor: 'CommandProcessor', room_id: RoomID, event_id: EventID,
+                 sender: u.User, command: str, args: List[str], content: MessageEventContent,
+                 portal: Optional['po.Portal'], 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
         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.sender = sender
-        self.command = command
-        self.args = args
-        self.is_management = is_management
-        self.is_portal = is_portal
 
-    def reply(self, message: str, allow_html: bool = False, render_markdown: bool = True
-              ) -> Awaitable[Dict]:
-        message = message.replace("$cmdprefix+sp ",
-                                  "" if self.is_management else f"{self.command_prefix} ")
-        message = message.replace("$cmdprefix", self.command_prefix)
-        html = None
-        if render_markdown:
-            md_renderer.allow_html = allow_html
-            html = md_renderer.render(md_parser.parse(message))
-        elif allow_html:
-            html = message
-        return self.az.intent.send_notice(self.room_id, message, html=html)
+    @property
+    def print_error_traceback(self) -> bool:
+        return self.sender.is_admin
+
+    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())
 
 
-class CommandHandler:
-    def __init__(self, handler: Callable[[CommandEvent], Awaitable[Dict]], needs_auth: bool,
-                 needs_puppeting: bool, needs_matrix_puppeting: bool, needs_admin: bool,
+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) -> None:
-        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
+                 help_section: HelpSection, needs_auth: bool, needs_puppeting: bool,
+                 needs_matrix_puppeting: bool, needs_admin: bool) -> 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)
 
     async def get_permission_error(self, evt: CommandEvent) -> Optional[str]:
-        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:
+        if 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
+        return await super().get_permission_error(evt)
 
-    def has_permission(self, is_management: bool, puppet_whitelisted: bool,
-                       matrix_puppet_whitelisted: bool, is_admin: bool, is_logged_in: bool) -> bool:
-        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:
-        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:
-        return bool(self.help_section) and bool(self._help_text)
-
-    @property
-    def help(self) -> str:
-        return f"**{self.name}** {self._help_args} - {self._help_text}"
+    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: 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)
+def command_handler(_func: Optional[CommandHandlerFunc] = None, *, needs_auth: bool = True,
+                    needs_puppeting: bool = True, needs_matrix_puppeting: bool = False,
+                    needs_admin: bool = False, management_only: bool = False,
+                    name: Optional[str] = None, help_text: str = "", help_args: str = "",
+                    help_section: HelpSection = None) -> Callable[[CommandHandlerFunc],
+                                                                  CommandHandler]:
+    return base_command_handler(
+        _func, _handler_class=CommandHandler, name=name, help_text=help_text, help_args=help_args,
+        help_section=help_section, management_only=management_only, needs_auth=needs_auth,
+        needs_admin=needs_admin, needs_puppeting=needs_puppeting,
+        needs_matrix_puppeting=needs_matrix_puppeting)
 
 
-class CommandProcessor:
-    log = logging.getLogger("mau.commands")
-
+class CommandProcessor(BaseCommandProcessor):
     def __init__(self, context: c.Context) -> None:
-        self.az, self.db, self.config, self.loop, self.tgbot = context.core
+        super().__init__(event_class=CommandEvent, bridge=context.bridge)
+        self.tgbot = context.bot
         self.public_website = context.public_website
-        self.command_prefix = self.config["bridge.command_prefix"]
 
-    async def handle(self, room: MatrixRoomID, sender: u.User, command: str, args: List[str],
-                     is_management: bool, is_portal: bool) -> Optional[Dict]:
-        evt = CommandEvent(self, room, sender, command, args, is_management, is_portal)
-        orig_command = command
-        command = command.lower()
+    @staticmethod
+    async def _run_handler(handler: Callable[[CommandEvent], Awaitable[Any]], evt: CommandEvent
+                           ) -> Any:
         try:
-            handler = command_handlers[command]
-        except KeyError:
-            if sender.command_status and "next" in sender.command_status:
-                args.insert(0, orig_command)
-                evt.command = ""
-                handler = sender.command_status["next"]
-            else:
-                handler = command_handlers["unknown-command"]
-        try:
-            await handler(evt)
+            return await handler(evt)
         except FloodWaitError as e:
             return await evt.reply(f"Flood error: Please wait {format_duration(e.seconds)}")
-        except Exception:
-            self.log.exception("Unhandled error while handling command "
-                               f"{evt.command} {' '.join(args)} from {sender.mxid}")
-            if evt.sender.is_admin and evt.is_management:
-                return await evt.reply("Unhandled error while handling command:\n\n"
-                                       "```traceback\n"
-                                       f"{traceback.format_exc()}"
-                                       "```")
-            return await evt.reply("Unhandled error while handling command. "
-                                   "Check logs for more details.")
-        return None

mautrix_telegram/commands/manhole.py

@@ -0,0 +1,128 @@
+# 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 Set, Callable
+import asyncio
+import sys
+import os
+
+from attr import dataclass
+
+from telethon import __version__ as __telethon_version__
+
+from mautrix import __version__ as __mautrix_version__
+from mautrix.types import UserID
+from mautrix.errors import MatrixConnectionError
+from mautrix.util.manhole import start_manhole
+
+from .. import __version__
+from . import command_handler, CommandEvent, SECTION_ADMIN
+
+
+@dataclass
+class ManholeState:
+    server: asyncio.AbstractServer
+    opened_by: UserID
+    close: Callable[[], None]
+    whitelist: Set[int]
+
+
+@command_handler(needs_auth=False, needs_admin=True, help_section=SECTION_ADMIN,
+                 help_text="Open a manhole into the bridge.", help_args="<_uid..._>")
+async def open_manhole(evt: CommandEvent) -> None:
+    if not evt.config["manhole.enabled"]:
+        await evt.reply("The manhole has been disabled in the config.")
+        return
+    elif len(evt.args) == 0:
+        await evt.reply("**Usage:** `$cmdprefix+sp open-manhole <uid...>`")
+        return
+
+    whitelist = set()
+    whitelist_whitelist = evt.config["manhole.whitelist"]
+    for arg in evt.args:
+        try:
+            uid = int(arg)
+        except ValueError:
+            await evt.reply(f"{arg} is not an integer.")
+            return
+        if whitelist_whitelist and uid not in whitelist_whitelist:
+            await evt.reply(f"{uid} is not in the list of allowed UIDs.")
+            return
+        whitelist.add(uid)
+
+    if evt.bridge.manhole:
+        added = [uid for uid in whitelist
+                 if uid not in evt.bridge.manhole.whitelist]
+        evt.bridge.manhole.whitelist |= set(added)
+        if len(added) == 0:
+            await evt.reply(f"There's an existing manhole opened by {evt.bridge.manhole.opened_by}"
+                            " and all the given UIDs are already whitelisted.")
+        else:
+            added_str = (f"{', '.join(str(uid) for uid in added[:-1])} and {added[-1]}"
+                         if len(added) > 1 else added[0])
+            await evt.reply(f"There's an existing manhole opened by {evt.bridge.manhole.opened_by}"
+                            f". Added {added_str} to the whitelist.")
+            evt.log.info(f"{evt.sender.mxid} added {added_str} to the manhole whitelist.")
+        return
+
+    from ..portal import Portal
+    from ..puppet import Puppet
+    from ..user import User
+    namespace = {
+        "bridge": evt.bridge,
+        "User": User,
+        "Portal": Portal,
+        "Puppet": Puppet,
+    }
+    banner = (f"Python {sys.version} on {sys.platform}\n"
+              f"mautrix-telegram {__version__} with mautrix-python {__mautrix_version__} "
+              f"and Telethon {__telethon_version__}\n\nManhole opened by {evt.sender.mxid}\n")
+    path = evt.config["manhole.path"]
+
+    wl_list = list(whitelist)
+    whitelist_str = (f"{', '.join(str(uid) for uid in wl_list[:-1])} and {wl_list[-1]}"
+                     if len(wl_list) > 1 else wl_list[0])
+    evt.log.info(f"{evt.sender.mxid} opened a manhole with {whitelist_str} whitelisted.")
+    server, close = await start_manhole(path=path, banner=banner, namespace=namespace,
+                                        loop=evt.loop, whitelist=whitelist)
+    evt.bridge.manhole = ManholeState(server=server, opened_by=evt.sender.mxid, close=close,
+                                      whitelist=whitelist)
+    plrl = "s" if len(whitelist) != 1 else ""
+    await evt.reply(f"Opened manhole at unix://{path} with UID{plrl} {whitelist_str} whitelisted")
+    await server.wait_closed()
+    evt.bridge.manhole = None
+    try:
+        os.unlink(path)
+    except FileNotFoundError:
+        pass
+    evt.log.info(f"{evt.sender.mxid}'s manhole was closed.")
+    try:
+        await evt.reply("Your manhole was closed.")
+    except (AttributeError, MatrixConnectionError) as e:
+        evt.log.warning(f"Failed to send manhole close notification: {e}")
+
+
+@command_handler(needs_auth=False, needs_admin=True, help_section=SECTION_ADMIN,
+                 help_text="Close an open manhole.")
+async def close_manhole(evt: CommandEvent) -> None:
+    if not evt.bridge.manhole:
+        await evt.reply("There is no open manhole.")
+        return
+
+    opened_by = evt.bridge.manhole.opened_by
+    evt.bridge.manhole.close()
+    evt.bridge.manhole = None
+    if opened_by != evt.sender.mxid:
+        await evt.reply(f"Closed manhole opened by {opened_by}")

mautrix_telegram/commands/matrix_auth.py

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

mautrix_telegram/commands/meta.py

@@ -1,72 +0,0 @@
-# -*- coding: future_fstrings -*-
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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(needs_auth=False, needs_puppeting=False,
-                 help_section=SECTION_GENERAL,
-                 help_text="Show this help message.")
-async def help(evt: CommandEvent) -> Optional[Dict]:
-    return await evt.reply(_get_management_status(evt) + "\n" + await _get_help_text(evt))

mautrix_telegram/commands/portal/admin.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,45 +13,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 typing import Dict
 import asyncio
 
-from mautrix_appservice import MatrixRequestError
+from mautrix.types import EventID
 
 from ... import portal as po, puppet as pu, user as u
 from .. import command_handler, CommandEvent, SECTION_ADMIN
 
 
-@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:
+async def clear_db_cache(evt: CommandEvent) -> EventID:
     try:
         section = evt.args[0].lower()
-    except KeyError:
+    except IndexError:
         return await evt.reply("**Usage:** `$cmdprefix+sp clear-db-cache <section>`")
     if section == "portal":
         po.Portal.by_tgid = {}
@@ -63,9 +39,8 @@ async def clear_db_cache(evt: CommandEvent) -> Dict:
         for puppet in pu.Puppet.by_custom_mxid.values():
             puppet.sync_task.cancel()
         pu.Puppet.by_custom_mxid = {}
-        await asyncio.gather(
-            *[puppet.init_custom_mxid() for puppet in pu.Puppet.all_with_custom_mxid()],
-            loop=evt.loop)
+        await asyncio.gather(*[puppet.try_start() for puppet in pu.Puppet.all_with_custom_mxid()],
+                             loop=evt.loop)
         await evt.reply("Cleared puppet cache and restarted custom puppet syncers")
     elif section == "user":
         u.User.by_mxid = {
@@ -81,7 +56,7 @@ async def clear_db_cache(evt: CommandEvent) -> Dict:
                  help_section=SECTION_ADMIN,
                  help_args="[_mxid_]",
                  help_text="Reload and reconnect a user")
-async def reload_user(evt: CommandEvent) -> Dict:
+async def reload_user(evt: CommandEvent) -> EventID:
     if len(evt.args) > 0:
         mxid = evt.args[0]
     else:
@@ -89,7 +64,7 @@ async def reload_user(evt: CommandEvent) -> Dict:
     user = u.User.get_by_mxid(mxid, create=False)
     if not user:
         return await evt.reply("User not found")
-    puppet = pu.Puppet.get_by_custom_mxid(mxid)
+    puppet = await pu.Puppet.get_by_custom_mxid(mxid)
     if puppet:
         puppet.sync_task.cancel()
     await user.stop()
@@ -97,5 +72,5 @@ async def reload_user(evt: CommandEvent) -> Dict:
     user = u.User.get_by_mxid(mxid)
     await user.ensure_started()
     if puppet:
-        await puppet.init_custom_mxid()
-    await evt.reply(f"Reloaded and reconnected {user.mxid} (telegram: {user.human_tg_id})")
+        await puppet.start()
+    return await evt.reply(f"Reloaded and reconnected {user.mxid} (telegram: {user.human_tg_id})")

mautrix_telegram/commands/portal/bridge.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,13 +13,14 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict, Optional, Tuple, Coroutine
+from typing import Optional, Tuple, Awaitable
 import asyncio
 
 from telethon.tl.types import ChatForbidden, ChannelForbidden
 
-from ...types import MatrixRoomID, TelegramID
-from ...util import ignore_coro
+from mautrix.types import EventID, RoomID
+
+from ...types import TelegramID
 from ... import portal as po
 from .. import command_handler, CommandEvent, SECTION_CREATING_PORTALS
 from .util import user_has_power_level, get_initial_state
@@ -32,11 +32,15 @@ from .util import user_has_power_level, get_initial_state
                  help_text="Bridge the current Matrix room to the Telegram chat with the given "
                            "ID. The ID must be the prefixed version that you get with the `/id` "
                            "command of the Telegram-side bot.")
-async def bridge(evt: CommandEvent) -> Dict:
+async def bridge(evt: CommandEvent) -> EventID:
     if len(evt.args) == 0:
         return await evt.reply("**Usage:** "
                                "`$cmdprefix+sp bridge <Telegram chat ID> [Matrix room ID]`")
-    room_id = MatrixRoomID(evt.args[1]) if len(evt.args) > 1 else evt.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
     that_this = "This" if room_id == evt.room_id else "That"
 
     portal = po.Portal.get_by_mxid(room_id)
@@ -61,7 +65,7 @@ async def bridge(evt: CommandEvent) -> Dict:
                                "Bridging private chats to existing rooms is not allowed.")
 
     portal = po.Portal.get_by_tgid(tgid, peer_type=peer_type)
-    if not portal.allow_bridging():
+    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.")
@@ -80,6 +84,7 @@ async def bridge(evt: CommandEvent) -> Dict:
             "bridge_to_mxid": room_id,
             "tgid": portal.tgid,
             "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"
@@ -93,25 +98,24 @@ async def bridge(evt: CommandEvent) -> Dict:
         "bridge_to_mxid": room_id,
         "tgid": portal.tgid,
         "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`")
 
 
 async def cleanup_old_portal_while_bridging(evt: CommandEvent, portal: "po.Portal"
-                                            ) -> Tuple[bool, Optional[Coroutine[None, None, None]]]:
+                                            ) -> Tuple[bool, Optional[Awaitable[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...")
         return True, None
     elif evt.args[0] == "delete-and-continue":
-        return True, portal.cleanup_room(portal.main_intent, portal.mxid,
-                                         message="Portal deleted (moving to another room)")
+        return True, portal.cleanup_portal("Portal deleted (moving to another room)", delete=False)
     elif evt.args[0] == "unbridge-and-continue":
-        return True, portal.cleanup_room(portal.main_intent, portal.mxid,
-                                         message="Room unbridged (portal moving to another room)",
-                                         puppets_only=True)
+        return True, portal.cleanup_portal("Room unbridged (portal moving to another room)",
+                                           puppets_only=True, delete=False)
     else:
         await evt.reply(
             "The chat you were trying to bridge already has a Matrix portal room.\n\n"
@@ -122,7 +126,7 @@ async def cleanup_old_portal_while_bridging(evt: CommandEvent, portal: "po.Porta
         return False, None
 
 
-async def confirm_bridge(evt: CommandEvent) -> Optional[Dict]:
+async def confirm_bridge(evt: CommandEvent) -> Optional[EventID]:
     status = evt.sender.command_status
     try:
         portal = po.Portal.get_by_tgid(status["tgid"], peer_type=status["peer_type"])
@@ -132,12 +136,15 @@ async def confirm_bridge(evt: CommandEvent) -> Optional[Dict]:
         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"]
+
     if "mxid" in status:
         ok, coro = await cleanup_old_portal_while_bridging(evt, portal)
         if not ok:
             return None
         elif coro:
-            ignore_coro(asyncio.ensure_future(coro, loop=evt.loop))
+            asyncio.ensure_future(coro, loop=evt.loop)
             await evt.reply("Cleaning up previous portal room...")
     elif portal.mxid:
         evt.sender.command_status = None
@@ -149,7 +156,13 @@ async def confirm_bridge(evt: CommandEvent) -> Optional[Dict]:
                                "`$cmdprefix+sp cancel` to cancel.")
 
     evt.sender.command_status = None
-    is_logged_in = await evt.sender.is_logged_in()
+    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) -> Optional[EventID]:
     user = evt.sender if is_logged_in else evt.tgbot
     try:
         entity = await user.client.get_entity(portal.peer)
@@ -167,15 +180,14 @@ async def confirm_bridge(evt: CommandEvent) -> Optional[Dict]:
         else:
             return await evt.reply("The bot doesn't seem to be in that chat.")
 
-    direct = False
-
-    portal.mxid = bridge_to_mxid
-    portal.title, portal.about, levels = await get_initial_state(evt.az.intent, evt.room_id)
+    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)
     portal.photo_id = ""
-    portal.save()
+    await portal.save()
 
-    ignore_coro(asyncio.ensure_future(portal.update_matrix_room(user, entity, direct,
-                                                                levels=levels),
-                                      loop=evt.loop))
+    asyncio.ensure_future(portal.update_matrix_room(user, entity, direct=False, levels=levels),
+                          loop=evt.loop)
 
     return await evt.reply("Bridging complete. Portal synchronization should begin momentarily.")

mautrix_telegram/commands/portal/config.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,14 +13,19 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict, Awaitable
+from typing import Awaitable, Any
 from io import StringIO
 
-from ...config import yaml
-from ... import portal as po, user as u, util
+from ruamel.yaml import YAMLError
+
+from mautrix.util.config import yaml
+from mautrix.types import EventID
+
+from ... import portal as po, util
 from .. import command_handler, CommandEvent, SECTION_PORTAL_MANAGEMENT
 
-@command_handler(help_section=SECTION_PORTAL_MANAGEMENT,
+
+@command_handler(needs_auth=False, help_section=SECTION_PORTAL_MANAGEMENT,
                  help_text="View or change per-portal settings.",
                  help_args="<`help`|_subcommand_> [...]")
 async def config(evt: CommandEvent) -> None:
@@ -41,8 +45,16 @@ 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
-    value = yaml.load(" ".join(evt.args[2:])) if len(evt.args) > 2 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
     if cmd == "set":
         await config_set(evt, portal, key, value)
     elif cmd == "unset":
@@ -51,10 +63,10 @@ async def config(evt: CommandEvent) -> None:
         await config_add_del(evt, portal, key, value, cmd)
     else:
         return
-    portal.save()
+    await portal.save()
 
 
-def config_help(evt: CommandEvent) -> Awaitable[Dict]:
+def config_help(evt: CommandEvent) -> Awaitable[EventID]:
     return evt.reply("""**Usage:** `$cmdprefix config <subcommand> [...]`. Subcommands:
 
 * **help** - View this help text.
@@ -67,16 +79,12 @@ def config_help(evt: CommandEvent) -> Awaitable[Dict]:
 """)
 
 
-def config_view(evt: CommandEvent, portal: po.Portal) -> Awaitable[Dict]:
-    stream = StringIO()
-    yaml.dump(portal.local_config, stream)
-    return evt.reply(f"Room-specific config:\n\n```yaml\n{stream.getvalue()}```")
+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[Dict]:
-    stream = StringIO()
-    yaml.dump({
-        "edits_as_replies": evt.config["bridge.edits_as_replies"],
+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"],
@@ -84,23 +92,34 @@ def config_defaults(evt: CommandEvent) -> Awaitable[Dict]:
         "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"],
+        "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"],
-    }, stream)
-    return evt.reply(f"Bridge instance wide config:\n\n```yaml\n{stream.getvalue()}```")
+    })
+    return evt.reply(f"Bridge instance wide config:\n{value.rstrip()}")
 
 
-def config_set(evt: CommandEvent, portal: po.Portal, key: str, value: str) -> Awaitable[Dict]:
+def _str_value(value: Any) -> str:
+    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}`"
+
+
+def config_set(evt: CommandEvent, portal: po.Portal, key: str, value: Any) -> Awaitable[EventID]:
     if not key or value is None:
         return evt.reply(f"**Usage:** `$cmdprefix+sp config set <key> <value>`")
     elif util.recursive_set(portal.local_config, key, value):
-        return evt.reply(f"Successfully set the value of `{key}` to `{value}`.")
+        return evt.reply(f"Successfully set the value of `{key}` to {_str_value(value)}".rstrip())
     else:
         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[Dict]:
+def config_unset(evt: CommandEvent, portal: po.Portal, key: str) -> Awaitable[EventID]:
     if not key:
         return evt.reply(f"**Usage:** `$cmdprefix+sp config unset <key>`")
     elif util.recursive_del(portal.local_config, key):
@@ -110,7 +129,7 @@ def config_unset(evt: CommandEvent, portal: po.Portal, key: str) -> Awaitable[Di
 
 
 def config_add_del(evt: CommandEvent, portal: po.Portal, key: str, value: str, cmd: str
-                   ) -> Awaitable[Dict]:
+                   ) -> Awaitable[EventID]:
     if not key or value is None:
         return evt.reply(f"**Usage:** `$cmdprefix+sp config {cmd} <key> <value>`")
 
@@ -122,11 +141,11 @@ def config_add_del(evt: CommandEvent, portal: po.Portal, key: str, value: str, c
         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 `{value}`.")
+            return evt.reply(f"The array at `{key}` already contains {_str_value(value)}".rstrip())
         arr.append(value)
-        return evt.reply(f"Successfully added `{value}` to the array at `{key}`")
+        return evt.reply(f"Successfully added {_str_value(value)} to the array at `{key}`")
     else:
         if value not in arr:
-            return evt.reply(f"The array at `{key}` does not contain `{value}`.")
+            return evt.reply(f"The array at `{key}` does not contain {_str_value(value)}")
         arr.remove(value)
-        return evt.reply(f"Successfully removed `{value}` from the array at `{key}`")
+        return evt.reply(f"Successfully removed {_str_value(value)} from the array at `{key}`")

mautrix_telegram/commands/portal/create_chat.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,9 +13,10 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict
+from mautrix.types import EventID
 
 from ... import portal as po
+from ...types import TelegramID
 from .. import command_handler, CommandEvent, SECTION_CREATING_PORTALS
 from .util import user_has_power_level, get_initial_state
 
@@ -25,10 +25,10 @@ from .util import user_has_power_level, get_initial_state
                  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"}:
+                           "`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"):
         return await evt.reply(
             "**Usage:** `$cmdprefix+sp create ['group'/'supergroup'/'channel']`")
 
@@ -38,7 +38,7 @@ async def create(evt: CommandEvent) -> Dict:
     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 = await get_initial_state(evt.az.intent, evt.room_id)
+    title, about, levels, encrypted = 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.")
 
@@ -50,10 +50,17 @@ async def create(evt: CommandEvent) -> Dict:
         "group": "chat",
     }[type]
 
-    portal = po.Portal(tgid=None, mxid=evt.room_id, title=title, about=about, peer_type=type)
+    portal = po.Portal(tgid=TelegramID(0), peer_type=type, mxid=evt.room_id,
+                       title=title, about=about, encrypted=encrypted)
+    invites, errors = await portal.get_telegram_users_in_matrix_room(evt.sender)
+    if len(errors) > 0:
+        error_list = "\n".join(f"* [{mxid}](https://matrix.to/#/{mxid})" for mxid in errors)
+        await evt.reply(f"Failed to add the following users to the chat:\n\n{error_list}\n\n"
+                        "You can try `$cmdprefix+sp search -r <username>` to help the bridge find "
+                        "those users.")
     try:
-        await portal.create_telegram_chat(evt.sender, supergroup=supergroup)
+        await portal.create_telegram_chat(evt.sender, invites=invites, supergroup=supergroup)
     except ValueError as e:
-        portal.delete()
+        await portal.delete()
         return await evt.reply(e.args[0])
     return await evt.reply(f"Telegram chat created. ID: {portal.tgid}")

mautrix_telegram/commands/portal/filter.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,7 +13,7 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict, Optional
+from mautrix.types import EventID
 
 from ... import portal as po
 from .. import command_handler, CommandEvent, SECTION_ADMIN
@@ -25,7 +24,7 @@ from .. import command_handler, CommandEvent, SECTION_ADMIN
                  help_args="<`whitelist`|`blacklist`>",
                  help_text="Change whether the bridge will allow or disallow bridging rooms by "
                            "default.")
-async def filter_mode(evt: CommandEvent) -> Dict:
+async def filter_mode(evt: CommandEvent) -> EventID:
     try:
         mode = evt.args[0]
         if mode not in ("whitelist", "blacklist"):
@@ -46,11 +45,11 @@ async def filter_mode(evt: CommandEvent) -> Dict:
                                "`!filter blacklist <chat ID>`.")
 
 
-@command_handler(needs_admin=True,
+@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 filter(evt: CommandEvent) -> Optional[Dict]:
+async def edit_filter(evt: CommandEvent) -> EventID:
     try:
         action = evt.args[0]
         if action not in ("whitelist", "blacklist", "add", "remove"):
@@ -58,11 +57,11 @@ async def filter(evt: CommandEvent) -> Optional[Dict]:
 
         id_str = evt.args[1]
         if id_str.startswith("-100"):
-            id = int(id_str[4:])
+            filter_id = int(id_str[4:])
         elif id_str.startswith("-"):
-            id = int(id_str[1:])
+            filter_id = int(id_str[1:])
         else:
-            id = int(id_str)
+            filter_id = int(id_str)
     except (IndexError, ValueError):
         return await evt.reply("**Usage:** `$cmdprefix+sp filter <whitelist/blacklist> <chat ID>`")
 
@@ -70,26 +69,27 @@ async def filter(evt: CommandEvent) -> Optional[Dict]:
     if mode not in ("blacklist", "whitelist"):
         return await evt.reply(f"Unknown filter mode \"{mode}\". Please fix the bridge config.")
 
-    list = evt.config["bridge.filter.list"]
+    filter_id_list = evt.config["bridge.filter.list"]
 
     if action in ("blacklist", "whitelist"):
         action = "add" if mode == action else "remove"
 
     def save() -> None:
-        evt.config["bridge.filter.list"] = list
+        evt.config["bridge.filter.list"] = filter_id_list
         evt.config.save()
-        po.Portal.filter_list = list
+        po.Portal.filter_list = filter_id_list
 
     if action == "add":
-        if id in list:
+        if filter_id in filter_id_list:
             return await evt.reply(f"That chat is already {mode}ed.")
-        list.append(id)
+        filter_id_list.append(filter_id)
         save()
         return await evt.reply(f"Chat ID added to {mode}.")
     elif action == "remove":
-        if id not in list:
+        if filter_id not in filter_id_list:
             return await evt.reply(f"That chat is not {mode}ed.")
-        list.remove(id)
+        filter_id_list.remove(filter_id)
         save()
         return await evt.reply(f"Chat ID removed from {mode}.")
-    return None
+    else:
+        return await evt.reply("**Usage:** `$cmdprefix+sp filter <whitelist/blacklist> <chat ID>`")

mautrix_telegram/commands/portal/misc.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,10 +13,16 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict
+from typing import Optional, List, Tuple
+from datetime import timedelta, datetime
+import re
 
+from telethon.tl.functions.channels import GetFullChannelRequest
+from telethon.tl.functions.messages import GetFullChatRequest
 from telethon.errors import (ChatAdminRequiredError, UsernameInvalidError,
-                             UsernameNotModifiedError, UsernameOccupiedError)
+                             UsernameNotModifiedError, UsernameOccupiedError, RPCError)
+
+from mautrix.types import EventID
 
 from ... import portal as po
 from .. import command_handler, CommandEvent, SECTION_PORTAL_MANAGEMENT, SECTION_MISC
@@ -27,21 +32,47 @@ from .util import user_has_power_level
 @command_handler(needs_admin=False, needs_puppeting=False, needs_auth=False,
                  help_section=SECTION_MISC,
                  help_text="Fetch Matrix room state to ensure the bridge has up-to-date info.")
-async def sync_state(evt: CommandEvent) -> Dict:
+async def sync_state(evt: CommandEvent) -> EventID:
     portal = po.Portal.get_by_mxid(evt.room_id)
     if not portal:
         return await evt.reply("This is not a portal room.")
     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.sync_matrix_members()
+    await portal.main_intent.get_joined_members(portal.mxid)
     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 = 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 id(evt: CommandEvent) -> Dict:
+async def get_id(evt: CommandEvent) -> EventID:
     portal = po.Portal.get_by_mxid(evt.room_id)
     if not portal:
         return await evt.reply("This is not a portal room.")
@@ -53,9 +84,81 @@ async def id(evt: CommandEvent) -> Dict:
     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>]`"
+                     "\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)")
+
+
+def _parse_flag(args: List[str]) -> Tuple[str, str]:
+    arg = args.pop(0).lower()
+    if arg.startswith("--"):
+        value_start = arg.index("=")
+        if value_start:
+            flag = arg[2:value_start]
+            value = arg[value_start+1:]
+        else:
+            flag = arg[2:]
+            value = args.pop(0).lower()
+    elif arg.startswith("-"):
+        flag = arg[1]
+        if len(arg) > 3 and arg[2] == "=":
+            value = arg[3:]
+        else:
+            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) -> Optional[timedelta]:
+    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.")
-async def invite_link(evt: CommandEvent) -> Dict:
+                 help_text="Get a Telegram invite link to the current chat.",
+                 help_args="[--uses=<amount>] [--expire=<time delta, e.g. 1d>]")
+async def invite_link(evt: CommandEvent) -> EventID:
+    # TODO once we switch to Python 3.9 minimum, use argparse with exit_on_error=False
+    uses = None
+    expire = None
+    while evt.args:
+        try:
+            flag, value = _parse_flag(evt.args)
+        except (ValueError, IndexError):
+            return await evt.reply(invite_link_usage)
+        if 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
+
     portal = po.Portal.get_by_mxid(evt.room_id)
     if not portal:
         return await evt.reply("This is not a portal room.")
@@ -64,7 +167,7 @@ async def invite_link(evt: CommandEvent) -> Dict:
         return await evt.reply("You can't invite users to private chats.")
 
     try:
-        link = await portal.get_invite_link(evt.sender)
+        link = await portal.get_invite_link(evt.sender, uses=uses, expire=expire)
         return await evt.reply(f"Invite link to {portal.title}: {link}")
     except ValueError as e:
         return await evt.reply(e.args[0])
@@ -74,7 +177,7 @@ async def invite_link(evt: CommandEvent) -> Dict:
 
 @command_handler(help_section=SECTION_PORTAL_MANAGEMENT,
                  help_text="Upgrade a normal Telegram group to a supergroup.")
-async def upgrade(evt: CommandEvent) -> Dict:
+async def upgrade(evt: CommandEvent) -> EventID:
     portal = po.Portal.get_by_mxid(evt.room_id)
     if not portal:
         return await evt.reply("This is not a portal room.")
@@ -96,7 +199,7 @@ async def upgrade(evt: CommandEvent) -> Dict:
                  help_args="<_name_|`-`>",
                  help_text="Change the username of a supergroup/channel. "
                            "To disable, use a dash (`-`) as the name.")
-async def group_name(evt: CommandEvent) -> Dict:
+async def group_name(evt: CommandEvent) -> EventID:
     if len(evt.args) == 0:
         return await evt.reply("**Usage:** `$cmdprefix+sp group-name <name/->`")
 

mautrix_telegram/commands/portal/unbridge.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -16,16 +15,15 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 from typing import Dict, Callable, Optional
 
-from ...types import MatrixRoomID
+from mautrix.types import RoomID, EventID
+
 from ... import portal as po
 from .. import command_handler, CommandEvent, SECTION_PORTAL_MANAGEMENT
-from .util import user_has_power_level, get_initial_state
+from .util import user_has_power_level
 
 
-async def _get_portal_and_check_permission(evt: CommandEvent, permission: str,
-                                           action: Optional[str] = None
-                                           ) -> Optional[po.Portal]:
-    room_id = MatrixRoomID(evt.args[0]) if len(evt.args) > 0 else evt.room_id
+async def _get_portal_and_check_permission(evt: CommandEvent) -> Optional[po.Portal]:
+    room_id = RoomID(evt.args[0]) if len(evt.args) > 0 else evt.room_id
 
     portal = po.Portal.get_by_mxid(room_id)
     if not portal:
@@ -33,16 +31,21 @@ async def _get_portal_and_check_permission(evt: CommandEvent, permission: str,
         await evt.reply(f"{that_this} is not a portal room.")
         return None
 
-    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.")
+    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.")
         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) -> Optional[Dict]:
+    async def post_confirm(confirm) -> Optional[EventID]:
         confirm.sender.command_status = None
         if len(confirm.args) > 0 and confirm.args[0] == f"confirm-{command}":
             await function()
@@ -63,8 +66,8 @@ def _get_portal_murder_function(action: str, room_id: str, function: Callable, c
                  help_text="Remove all users from the current portal room and forget the portal. "
                            "Only works for group chats; to delete a private chat portal, simply "
                            "leave the room.")
-async def delete_portal(evt: CommandEvent) -> Optional[Dict]:
-    portal = await _get_portal_and_check_permission(evt, "unbridge")
+async def delete_portal(evt: CommandEvent) -> Optional[EventID]:
+    portal = await _get_portal_and_check_permission(evt)
     if not portal:
         return None
 
@@ -84,8 +87,8 @@ async def delete_portal(evt: CommandEvent) -> Optional[Dict]:
 @command_handler(needs_auth=False, needs_puppeting=False,
                  help_section=SECTION_PORTAL_MANAGEMENT,
                  help_text="Remove puppets from the current portal room and forget the portal.")
-async def unbridge(evt: CommandEvent) -> Optional[Dict]:
-    portal = await _get_portal_and_check_permission(evt, "unbridge")
+async def unbridge(evt: CommandEvent) -> Optional[EventID]:
+    portal = await _get_portal_and_check_permission(evt)
     if not portal:
         return None
 

mautrix_telegram/commands/portal/util.py

@@ -1,40 +1,62 @@
-from typing import Dict, Tuple
+# 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 Tuple, Optional
 
-from mautrix_appservice import MatrixRequestError, IntentAPI
+from mautrix.errors import MatrixRequestError
+from mautrix.appservice import IntentAPI
+from mautrix.types import RoomID, EventType, PowerLevelStateEventContent
 
 from ... import user as u
 
+OptStr = Optional[str]
 
-async def get_initial_state(intent: IntentAPI, room_id: str) -> Tuple[str, str, Dict]:
-    state = await intent.get_room_state(room_id)
-    title = None
-    about = None
-    levels = None
+
+async def get_initial_state(intent: IntentAPI, room_id: RoomID
+                            ) -> Tuple[OptStr, OptStr, Optional[PowerLevelStateEventContent], bool]:
+    state = await intent.get_state(room_id)
+    title: OptStr = None
+    about: OptStr = None
+    levels: Optional[PowerLevelStateEventContent] = None
+    encrypted: bool = False
     for event in state:
         try:
-            if event["type"] == "m.room.name":
-                title = event["content"]["name"]
-            elif event["type"] == "m.room.topic":
-                about = event["content"]["topic"]
-            elif event["type"] == "m.room.power_levels":
-                levels = event["content"]
-            elif event["type"] == "m.room.canonical_alias":
-                title = title or event["content"]["alias"]
+            if event.type == EventType.ROOM_NAME:
+                title = event.content.name
+            elif event.type == EventType.ROOM_TOPIC:
+                about = event.content.topic
+            elif event.type == EventType.ROOM_POWER_LEVELS:
+                levels = event.content
+            elif event.type == EventType.ROOM_CANONICAL_ALIAS:
+                title = title or event.content.canonical_alias
+            elif event.type == EventType.ROOM_ENCRYPTION:
+                encrypted = True
         except KeyError:
             # Some state event probably has empty content
             pass
-    return title, about, levels
+    return title, about, levels, encrypted
 
 
-async def user_has_power_level(room: str, intent, sender: u.User, event: str, default: int = 50
-                               ) -> bool:
+async def user_has_power_level(room_id: RoomID, intent: IntentAPI, sender: u.User,
+                               event: str) -> bool:
     if sender.is_admin:
         return True
     # Make sure the state store contains the power levels.
     try:
-        await intent.get_power_levels(room)
+        await intent.get_power_levels(room_id)
     except MatrixRequestError:
         return False
-    return intent.state_store.has_power_level(room, sender.mxid,
-                                              event=f"net.maunium.telegram.{event}",
-                                              default=default)
+    event_type = EventType.find(f"net.maunium.telegram.{event}", t_class=EventType.Class.STATE)
+    return await intent.state_store.has_power_level(room_id, sender.mxid, event_type)

mautrix_telegram/commands/telegram/account.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,22 +13,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 typing import Dict, Optional
+from typing import Optional
 
 from telethon.errors import (UsernameInvalidError, UsernameNotModifiedError, UsernameOccupiedError,
-                             HashInvalidError)
+                             HashInvalidError, AuthKeyError, FirstNameInvalidError, AboutTooLongError)
 from telethon.tl.types import Authorization
 from telethon.tl.functions.account import (UpdateUsernameRequest, GetAuthorizationsRequest,
-                                           ResetAuthorizationRequest)
+                                           ResetAuthorizationRequest, UpdateProfileRequest)
 
-from mautrix_telegram.commands import command_handler, CommandEvent, SECTION_AUTH
+from mautrix.types import EventID
+
+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) -> Optional[Dict]:
+async def username(evt: CommandEvent) -> EventID:
     if len(evt.args) == 0:
         return await evt.reply("**Usage:** `$cmdprefix+sp username <new username>`")
     if evt.sender.is_bot:
@@ -52,6 +53,42 @@ async def username(evt: CommandEvent) -> Optional[Dict]:
     else:
         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:
+    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]))
+    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")
+
 
 def _format_session(sess: Authorization) -> str:
     return (f"**{sess.app_name} {sess.app_version}**  \n"
@@ -64,7 +101,7 @@ def _format_session(sess: Authorization) -> str:
                  help_section=SECTION_AUTH,
                  help_args="<`list`|`terminate`> [_hash_]",
                  help_text="View or delete other Telegram sessions.")
-async def session(evt: CommandEvent) -> Optional[Dict]:
+async def session(evt: CommandEvent) -> EventID:
     if len(evt.args) == 0:
         return await evt.reply("**Usage:** `$cmdprefix+sp session <list|terminate> [hash]`")
     elif evt.sender.is_bot:
@@ -87,13 +124,16 @@ async def session(evt: CommandEvent) -> Optional[Dict]:
         try:
             session_hash = int(evt.args[1])
         except ValueError:
-            return await evt.reply("Hash must be a positive integer")
-        if session_hash <= 0:
-            return await evt.reply("Hash must be a positive integer")
+            return await evt.reply("Hash must be an integer")
         try:
             ok = await evt.sender.client(ResetAuthorizationRequest(hash=session_hash))
         except HashInvalidError:
             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.")
+            raise
         if ok:
             return await evt.reply("Session terminated successfully.")
         else:

mautrix_telegram/commands/telegram/auth.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -16,25 +15,40 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 from typing import Any, Dict, Optional
 import asyncio
+import io
 
-from telethon.errors import (
+from telethon.errors import (  # isort: skip
     AccessTokenExpiredError, AccessTokenInvalidError, FirstNameInvalidError, FloodWaitError,
     PasswordHashInvalidError, PhoneCodeExpiredError, PhoneCodeInvalidError,
     PhoneNumberAppSignupForbiddenError, PhoneNumberBannedError, PhoneNumberFloodError,
-    PhoneNumberOccupiedError, PhoneNumberUnoccupiedError, SessionPasswordNeededError)
+    PhoneNumberOccupiedError, PhoneNumberUnoccupiedError, SessionPasswordNeededError,
+    PhoneNumberInvalidError)
+from telethon.tl.types import User
 
-from mautrix_telegram.commands import command_handler, CommandEvent, SECTION_AUTH
-from mautrix_telegram import puppet as pu, user as u
-from mautrix_telegram.util import format_duration, ignore_coro
+from mautrix.types import (EventID, UserID, MediaMessageEventContent, ImageInfo, MessageType,
+                           TextMessageEventContent)
+
+from ... import user as u
+from ...types import TelegramID
+from ...commands import command_handler, CommandEvent, SECTION_AUTH
+from ...util import format_duration as fmt_duration
+
+try:
+    import qrcode
+    import PIL as _
+    from telethon.tl.custom import QRLogin
+except ImportError:
+    qrcode = None
+    QRLogin = None
 
 
 @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]:
+async def ping(evt: CommandEvent) -> EventID:
     me = await evt.sender.client.get_me() if await evt.sender.is_logged_in() else None
-    human_tg_id = f"@{me.username}" if me.username else f"+{me.phone}"
     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.")
@@ -43,14 +57,12 @@ async def ping(evt: CommandEvent) -> Optional[Dict]:
 @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]:
+async def ping_bot(evt: CommandEvent) -> EventID:
     if not evt.tgbot:
         return await evt.reply("Telegram message relay bot not configured.")
-    bot_info = await evt.tgbot.client.get_me()
-    mxid = pu.Puppet.get_mxid_from_id(bot_info.id)
-    displayname = bot_info.first_name
+    info, mxid = await evt.tgbot.get_me(use_cache=False)
     return await evt.reply("Telegram message relay bot is active: "
-                           f"[{displayname}](https://matrix.to/#/{mxid}) (ID {bot_info.id})\n\n"
+                           f"[{info.first_name}](https://matrix.to/#/{mxid}) (ID {info.id})\n\n"
                            "To use the bot, simply invite it to a portal room.")
 
 
@@ -58,7 +70,7 @@ async def ping_bot(evt: CommandEvent) -> Optional[Dict]:
                  help_section=SECTION_AUTH,
                  help_args="<_phone_> <_full name_>",
                  help_text="Register to Telegram")
-async def register(evt: CommandEvent) -> Optional[Dict]:
+async def register(evt: CommandEvent) -> EventID:
     if await evt.sender.is_logged_in():
         return await evt.reply("You are already logged in.")
     elif len(evt.args) < 1:
@@ -75,17 +87,18 @@ async def register(evt: CommandEvent) -> Optional[Dict]:
         "action": "Register",
         "full_name": full_name,
     })
-    return None
+    return await evt.reply("By signing up for Telegram, you agree to "
+                           "the terms of service: https://telegram.org/tos")
 
 
-async def enter_code_register(evt: CommandEvent) -> Dict:
+async def enter_code_register(evt: CommandEvent) -> EventID:
     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))
+        asyncio.ensure_future(evt.sender.post_login(user, first_login=True), loop=evt.loop)
         evt.sender.command_status = None
         return await evt.reply(f"Successfully registered to Telegram.")
     except PhoneNumberOccupiedError:
@@ -104,18 +117,76 @@ async def enter_code_register(evt: CommandEvent) -> Dict:
                                "Check console for more details.")
 
 
+@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 = 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}.")
+
+    await login_as.ensure_started(even_if_no_session=True)
+    qr_login = QRLogin(login_as.client, ignored_ids=[])
+    qr_event_id: Optional[EventID] = 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.")
+    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)
+
+    return await _finish_sign_in(evt, user, login_as=login_as)
+
+
 @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]:
+async def login(evt: CommandEvent) -> EventID:
     override_sender = False
     if len(evt.args) > 0 and evt.sender.is_admin:
-        evt.sender = await u.User.get_by_mxid(evt.args[0]).ensure_started()
+        evt.sender = await u.User.get_by_mxid(UserID(evt.args[0])).ensure_started()
         override_sender = True
     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.get("bridge.allow_matrix_login", True)
+    allow_matrix_login = evt.config["bridge.allow_matrix_login"]
     if allow_matrix_login and not override_sender:
         evt.sender.command_status = {
             "next": enter_phone_or_token,
@@ -126,46 +197,25 @@ async def login(evt: CommandEvent) -> Optional[Dict]:
     if evt.config["appservice.public.enabled"]:
         prefix = evt.config["appservice.public.external"]
         url = f"{prefix}/login?token={evt.public_website.make_token(evt.sender.mxid, '/login')}"
-        if allow_matrix_login:
-            if override_sender:
-                return await evt.reply(
-                    "This bridge instance allows you to log in inside or outside of Matrix, but "
-                    "logging in as another user is only possible via the web interface.\n\n"
-                    f"Please visit [the login page]({url}) to log in as "
-                    f"[{evt.sender.mxid}](https://matrix.to/#/{evt.sender.mxid}).\n\n")
-            return await evt.reply(
-                "This bridge instance allows you to log in inside or outside Matrix.\n\n"
-                "If you would like to log in within Matrix, please send your phone number or bot "
-                "auth token here.\n"
-                "If you would like to log in outside of Matrix, please visit [the login page]"
-                f"({url}).\n\n"
-                "Logging in outside of Matrix is recommended if you have two-factor authentication "
-                "enabled, because in-Matrix login would save your password in the message history."
-                f"\n\n{nb}")
         if override_sender:
-            return await evt.reply(
-                "This bridge instance does not allow logging in inside Matrix, and logging in as "
-                "another user inside Matrix isn't possible anyway.\n\n"
-                f"Please visit [the login page]({url}) to log in as "
-                f"[{evt.sender.mxid}](https://matrix.to/#/{evt.sender.mxid}).")
-        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.\n\n"
-            f"{nb}")
+            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}).\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(
-            "This bridge instance does not allow you to log in outside of Matrix.\n\n"
-            "Please send your phone number or bot auth token here to start the login process.\n\n"
-            f"{nb}")
+        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]
-                        ) -> Dict:
+                        ) -> EventID:
     ok = False
     try:
         await evt.sender.ensure_started(even_if_no_session=True)
@@ -173,21 +223,20 @@ async def _request_code(evt: CommandEvent, phone_number: str, next_status: Dict[
         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.")
+        return await evt.reply("Your phone number has been temporarily blocked for flooding. "
+                               "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 {format_duration(e.seconds)} before trying again.")
+        return await evt.reply("Your phone number has been temporarily blocked for flooding. "
+                               f"Please wait for {fmt_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 register with `$cmdprefix+sp register <phone>`.")
+        return await evt.reply("That phone number has not been registered. "
+                               "Please register with `$cmdprefix+sp register <phone>`.")
+    except PhoneNumberInvalidError:
+        return await evt.reply("That phone number is not valid.")
     except Exception:
         evt.log.exception("Error requesting phone code")
         return await evt.reply("Unhandled exception while requesting code. "
@@ -197,7 +246,7 @@ async def _request_code(evt: CommandEvent, phone_number: str, next_status: Dict[
 
 
 @command_handler(needs_auth=False)
-async def enter_phone_or_token(evt: CommandEvent) -> Optional[Dict]:
+async def enter_phone_or_token(evt: CommandEvent) -> Optional[EventID]:
     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):
@@ -221,7 +270,7 @@ async def enter_phone_or_token(evt: CommandEvent) -> Optional[Dict]:
 
 
 @command_handler(needs_auth=False)
-async def enter_code(evt: CommandEvent) -> Optional[Dict]:
+async def enter_code(evt: CommandEvent) -> Optional[EventID]:
     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):
@@ -237,14 +286,15 @@ async def enter_code(evt: CommandEvent) -> Optional[Dict]:
 
 
 @command_handler(needs_auth=False)
-async def enter_password(evt: CommandEvent) -> Optional[Dict]:
+async def enter_password(evt: CommandEvent) -> Optional[EventID]:
     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")
     try:
-        await _sign_in(evt, password=" ".join(evt.args))
+        await _sign_in(evt, login_as=evt.sender.command_status.get("login_as", None),
+                       password=" ".join(evt.args))
     except AccessTokenInvalidError:
         return await evt.reply("That bot token is not valid.")
     except AccessTokenExpiredError:
@@ -256,20 +306,12 @@ async def enter_password(evt: CommandEvent) -> Optional[Dict]:
     return None
 
 
-async def _sign_in(evt: CommandEvent, **sign_in_info) -> Dict:
+async def _sign_in(evt: CommandEvent, login_as: 'u.User' = None, **sign_in_info) -> EventID:
+    login_as = login_as or evt.sender
     try:
-        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}")
+        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)
     except PhoneCodeExpiredError:
         return await evt.reply("Phone code expired. Try again with `$cmdprefix+sp login`.")
     except PhoneCodeInvalidError:
@@ -285,10 +327,29 @@ async def _sign_in(evt: CommandEvent, **sign_in_info) -> Dict:
                                "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 = 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}]"
+                        f"(https://matrix.to/#/{existing_user.mxid})"
+                        " was logged out from the account.")
+    asyncio.ensure_future(login_as.post_login(user, first_login=True), loop=evt.loop)
+    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=True,
                  help_section=SECTION_AUTH,
                  help_text="Log out from Telegram.")
-async def logout(evt: CommandEvent) -> Optional[Dict]:
+async def logout(evt: CommandEvent) -> EventID:
     if await evt.sender.log_out():
         return await evt.reply("Logged out successfully.")
     return await evt.reply("Failed to log out.")

mautrix_telegram/commands/telegram/misc.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 Tulir Asokan
+# Copyright (C) 2020 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
@@ -14,29 +13,54 @@
 #
 # 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 typing import List, Optional, Tuple, cast
 import codecs
 import base64
 import re
 
-from telethon.errors import (InviteHashInvalidError, InviteHashExpiredError,
-                             UserAlreadyParticipantError)
-from telethon.tl.types import User as TLUser, TypeUpdates, MessageMediaGame
+from aiohttp import ClientSession, InvalidURL
+
+from telethon.errors import (InviteHashInvalidError, InviteHashExpiredError, OptionsTooMuchError,
+                             UserAlreadyParticipantError, ChatIdInvalidError,
+                             TakeoutInitDelayError, EmoticonInvalidError)
+from telethon.tl.patched import Message
+from telethon.tl.types import (User as TLUser, TypeUpdates, MessageMediaGame, MessageMediaPoll,
+                               TypeInputPeer, InputMediaDice)
 from telethon.tl.types.messages import BotCallbackAnswer
 from telethon.tl.functions.messages import (ImportChatInviteRequest, CheckChatInviteRequest,
-                                            GetBotCallbackAnswerRequest)
+                                            GetBotCallbackAnswerRequest, SendVoteRequest)
 from telethon.tl.functions.channels import JoinChannelRequest
 
-from mautrix_telegram import puppet as pu, portal as po
-from mautrix_telegram.db import Message as DBMessage
-from mautrix_telegram.types import TelegramID
-from mautrix_telegram.commands import command_handler, CommandEvent, SECTION_MISC, SECTION_CREATING_PORTALS
+from mautrix.types import EventID, Format
+
+from ... import puppet as pu, portal as po
+from ...abstract_user import AbstractUser
+from ...db import Message as DBMessage
+from ...types import TelegramID
+from ...commands import (command_handler, CommandEvent, SECTION_MISC, SECTION_CREATING_PORTALS,
+                         SECTION_PORTAL_MANAGEMENT)
+
+
+@command_handler(needs_auth=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) -> Optional[Dict]:
+async def search(evt: CommandEvent) -> EventID:
     if len(evt.args) == 0:
         return await evt.reply("**Usage:** `$cmdprefix+sp search [-r|--remote] <query>`")
 
@@ -57,7 +81,7 @@ async def search(evt: CommandEvent) -> Optional[Dict]:
                                    "Minimum length of remote query is 5 characters.")
         return await evt.reply("No results 3:")
 
-    reply = []  # type: List[str]
+    reply: List[str] = []
     if remote:
         reply += ["**Results from Telegram server:**", ""]
     else:
@@ -71,18 +95,18 @@ async def search(evt: CommandEvent) -> Optional[Dict]:
     return await evt.reply("\n".join(reply))
 
 
-@command_handler(help_section=SECTION_CREATING_PORTALS,
-                 help_args="<_identifier_>",
+@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]:
+async def pm(evt: CommandEvent) -> EventID:
     if len(evt.args) == 0:
         return await evt.reply("**Usage:** `$cmdprefix+sp pm <user identifier>`")
 
     try:
-        user = await evt.sender.client.get_entity(evt.args[0])
+        id = "".join(evt.args).translate({ord(c): None for c in "+()- "})
+        user = await evt.sender.client.get_entity(id)
     except ValueError:
         return await evt.reply("Invalid user identifier or user not found.")
 
@@ -92,25 +116,25 @@ async def pm(evt: CommandEvent) -> Optional[Dict]:
         return await evt.reply("That doesn't seem to be a user.")
     portal = po.Portal.get_by_entity(user, evt.sender.tgid)
     await portal.create_matrix_room(evt.sender, user, [evt.sender.mxid])
-    return await evt.reply("Created private chat room with "
-                           f"{pu.Puppet.get_displayname(user, False)}")
+    displayname, _ = pu.Puppet.get_displayname(user, False)
+    return await evt.reply(f"Created private chat room with {displayname}")
 
 
-async def _join(evt: CommandEvent, arg: str) -> Tuple[Optional[TypeUpdates], Optional[Dict]]:
-    if arg.startswith("joinchat/"):
-        invite_hash = arg[len("joinchat/"):]
+async def _join(evt: CommandEvent, identifier: str, link_type: str
+                ) -> Tuple[Optional[TypeUpdates], Optional[EventID]]:
+    if link_type == "joinchat":
         try:
-            await evt.sender.client(CheckChatInviteRequest(invite_hash))
+            await evt.sender.client(CheckChatInviteRequest(identifier))
         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(invite_hash))), None
+            return (await evt.sender.client(ImportChatInviteRequest(identifier))), None
         except UserAlreadyParticipantError:
             return None, await evt.reply("You are already in that chat.")
     else:
-        channel = await evt.sender.client.get_entity(arg)
+        channel = await evt.sender.client.get_entity(identifier)
         if not channel:
             return None, await evt.reply("Channel/supergroup not found.")
         return await evt.sender.client(JoinChannelRequest(channel)), None
@@ -119,16 +143,30 @@ async def _join(evt: CommandEvent, arg: str) -> Tuple[Optional[TypeUpdates], Opt
 @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]:
+async def join(evt: CommandEvent) -> Optional[EventID]:
     if len(evt.args) == 0:
         return await evt.reply("**Usage:** `$cmdprefix+sp join <invite link>`")
 
-    regex = re.compile(r"(?:https?://)?t(?:elegram)?\.(?:dog|me)(?:joinchat/)?/(.+)")
-    arg = regex.match(evt.args[0])
+    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)"
+                       r"(?:/(?P<type>joinchat|s))?/(?P<id>[^/]+)/?", flags=re.IGNORECASE)
+    arg = regex.match(url)
     if not arg:
         return await evt.reply("That doesn't look like a Telegram invite link.")
 
-    updates, _ = await _join(evt, arg.group(1))
+    data = arg.groupdict()
+    identifier = data["id"]
+    link_type = data["type"]
+    if link_type:
+        link_type = link_type.lower()
+    updates, _ = await _join(evt, identifier, link_type)
     if not updates:
         return None
 
@@ -139,7 +177,12 @@ async def join(evt: CommandEvent) -> Optional[Dict]:
             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.")
-            await portal.create_matrix_room(evt.sender, chat, [evt.sender.mxid])
+            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
             return await evt.reply(f"Created room for {portal.title}")
     return None
 
@@ -147,7 +190,7 @@ async def join(evt: CommandEvent) -> Optional[Dict]:
 @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]:
+async def sync(evt: CommandEvent) -> EventID:
     if len(evt.args) > 0:
         sync_only = evt.args[0]
         if sync_only not in ("chats", "contacts", "me"):
@@ -156,8 +199,10 @@ async def sync(evt: CommandEvent) -> Optional[Dict]:
         sync_only = None
 
     if not sync_only or sync_only == "chats":
-        await evt.sender.sync_dialogs(synchronous_create=True)
+        await evt.reply("Synchronizing chats...")
+        await evt.sender.sync_dialogs()
     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()
@@ -167,10 +212,49 @@ async def sync(evt: CommandEvent) -> Optional[Dict]:
 PEER_TYPE_CHAT = b"g"
 
 
+class MessageIDError(ValueError):
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+        self.message = message
+
+
+async def _parse_encoded_msgid(user: AbstractUser, enc_id: str, type_name: str
+                               ) -> Tuple[TypeInputPeer, Message]:
+    try:
+        enc_id += (4 - len(enc_id) % 4) * "="
+        enc_id = base64.b64decode(enc_id)
+        peer_type, enc_id = bytes([enc_id[0]]), enc_id[1:]
+        tgid = TelegramID(int(codecs.encode(enc_id[0:5], "hex_codec"), 16))
+        msg_id = TelegramID(int(codecs.encode(enc_id[5:10], "hex_codec"), 16))
+        space = None
+        if peer_type == PEER_TYPE_CHAT:
+            space = TelegramID(int(codecs.encode(enc_id[10:15], "hex_codec"), 16))
+    except ValueError as e:
+        raise MessageIDError(f"Invalid {type_name} ID (format)") from e
+
+    if peer_type == PEER_TYPE_CHAT:
+        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 = 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
+    try:
+        peer = await user.client.get_input_entity(tgid)
+    except ValueError as e:
+        raise MessageIDError(f"Invalid {type_name} ID (chat not found)") from e
+
+    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)
+
+
 @command_handler(help_section=SECTION_MISC,
                  help_args="<_play ID_>",
                  help_text="Play a Telegram game.")
-async def play(evt: CommandEvent) -> Optional[Dict]:
+async def play(evt: CommandEvent) -> EventID:
     if len(evt.args) < 1:
         return await evt.reply("**Usage:** `$cmdprefix+sp play <play ID>`")
     elif not await evt.sender.is_logged_in():
@@ -179,38 +263,113 @@ async def play(evt: CommandEvent) -> Optional[Dict]:
         return await evt.reply("Bots can't play games :(")
 
     try:
-        play_id = evt.args[0]
-        play_id += (4 - len(play_id) % 4) * "="
-        play_id = base64.b64decode(play_id)
-        peer_type, play_id = bytes([play_id[0]]), play_id[1:]
-        tgid = TelegramID(int(codecs.encode(play_id[0:5], "hex_codec"), 16))
-        msg_id = TelegramID(int(codecs.encode(play_id[5:10], "hex_codec"), 16))
-        space = None
-        if peer_type == PEER_TYPE_CHAT:
-            space = TelegramID(int(codecs.encode(play_id[10:15], "hex_codec"), 16))
-    except ValueError:
-        return await evt.reply("Invalid play ID (format)")
+        peer, msg = await _parse_encoded_msgid(evt.sender, evt.args[0], type_name="play")
+    except MessageIDError as e:
+        return await evt.reply(e.message)
 
-    if peer_type == PEER_TYPE_CHAT:
-        orig_msg = DBMessage.get_by_tgid(msg_id, space)
-        if not orig_msg:
-            return await evt.reply("Invalid play ID (original message not found in db)")
-        new_msg = DBMessage.get_by_mxid(orig_msg.mxid, orig_msg.mx_room, evt.sender.tgid)
-        if not new_msg:
-            return await evt.reply("Invalid play ID (your copy of message not found in db)")
-        msg_id = new_msg.tgid
-    try:
-        peer = await evt.sender.client.get_input_entity(tgid)
-    except ValueError:
-        return await evt.reply("Invalid play ID (chat not found)")
-
-    msg = await evt.sender.client.get_messages(entity=peer, ids=msg_id)
-    if not msg or not isinstance(msg.media, MessageMediaGame):
+    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")
 
-    await evt.reply(f"Click [here]({game.url}) to play {msg.media.game.title}:\n\n"
-                    f"{msg.media.game.description}")
+    return 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:
+    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():
+        return await evt.reply("You must be logged in with a real account to vote in polls.")
+    elif evt.sender.is_bot:
+        return await evt.reply("Bots can't vote in polls :(")
+
+    try:
+        peer, msg = await _parse_encoded_msgid(evt.sender, evt.args[0], type_name="poll")
+    except MessageIDError as e:
+        return await evt.reply(e.message)
+
+    if not isinstance(msg.media, MessageMediaPoll):
+        return await evt.reply("Invalid poll ID (message doesn't look like a poll)")
+
+    options = []
+    for option in evt.args[1:]:
+        try:
+            if len(option) > 10:
+                raise ValueError("option index too long")
+            option_index = int(option) - 1
+        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)
+        elif option_index < 0:
+            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.")
+        options.append(msg.media.poll.answers[option_index].option)
+    options = [msg.media.poll.answers[int(option) - 1].option
+               for option in evt.args[1:]]
+    try:
+        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 = 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
+    try:
+        limit = int(evt.args[0])
+    except (ValueError, IndexError):
+        limit = -1
+    portal = 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
+    try:
+        await portal.backfill(evt.sender, limit=limit)
+    except TakeoutInitDelayError:
+        msg = ("Please accept the data export request from a mobile device, "
+               "then re-run the backfill command.")
+        if portal.peer_type == "user":
+            from mautrix.appservice import IntentAPI
+            await portal.main_intent.send_notice(evt.room_id, msg)
+        else:
+            await evt.reply(msg)

mautrix_telegram/config.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 Tulir Asokan
+# Copyright (C) 2020 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
@@ -14,157 +13,52 @@
 #
 # 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, Dict, Optional, Tuple
-from ruamel.yaml import YAML
+from typing import Any, List, NamedTuple
 from ruamel.yaml.comments import CommentedMap
-import random
-import string
+import os
 
-yaml = YAML()  # type: YAML
-yaml.indent(4)
+from mautrix.types import UserID
+from mautrix.client import Client
+from mautrix.bridge.config import BaseBridgeConfig
+from mautrix.util.config import ForbiddenKey, ForbiddenDefault, ConfigUpdateHelper
+
+Permissions = NamedTuple("Permissions", relaybot=bool, user=bool, puppeting=bool,
+                         matrix_puppeting=bool, admin=bool, level=str)
 
 
-class DictWithRecursion:
-    def __init__(self, data: Optional[CommentedMap] = None) -> None:
-        self._data = data or CommentedMap()  # type: CommentedMap
-
-    @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)
-
+class Config(BaseBridgeConfig):
     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]
+            return os.environ[f"MAUTRIX_TELEGRAM_{key.replace('.', '_').upper()}"]
         except KeyError:
-            pass
+            return super().__getitem__(key)
 
-    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
+    @property
+    def forbidden_defaults(self) -> List[ForbiddenDefault]:
+        return [
+            *super().forbidden_defaults,
+            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"),
+        ]
 
-    def __delitem__(self, key: str) -> None:
-        self.delete(key)
+    def do_update(self, helper: ConfigUpdateHelper) -> None:
+        super().do_update(helper)
+        copy, copy_dict, base = helper
 
-
-class Config(DictWithRecursion):
-    def __init__(self, path: str, registration_path: str, base_path: str) -> 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]
-
-    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")
+        copy("homeserver.asmux")
 
         if "appservice.protocol" in self and "appservice.address" not in self:
             protocol, hostname, port = (self["appservice.protocol"], self["appservice.hostname"],
                                         self["appservice.port"])
             base["appservice.address"] = f"{protocol}://{hostname}:{port}"
-        else:
-            copy("appservice.address")
-        copy("appservice.hostname")
-        copy("appservice.port")
-        copy("appservice.max_body_size")
-
-        copy("appservice.database")
+        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
 
         copy("appservice.public.enabled")
         copy("appservice.public.prefix")
@@ -176,36 +70,77 @@ class Config(DictWithRecursion):
         if base["appservice.provisioning.shared_secret"] == "generate":
             base["appservice.provisioning.shared_secret"] = self._new_token()
 
-        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")
+
+        copy("manhole.enabled")
+        copy("manhole.path")
+        copy("manhole.whitelist")
 
         copy("bridge.username_template")
         copy("bridge.alias_template")
         copy("bridge.displayname_template")
 
         copy("bridge.displayname_preference")
+        copy("bridge.displayname_max_length")
+        copy("bridge.allow_avatar_remove")
 
         copy("bridge.max_initial_member_sync")
         copy("bridge.sync_channel_members")
         copy("bridge.skip_deleted_members")
         copy("bridge.startup_sync")
-        copy("bridge.sync_dialog_limit")
+        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_direct_chats")
         copy("bridge.max_telegram_delete")
         copy("bridge.sync_matrix_state")
         copy("bridge.allow_matrix_login")
         copy("bridge.plaintext_highlights")
-        copy("bridge.edits_as_replies")
-        copy("bridge.highlight_edits")
         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")
+        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.inline_images")
+        copy("bridge.image_as_file_size")
+        copy("bridge.max_document_size")
+        copy("bridge.parallel_file_transfer")
+        copy("bridge.federate_rooms")
+        copy("bridge.animated_sticker.target")
+        copy("bridge.animated_sticker.args")
+        copy("bridge.encryption.allow")
+        copy("bridge.encryption.default")
+        copy("bridge.encryption.database")
+        copy("bridge.encryption.key_sharing.allow")
+        copy("bridge.encryption.key_sharing.require_cross_signing")
+        copy("bridge.encryption.key_sharing.require_verification")
+        copy("bridge.private_chat_portal_meta")
+        copy("bridge.delivery_receipts")
+        copy("bridge.delivery_error_reports")
+        copy("bridge.resend_bridge_info")
+        copy("bridge.backfill.invite_own_puppet")
+        copy("bridge.backfill.takeout_limit")
+        copy("bridge.backfill.initial_limit")
+        copy("bridge.backfill.missed_limit")
+        copy("bridge.backfill.disable_notifications")
+        copy("bridge.backfill.normal_groups")
+
+        copy("bridge.initial_power_level_overrides.group")
+        copy("bridge.initial_power_level_overrides.user")
 
         copy("bridge.bot_messages_as_notices")
         if isinstance(self["bridge.bridge_notices"], bool):
@@ -222,6 +157,7 @@ class Config(DictWithRecursion):
         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.state_event_formats.join")
         copy("bridge.state_event_formats.leave")
@@ -248,6 +184,11 @@ class Config(DictWithRecursion):
         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")
@@ -256,10 +197,24 @@ class Config(DictWithRecursion):
         copy("telegram.api_id")
         copy("telegram.api_hash")
         copy("telegram.bot_token")
+
+        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.device_info.device_model")
+        copy("telegram.device_info.system_version")
+        copy("telegram.device_info.app_version")
+        copy("telegram.device_info.lang_code")
+        copy("telegram.device_info.system_lang_code")
+
         copy("telegram.server.enabled")
         copy("telegram.server.dc")
         copy("telegram.server.ip")
         copy("telegram.server.port")
+
         copy("telegram.proxy.type")
         copy("telegram.proxy.address")
         copy("telegram.proxy.port")
@@ -267,63 +222,22 @@ class Config(DictWithRecursion):
         copy("telegram.proxy.username")
         copy("telegram.proxy.password")
 
-        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]:
+    def _get_permissions(self, key: str) -> Permissions:
         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 relaybot, user, puppeting, matrix_puppeting, admin, level
+        return Permissions(relaybot, user, puppeting, matrix_puppeting, admin, level)
 
-    def get_permissions(self, mxid: str) -> Tuple[bool, bool, bool, bool, bool, bool]:
-        permissions = self["bridge.permissions"] or {}
+    def get_permissions(self, mxid: UserID) -> Permissions:
+        permissions = self["bridge.permissions"]
         if mxid in permissions:
             return self._get_permissions(mxid)
 
-        homeserver = mxid[mxid.index(":") + 1:]
+        _, homeserver = Client.parse_user_id(mxid)
         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
-        }

mautrix_telegram/context.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -15,36 +14,44 @@
 # 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
+import asyncio
+
+from alchemysession import AlchemySessionContainer
+
+from mautrix.appservice import AppService
 
 if TYPE_CHECKING:
-    import asyncio
-
-    from sqlalchemy.orm import scoped_session
-
-    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
+    from .__main__ import TelegramBridge
 
 
 class Context:
-    def __init__(self, az: 'AppService', db: 'scoped_session', config: 'Config',
-                 loop: 'asyncio.AbstractEventLoop', session_container: 'AlchemySessionContainer'
-                 ) -> None:
-        self.az = az  # type: AppService
-        self.db = db  # type: scoped_session
-        self.config = config  # type: Config
-        self.loop = loop  # type: asyncio.AbstractEventLoop
-        self.bot = None  # type: Optional[Bot]
-        self.mx = None  # type: MatrixHandler
-        self.session_container = session_container  # type: AlchemySessionContainer
-        self.public_website = None  # type: PublicBridgeWebsite
-        self.provisioning_api = None  # type: ProvisioningAPI
+    az: AppService
+    config: 'Config'
+    loop: asyncio.AbstractEventLoop
+    bridge: 'TelegramBridge'
+    bot: Optional['Bot']
+    mx: Optional['MatrixHandler']
+    session_container: AlchemySessionContainer
+    public_website: Optional['PublicBridgeWebsite']
+    provisioning_api: Optional['ProvisioningAPI']
+
+    def __init__(self, az: AppService, config: 'Config', loop: asyncio.AbstractEventLoop,
+                 session_container: AlchemySessionContainer, bridge: 'TelegramBridge',
+                 bot: Optional['Bot']) -> None:
+        self.az = az
+        self.config = config
+        self.loop = loop
+        self.bridge = bridge
+        self.bot = bot
+        self.mx = None
+        self.session_container = session_container
+        self.public_website = None
+        self.provisioning_api = None
 
     @property
-    def core(self) -> Tuple['AppService', 'scoped_session', 'Config',
-                            'asyncio.AbstractEventLoop', Optional['Bot']]:
-        return (self.az, self.db, self.config, self.loop, self.bot)
+    def core(self) -> Tuple[AppService, 'Config', asyncio.AbstractEventLoop, Optional['Bot']]:
+        return self.az, self.config, self.loop, self.bot

mautrix_telegram/db/__init__.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,20 +13,19 @@
 #
 # 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 .base import Base
+from sqlalchemy.engine.base import Engine
+
+from mautrix.client.state_store.sqlalchemy import UserProfile, RoomState
+
 from .bot_chat import BotChat
 from .message import Message
 from .portal import Portal
 from .puppet import Puppet
-from .room_state import RoomState
 from .telegram_file import TelegramFile
 from .user import User, UserPortal, Contact
-from .user_profile import UserProfile
 
 
-def init(db_engine) -> None:
+def init(db_engine: 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
+        table.bind(db_engine)

mautrix_telegram/db/base.py

@@ -1,41 +0,0 @@
-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:
-        self.db.execute(self.t.update()
-                        .where(self._edit_identity)
-                        .values(**values))
-        for key, value in values.items():
-            setattr(self, key, value)
-
-    def delete(self) -> None:
-        self.db.execute(self.t.delete().where(self._edit_identity))
-
-
-Base = declarative_base(cls=BaseBase)

mautrix_telegram/db/base.pyi

@@ -1,26 +0,0 @@
-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: ...

mautrix_telegram/db/bot_chat.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -16,28 +15,24 @@
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 from typing import Iterable
 
-from sqlalchemy import Column, Integer, String
+from sqlalchemy import Column, BigInteger, String
+
+from mautrix.util.db import Base
 
 from ..types import TelegramID
-from .base import Base
 
 
 # Fucking Telegram not telling bots what chats they are in 3:<
 class BotChat(Base):
     __tablename__ = "bot_chat"
-    id = Column(Integer, primary_key=True)  # type: TelegramID
-    type = Column(String, nullable=False)
+    id: TelegramID = Column(BigInteger, primary_key=True)
+    type: str = Column(String, nullable=False)
 
     @classmethod
-    def delete(cls, id: TelegramID) -> None:
-        cls.db.execute(cls.t.delete().where(cls.c.id == id))
+    def delete_by_id(cls, chat_id: TelegramID) -> None:
+        with cls.db.begin() as conn:
+            conn.execute(cls.t.delete().where(cls.c.id == chat_id))
 
     @classmethod
     def all(cls) -> Iterable['BotChat']:
-        rows = cls.db.execute(cls.t.select())
-        for row in rows:
-            id, type = row
-            yield cls(id=id, type=type)
-
-    def insert(self) -> None:
-        self.db.execute(self.t.insert().values(id=self.id, type=self.type))
+        return cls._select_all()

mautrix_telegram/db/message.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,43 +13,54 @@
 #
 # 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, UniqueConstraint, Integer, String, and_, func, select
-from sqlalchemy.engine.result import RowProxy
-from typing import Optional, List
+from typing import Optional, Iterator, List
 
-from ..types import MatrixRoomID, MatrixEventID, TelegramID
-from .base import Base
+from sqlalchemy import (Column, UniqueConstraint, BigInteger, Integer, String, Boolean, and_, func,
+                        desc, select, false)
+
+from mautrix.types import RoomID, EventID
+from mautrix.util.db import Base
+
+from ..types import TelegramID
 
 
 class Message(Base):
     __tablename__ = "message"
 
-    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
+    mxid: EventID = Column(String)
+    mx_room: RoomID = Column(String)
+    tgid: TelegramID = Column(BigInteger, primary_key=True)
+    tg_space: TelegramID = Column(BigInteger, primary_key=True)
+    edit_index: int = Column(Integer, primary_key=True)
+    redacted: bool = Column(Boolean, server_default=false())
 
-    __table_args__ = (UniqueConstraint("mxid", "mx_room", "tg_space", name="_mx_id_room"),)
+    __table_args__ = (UniqueConstraint("mxid", "mx_room", "tg_space", name="_mx_id_room_2"),)
 
     @classmethod
-    def _one_or_none(cls, rows: RowProxy) -> Optional['Message']:
-        try:
-            mxid, mx_room, tgid, tg_space = next(rows)
-            return cls(mxid=mxid, mx_room=mx_room, tgid=tgid, tg_space=tg_space)
-        except StopIteration:
-            return None
-
-    @staticmethod
-    def _all(rows: RowProxy) -> List['Message']:
-        return [Message(mxid=row[0], mx_room=row[1], tgid=row[2], tg_space=row[3])
-                for row in rows]
+    def get_all_by_tgid(cls, tgid: TelegramID, tg_space: TelegramID) -> Iterator['Message']:
+        return cls._select_all(cls.c.tgid == tgid, cls.c.tg_space == tg_space)
 
     @classmethod
-    def get_by_tgid(cls, tgid: TelegramID, tg_space: TelegramID) -> Optional['Message']:
-        return cls._select_one_or_none(and_(cls.c.tgid == tgid, cls.c.tg_space == tg_space))
+    def get_one_by_tgid(cls, tgid: TelegramID, tg_space: TelegramID, edit_index: int = 0
+                        ) -> Optional['Message']:
+        if edit_index < 0:
+            return cls._one_or_none(cls.db.execute(
+                cls.t.select()
+                    .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:
+            return cls._select_one_or_none(cls.c.tgid == tgid, cls.c.tg_space == tg_space,
+                                           cls.c.edit_index == edit_index)
 
     @classmethod
-    def count_spaces_by_mxid(cls, mxid: MatrixEventID, mx_room: MatrixRoomID) -> int:
+    def get_first_by_tgids(cls, tgids: List[TelegramID], tg_space: TelegramID
+                           ) -> Iterator['Message']:
+        return cls._select_all(cls.c.tgid.in_(tgids), cls.c.tg_space == tg_space,
+                               cls.c.edit_index == 0)
+
+    @classmethod
+    def count_spaces_by_mxid(cls, mxid: EventID, mx_room: RoomID) -> 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:
@@ -60,28 +70,39 @@ class Message(Base):
             return 0
 
     @classmethod
-    def get_by_mxid(cls, mxid: MatrixEventID, mx_room: MatrixRoomID, tg_space: TelegramID
+    def find_last(cls, mx_room: RoomID, tg_space: TelegramID) -> Optional['Message']:
+        return cls._one_or_none(cls.db.execute(
+            cls._make_simple_select(cls.c.mx_room == mx_room, cls.c.tg_space == tg_space)
+                .order_by(desc(cls.c.tgid)).limit(1)))
+
+    @classmethod
+    def delete_all(cls, mx_room: RoomID) -> None:
+        cls.db.execute(cls.t.delete().where(cls.c.mx_room == mx_room))
+
+    @classmethod
+    def get_by_mxid(cls, mxid: EventID, mx_room: RoomID, 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))
+        return cls._select_one_or_none(cls.c.mxid == mxid, cls.c.mx_room == mx_room,
+                                       cls.c.tg_space == tg_space)
 
     @classmethod
-    def update_by_tgid(cls, s_tgid: TelegramID, s_tg_space: TelegramID, **values) -> None:
-        cls.db.execute(cls.t.update()
-                       .where(and_(cls.c.tgid == s_tgid, cls.c.tg_space == s_tg_space))
-                       .values(**values))
+    def get_by_mxids(cls, mxids: List[EventID], mx_room: RoomID, tg_space: TelegramID
+                     ) -> Iterator['Message']:
+        return cls._select_all(cls.c.mxid.in_(mxids), cls.c.mx_room == mx_room,
+                               cls.c.tg_space == tg_space)
 
     @classmethod
-    def update_by_mxid(cls, s_mxid: MatrixEventID, s_mx_room: MatrixRoomID, **values) -> None:
-        cls.db.execute(cls.t.update()
-                       .where(and_(cls.c.mxid == s_mxid, cls.c.mx_room == s_mx_room))
-                       .values(**values))
+    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))
 
-    @property
-    def _edit_identity(self):
-        return and_(self.c.tgid == self.tgid, self.c.tg_space == self.tg_space)
-
-    def insert(self) -> None:
-        self.db.execute(self.t.insert().values(mxid=self.mxid, mx_room=self.mx_room, tgid=self.tgid,
-                                               tg_space=self.tg_space))
+    @classmethod
+    def update_by_mxid(cls, s_mxid: EventID, s_mx_room: RoomID, **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))

mautrix_telegram/db/portal.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,67 +13,54 @@
 #
 # 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, Integer, String, Boolean, Text, and_
-from sqlalchemy.engine.result import RowProxy
-from typing import Optional
+from typing import Optional, Iterable
 
-from ..types import MatrixRoomID, TelegramID
-from .base import Base
+from sqlalchemy import Column, BigInteger, String, Boolean, Text, func, sql
+
+from mautrix.types import RoomID, ContentURI
+from mautrix.util.db import Base
+
+from ..types import TelegramID
 
 
 class Portal(Base):
     __tablename__ = "portal"
 
     # Telegram chat information
-    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)
+    tgid: TelegramID = Column(BigInteger, primary_key=True)
+    tg_receiver: TelegramID = Column(BigInteger, primary_key=True)
+    peer_type: str = Column(String, nullable=False)
+    megagroup: bool = Column(Boolean)
 
     # Matrix portal information
-    mxid = Column(String, unique=True, nullable=True)  # type: Optional[MatrixRoomID]
+    mxid: Optional[RoomID] = Column(String, unique=True, nullable=True)
+    avatar_url: Optional[ContentURI] = Column(String, nullable=True)
+    encrypted: bool = Column(Boolean, nullable=False, server_default=sql.expression.false())
 
-    config = Column(Text, nullable=True)
+    config: str = Column(Text, nullable=True)
 
     # Telegram chat metadata
-    username = Column(String, nullable=True)
-    title = Column(String, nullable=True)
-    about = Column(String, nullable=True)
-    photo_id = Column(String, nullable=True)
-
-    @classmethod
-    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
+    username: str = Column(String, nullable=True)
+    title: str = Column(String, nullable=True)
+    about: str = Column(String, nullable=True)
+    photo_id: str = Column(String, nullable=True)
 
     @classmethod
     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))
+        return cls._select_one_or_none(cls.c.tgid == tgid, cls.c.tg_receiver == tg_receiver)
 
     @classmethod
-    def get_by_mxid(cls, mxid: MatrixRoomID) -> Optional['Portal']:
+    def find_private_chats(cls, tg_receiver: TelegramID) -> Iterable['Portal']:
+        yield from cls._select_all(cls.c.tg_receiver == tg_receiver, cls.c.peer_type == "user")
+
+    @classmethod
+    def get_by_mxid(cls, mxid: RoomID) -> Optional['Portal']:
         return cls._select_one_or_none(cls.c.mxid == mxid)
 
     @classmethod
     def get_by_username(cls, username: str) -> Optional['Portal']:
-        return cls._select_one_or_none(cls.c.username == username)
+        return cls._select_one_or_none(func.lower(cls.c.username) == username)
 
-    @property
-    def _edit_identity(self):
-        return and_(self.c.tgid == self.tgid, self.c.tg_receiver == self.tg_receiver)
-
-    def insert(self) -> None:
-        self.db.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))
+    @classmethod
+    def all(cls) -> Iterable['Portal']:
+        yield from cls._select_all()

mautrix_telegram/db/puppet.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,73 +13,51 @@
 #
 # 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, Integer, String, Boolean
-from sqlalchemy.engine.result import RowProxy
-from sqlalchemy.sql import expression
 from typing import Optional, Iterable
 
-from ..types import MatrixUserID, MatrixRoomID, TelegramID
-from .base import Base
+from sqlalchemy import Column, Integer, BigInteger, String, Text, Boolean
+from sqlalchemy.sql import expression, func
+
+from mautrix.types import UserID, SyncToken
+from mautrix.util.db import Base
+
+from ..types import TelegramID
 
 
 class Puppet(Base):
     __tablename__ = "puppet"
 
-    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())
-
-    @classmethod
-    def scan(cls, row) -> Optional['Puppet']:
-        (id, custom_mxid, access_token, displayname, displayname_source, username, photo_id,
-         is_bot, matrix_registered) = 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)
-
-    @classmethod
-    def _one_or_none(cls, rows: RowProxy) -> Optional['Puppet']:
-        try:
-            return cls.scan(next(rows))
-        except StopIteration:
-            return None
+    id: TelegramID = Column(BigInteger, primary_key=True)
+    custom_mxid: UserID = Column(String, nullable=True)
+    access_token: str = Column(String, nullable=True)
+    next_batch: SyncToken = Column(String, nullable=True)
+    base_url: str = Column(Text, nullable=True)
+    displayname: str = Column(String, nullable=True)
+    displayname_source: TelegramID = Column(BigInteger, nullable=True)
+    displayname_contact: bool = Column(Boolean, nullable=False, server_default=expression.true())
+    displayname_quality: int = Column(Integer, nullable=False, server_default="0")
+    username: str = Column(String, nullable=True)
+    photo_id: str = Column(String, nullable=True)
+    is_bot: bool = Column(Boolean, nullable=True)
+    matrix_registered: bool = Column(Boolean, nullable=False, server_default=expression.false())
+    disable_updates: bool = Column(Boolean, nullable=False, server_default=expression.false())
 
     @classmethod
     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)
+        yield from cls._select_all(cls.c.custom_mxid != None)
 
     @classmethod
     def get_by_tgid(cls, tgid: TelegramID) -> Optional['Puppet']:
         return cls._select_one_or_none(cls.c.id == tgid)
 
     @classmethod
-    def get_by_custom_mxid(cls, mxid: MatrixUserID) -> Optional['Puppet']:
+    def get_by_custom_mxid(cls, mxid: UserID) -> Optional['Puppet']:
         return cls._select_one_or_none(cls.c.custom_mxid == mxid)
 
     @classmethod
     def get_by_username(cls, username: str) -> Optional['Puppet']:
-        return cls._select_one_or_none(cls.c.username == username)
+        return cls._select_one_or_none(func.lower(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 _edit_identity(self):
-        return self.c.id == self.id
-
-    def insert(self) -> None:
-        self.db.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))

mautrix_telegram/db/room_state.py

@@ -1,60 +0,0 @@
-# -*- coding: future_fstrings -*-
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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:
-        self.db.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:
-        self.db.execute(self.t.insert().values(room_id=self.room_id,
-                                               power_levels=self._power_levels_text))

mautrix_telegram/db/telegram_file.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,42 +13,69 @@
 #
 # 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, ForeignKey, Integer, BigInteger, String, Boolean
-from sqlalchemy.orm import relationship
-from typing import Optional
+from typing import Optional, cast, Dict, Any, TYPE_CHECKING
 
-from .base import Base
+from sqlalchemy import (Column, ForeignKey, Integer, BigInteger, String, Boolean, Text,
+                        TypeDecorator)
+
+from mautrix.types import ContentURI, EncryptedFile
+from mautrix.util.db import Base
+
+if TYPE_CHECKING:
+    from sqlalchemy.engine.result import RowProxy
+
+
+class DBEncryptedFile(TypeDecorator):
+    impl = Text
+
+    @property
+    def python_type(self):
+        return EncryptedFile
+
+    def process_bind_param(self, value: EncryptedFile, dialect) -> Optional[str]:
+        if value is not None:
+            return value.json()
+        return None
+
+    def process_result_value(self, value: str, dialect) -> Optional[EncryptedFile]:
+        if value is not None:
+            return EncryptedFile.parse_json(value)
+        return None
+
+    def process_literal_param(self, value, dialect):
+        return value
 
 
 class TelegramFile(Base):
     __tablename__ = "telegram_file"
 
-    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 = relationship("TelegramFile", uselist=False)
+    id: str = Column(String, primary_key=True)
+    mxc: ContentURI = Column(String)
+    mime_type: str = Column(String)
+    was_converted: bool = Column(Boolean)
+    timestamp: int = Column(BigInteger)
+    size: Optional[int] = Column(Integer, nullable=True)
+    width: Optional[int] = Column(Integer, nullable=True)
+    height: Optional[int] = Column(Integer, nullable=True)
+    decryption_info: Optional[Dict[str, Any]] = Column(DBEncryptedFile, nullable=True)
+    thumbnail_id: str = Column("thumbnail", String, ForeignKey("telegram_file.id"), nullable=True)
+    thumbnail: Optional['TelegramFile'] = None
 
     @classmethod
-    def get(cls, id: str) -> Optional['TelegramFile']:
-        rows = cls.db.execute(cls.t.select().where(cls.c.id == id))
-        try:
-            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=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
+    def scan(cls, row: 'RowProxy') -> 'TelegramFile':
+        telegram_file = cast(TelegramFile, super().scan(row))
+        if isinstance(telegram_file.thumbnail, str):
+            telegram_file.thumbnail = cls.get(telegram_file.thumbnail)
+        return telegram_file
+
+    @classmethod
+    def get(cls, loc_id: str) -> Optional['TelegramFile']:
+        return cls._select_one_or_none(cls.c.id == loc_id)
 
     def insert(self) -> None:
-        self.db.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))
+        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, decryption_info=self.decryption_info,
+                thumbnail=self.thumbnail.id if self.thumbnail else self.thumbnail_id))

mautrix_telegram/db/user.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,60 +13,40 @@
 #
 # 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, ForeignKey, ForeignKeyConstraint, Integer, String
-from sqlalchemy.engine.result import RowProxy
 from typing import Optional, Iterable, Tuple
 
-from ..types import MatrixUserID, MatrixRoomID, TelegramID
-from .base import Base
+from sqlalchemy import Column, ForeignKey, ForeignKeyConstraint, BigInteger, Integer, String, func
+
+from mautrix.types import UserID
+from mautrix.util.db import Base
+
+from ..types import TelegramID
 
 
 class User(Base):
     __tablename__ = "user"
 
-    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)
+    mxid: UserID = Column(String, primary_key=True)
+    tgid: Optional[TelegramID] = Column(BigInteger, nullable=True, unique=True)
+    tg_username: str = Column(String, nullable=True)
+    tg_phone: str = Column(String, nullable=True)
+    saved_contacts: int = Column(Integer, default=0, nullable=False)
 
     @classmethod
-    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
-
-    @classmethod
-    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)
+    def all_with_tgid(cls) -> Iterable['User']:
+        return cls._select_all(cls.c.tgid != None)
 
     @classmethod
     def get_by_tgid(cls, tgid: TelegramID) -> Optional['User']:
         return cls._select_one_or_none(cls.c.tgid == tgid)
 
     @classmethod
-    def get_by_mxid(cls, mxid: MatrixUserID) -> Optional['User']:
+    def get_by_mxid(cls, mxid: UserID) -> Optional['User']:
         return cls._select_one_or_none(cls.c.mxid == mxid)
 
     @classmethod
     def get_by_username(cls, username: str) -> Optional['User']:
-        return cls._select_one_or_none(cls.c.tg_username == username)
-
-    @property
-    def _edit_identity(self):
-        return self.c.mxid == self.mxid
-
-    def insert(self) -> None:
-        self.db.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))
+        return cls._select_one_or_none(func.lower(cls.c.tg_username) == username)
 
     @property
     def contacts(self) -> Iterable[TelegramID]:
@@ -78,10 +57,11 @@ class User(Base):
 
     @contacts.setter
     def contacts(self, puppets: Iterable[TelegramID]) -> None:
-        self.db.execute(Contact.t.delete().where(Contact.c.user == self.tgid))
-        if puppets:
-            self.db.execute(Contact.t.insert(), [{"user": self.tgid, "contact": tgid}
-                                                 for tgid in puppets])
+        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)
 
     @property
     def portals(self) -> Iterable[Tuple[TelegramID, TelegramID]]:
@@ -92,28 +72,29 @@ class User(Base):
 
     @portals.setter
     def portals(self, portals: Iterable[Tuple[TelegramID, TelegramID]]) -> None:
-        self.db.execute(UserPortal.t.delete().where(UserPortal.c.user == self.tgid))
-        if portals:
-            self.db.execute(UserPortal.t.insert(),
-                            [{
-                                "user": self.tgid,
-                                "portal": tgid,
-                                "portal_receiver": tg_receiver
-                            } for tgid, tg_receiver in portals])
+        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)
 
     def delete(self) -> None:
         super().delete()
-        self.portals = None
-        self.contacts = None
+        self.portals = []
+        self.contacts = []
 
 
 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
+    user: TelegramID = Column(BigInteger, ForeignKey("user.tgid", onupdate="CASCADE",
+                                                  ondelete="CASCADE"), primary_key=True)
+    portal: TelegramID = Column(BigInteger, primary_key=True)
+    portal_receiver: TelegramID = Column(BigInteger, primary_key=True)
 
     __table_args__ = (ForeignKeyConstraint(("portal", "portal_receiver"),
                                            ("portal.tgid", "portal.tg_receiver"),
@@ -123,6 +104,5 @@ class UserPortal(Base):
 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
-
+    user: TelegramID = Column(BigInteger, ForeignKey("user.tgid"), primary_key=True)
+    contact: TelegramID = Column(BigInteger, ForeignKey("puppet.id"), primary_key=True)

mautrix_telegram/db/user_profile.py

@@ -1,68 +0,0 @@
-# -*- coding: future_fstrings -*-
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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:
-        cls.db.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:
-        self.db.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))
-

mautrix_telegram/example-config.yaml

@@ -0,0 +1,526 @@
+# 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
+    asmux: 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 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
+    # Optional extra arguments for SQLAlchemy's create_engine
+    database_opts: {}
+
+    # 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/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.
+    #
+    # Example: "+telegram:example.com". Set to false to disable.
+    community_id: false
+
+    # 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: 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
+
+# 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
+
+    # 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
+    # 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.
+    # 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: 30
+    # 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 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 use /sync to get presence, read receipts and typing notifications
+    # when double puppeting is enabled
+    sync_with_custom_puppets: true
+    # 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
+    # Use inline images instead of a separate message for the caption.
+    # N.B. Inline images are not supported on all clients (e.g. Element iOS/Android).
+    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
+    # 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
+    # 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, but loses transparency
+        # webm - converts to webm video, requires ffmpeg executable with vp9 codec and webm container support
+        target: gif
+        # Arguments for converter. All converters take width and height.
+        # GIF converter takes background as a hex color.
+        args:
+            width: 256
+            height: 256
+            background: "020202"  # only for gif
+            fps: 30               # only for webm
+    # End-to-bridge encryption support options. These require matrix-nio to be installed with pip
+    # and login_shared_secret to be configured in order to get a device for the bridge bot.
+    #
+    # Additionally, https://github.com/matrix-org/synapse/pull/5758 is required if using a normal
+    # application service.
+    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
+        # Database for the encryption data. Currently only supports Postgres and an in-memory
+        # store that's persisted as a pickle.
+        # If set to `default`, will use the appservice postgres database
+        # or a pickle file if the appservice database is sqlite.
+        #
+        # Format examples:
+        #   Pickle:   pickle:///filename.pickle
+        #   Postgres: postgres://username:password@hostname/dbname
+        database: default
+        # Options for automatic key sharing.
+        key_sharing:
+            # 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: false
+            # Require the requesting device to have a valid cross-signing signature?
+            # This doesn't require that the bridge has verified the device, only that the user has verified it.
+            # Not yet implemented.
+            require_cross_signing: false
+            # Require devices to be verified by the bridge?
+            # Verification by the bridge is not yet implemented.
+            require_verification: true
+    # Whether or not to explicitly set the avatar and room name for private
+    # chat portal rooms. This will be implicitly enabled if encryption.default is true.
+    private_chat_portal_meta: 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
+    # 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
+    # Settings for backfilling messages from Telegram.
+    backfill:
+        # Whether or not the Telegram ghosts of logged in Matrix users should be
+        # invited to private chats when backfilling history from Telegram. This is
+        # usually needed to prevent rate limits and to allow timestamp massaging.
+        invite_own_puppet: true
+        # Maximum number of messages to backfill without using a takeout.
+        # The first time a takeout is used, the user has to manually approve it from a different
+        # device. If initial_limit or missed_limit are higher than this value, the bridge will ask
+        # the user to accept the takeout after logging in before syncing any chats.
+        takeout_limit: 100
+        # Maximum number of messages to backfill initially.
+        # Set to 0 to disable backfilling when creating portal, or -1 to disable the limit.
+        #
+        # N.B. Initial backfill will only start after member sync. Make sure your
+        #      max_initial_member_sync is set to a low enough value so it doesn't take forever.
+        initial_limit: 0
+        # Maximum number of messages to backfill if messages were missed while the bridge was
+        # disconnected. Note that this only works for logged in users and only if the chat isn't
+        # older than sync_update_limit
+        # Set to 0 to disable backfilling missed messages.
+        missed_limit: 50
+        # If using double puppeting, should notifications be disabled
+        # while the initial backfill is in progress?
+        disable_notifications: false
+        # 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
+
+    # 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:
+        - "@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.
+    # 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)
+    #   $message            - The message content
+    message_formats:
+        m.text: "<b>$sender_displayname</b>: $message"
+        m.notice: "<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"
+    # 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: "<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:
+        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
+
+    # 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, 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]

mautrix_telegram/formatter/__init__.py

@@ -1,9 +1,7 @@
-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, init_tg)
+from .from_matrix import matrix_reply_to_telegram, matrix_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)
-    init_tg(context)

mautrix_telegram/formatter/from_matrix/__init__.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,52 +13,49 @@
 #
 # 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, List, Tuple, Callable, Pattern, Match, TYPE_CHECKING, Dict, Any
+from typing import Optional, List, Tuple, Callable, Pattern, Match, TYPE_CHECKING
 import re
 import logging
 
 from telethon.tl.types import (MessageEntityMention, MessageEntityMentionName, MessageEntityItalic,
-                               TypeMessageEntity)
+                               TypeMessageEntity, InputMessageEntityMentionName)
+from telethon.helpers import add_surrogate, del_surrogate
+from telethon import TelegramClient
+
+from mautrix.types import RoomID, MessageEventContent
+from mautrix.util.logging import TraceLogger
 
 from ... import puppet as pu
-from ...types import TelegramID, MatrixRoomID
+from ...types import TelegramID
 from ...db import Message as DBMessage
-from ..util import (add_surrogates, remove_surrogates, trim_reply_fallback_html,
-                    trim_reply_fallback_text)
 from .parser import ParsedMessage, parse_html
 
 if TYPE_CHECKING:
     from ...context import Context
 
-log = logging.getLogger("mau.fmt.mx")  # type: logging.Logger
-should_bridge_plaintext_highlights = False  # type: bool
+log: TraceLogger = logging.getLogger("mau.fmt.mx")
+should_bridge_plaintext_highlights: bool = False
 
-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: Pattern
+command_regex: Pattern = re.compile(r"^!([A-Za-z0-9@]+)")
+not_command_regex: Pattern = re.compile(r"^\\(![A-Za-z0-9@]+)")
+plain_mention_regex: Optional[Pattern] = None
+
+MAX_LENGTH = 4096
+CUTOFF_TEXT = " [message cut]"
+CUT_MAX_LENGTH = MAX_LENGTH - len(CUTOFF_TEXT)
 
 
-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]"
+def _cut_long_message(message: str, entities: List[TypeMessageEntity]) -> ParsedMessage:
+    if len(message) > MAX_LENGTH:
+        message = message[0:CUT_MAX_LENGTH] + CUTOFF_TEXT
         new_entities = []
         for entity in entities:
-            if entity.offset > 4082:
+            if entity.offset > CUT_MAX_LENGTH:
                 continue
-            if entity.offset + entity.length > 4082:
-                entity.length = 4082 - entity.offset
+            if entity.offset + entity.length > CUT_MAX_LENGTH:
+                entity.length = CUT_MAX_LENGTH - entity.offset
             new_entities.append(entity)
-        new_entities.append(MessageEntityItalic(4082, len(" [message cut]")))
+        new_entities.append(MessageEntityItalic(CUT_MAX_LENGTH, len(CUTOFF_TEXT)))
         entities = new_entities
     return message, entities
 
@@ -68,64 +64,77 @@ class FormatError(Exception):
     pass
 
 
-def matrix_to_telegram(html: str) -> ParsedMessage:
+def matrix_reply_to_telegram(content: MessageEventContent, tg_space: TelegramID,
+                             room_id: Optional[RoomID] = None) -> Optional[TelegramID]:
+    event_id = content.get_reply_to()
+    if not event_id:
+        return
+    content.trim_reply_fallback()
+
+    message = 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: Optional[str] = None,
+                             html: Optional[str] = None) -> ParsedMessage:
+    if html is not None:
+        text, entities = _matrix_html_to_telegram(html)
+    elif text is not None:
+        text, entities = _matrix_text_to_telegram(text)
+    else:
+        raise ValueError("text or html must be provided to convert formatting")
+    await _fix_name_mentions(client, entities)
+    return text, entities
+
+
+def _matrix_html_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)
+            html = plain_mention_regex.sub(_plain_mention_to_html, html)
 
-        html = add_surrogates(html)
-        text, entities = parse_html(add_surrogates(html))
-        text = remove_surrogates(text.strip())
-        text, entities = cut_long_message(text, entities)
+        text, entities = parse_html(add_surrogate(html))
+        text = del_surrogate(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 matrix_reply_to_telegram(content: Dict[str, Any], tg_space: TelegramID,
-                             room_id: Optional[MatrixRoomID] = None) -> Optional[TelegramID]:
-    try:
-        reply = content.get("m.relates_to", {}).get("m.in_reply_to", {})
-        if not reply:
-            return None
-        room_id = room_id or reply["room_id"]
-        event_id = reply["event_id"]
-
-        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
-    except KeyError:
-        pass
-    return None
-
-
-def matrix_text_to_telegram(text: str) -> ParsedMessage:
+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)
     if should_bridge_plaintext_highlights:
-        entities, pmr_replacer = plain_mention_to_text()
+        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]]:
+async def _fix_name_mentions(client: TelegramClient, entities: List[TypeMessageEntity]) -> None:
+    for index in reversed(range(len(entities))):
+        entity = entities[index]
+        if isinstance(entity, (MessageEntityMentionName, InputMessageEntityMentionName)):
+            try:
+                user = await client.get_input_entity(entity.user_id)
+            except (ValueError, TypeError) as e:
+                log.trace(f"Dropping mention of {entity.user_id}: {e}")
+                del entities[index]
+            else:
+                entities[index] = InputMessageEntityMentionName(entity.offset, entity.length, user)
+
+
+def _plain_mention_to_text() -> Tuple[List[TypeMessageEntity], Callable[[Match], str]]:
     entities = []
 
-    def replacer(match) -> str:
+    def replacer(match: Match) -> str:
         puppet = pu.Puppet.find_by_displayname(match.group(2))
         if puppet:
             offset = match.start()
@@ -143,10 +152,20 @@ def plain_mention_to_text() -> Tuple[List[TypeMessageEntity], Callable[[str], st
     return entities, replacer
 
 
+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 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 = config["bridge.displayname_template"]
     dn_template = re.escape(dn_template).replace(re.escape("{displayname}"), "[^>]+")
-    plain_mention_regex = re.compile(f"(\s|^)({dn_template})")
-    should_bridge_plaintext_highlights = config["bridge.plaintext_highlights"] or False
+    plain_mention_regex = re.compile(f"^({dn_template})")
+    should_bridge_plaintext_highlights = config["bridge.plaintext_highlights"]

mautrix_telegram/formatter/from_matrix/html_reader.py

@@ -1,4 +0,0 @@
-try:
-    from .html_reader_lxml import HTMLNode, read_html
-except ImportError:
-    from .html_reader_htmlparser import HTMLNode, read_html

mautrix_telegram/formatter/from_matrix/html_reader.pyi

@@ -1,11 +0,0 @@
-from typing import Dict, List
-
-
-class HTMLNode(List['HTMLNode']):
-    tag: str
-    text: str
-    tail: str
-    attrib: Dict[str, str]
-
-
-def read_html(data: str) -> HTMLNode: ...

mautrix_telegram/formatter/from_matrix/html_reader_htmlparser.py

@@ -1,58 +0,0 @@
-# -*- coding: future_fstrings -*-
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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):
-    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)
-        self.stack.append(node)
-
-    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]

mautrix_telegram/formatter/from_matrix/parser.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,236 +13,77 @@
 #
 # 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 List, Tuple, Pattern
-import re
+from typing import List, Tuple, Optional
 
-from telethon.tl.types import (MessageEntityMention as Mention, MessageEntityBotCommand as Command,
-                               MessageEntityMentionName as MentionName, MessageEntityEmail as Email,
-                               MessageEntityUrl as URL, MessageEntityTextUrl as TextURL,
-                               MessageEntityBold as Bold, MessageEntityItalic as Italic,
-                               MessageEntityCode as Code, MessageEntityPre as Pre,
-                               TypeMessageEntity)
+from telethon.tl.types import TypeMessageEntity
+
+from mautrix.types import UserID, RoomID
+from mautrix.util.formatter import MatrixParser as BaseMatrixParser, RecursionContext
+from mautrix.util.formatter.html_reader_htmlparser import read_html, HTMLNode
 
 from ... import user as u, puppet as pu, portal as po
-from ...types import MatrixUserID
-from ..util import html_to_unicode
-from .telegram_message import TelegramMessage, Entity, offset_length_multiply
+from .telegram_message import TelegramMessage, TelegramEntityType
 
-from .html_reader import HTMLNode, read_html
 
 ParsedMessage = Tuple[str, List[TypeMessageEntity]]
 
 
 def parse_html(input_html: str) -> ParsedMessage:
-    return MatrixParser.parse(input_html)
+    msg = MatrixParser.parse(input_html)
+    return msg.text, msg.telegram_entities
 
 
-class RecursionContext:
-    def __init__(self, strip_linebreaks: bool = True, ul_depth: int = 0):
-        self.strip_linebreaks = strip_linebreaks  # type: bool
-        self.ul_depth = ul_depth  # type: int
-        self._inited = True  # type: bool
-
-    def __setattr__(self, key, value):
-        if getattr(self, "_inited", False) is True:
-            raise TypeError("'RecursionContext' object is immutable")
-        super(RecursionContext, self).__setattr__(key, value)
-
-    def enter_list(self) -> 'RecursionContext':
-        return RecursionContext(strip_linebreaks=self.strip_linebreaks, ul_depth=self.ul_depth + 1)
-
-    def enter_code_block(self) -> 'RecursionContext':
-        return RecursionContext(strip_linebreaks=False, ul_depth=self.ul_depth)
-
-
-class MatrixParser:
-    mention_regex = re.compile("https://matrix.to/#/(@.+:.+)")  # type: Pattern
-    room_regex = re.compile("https://matrix.to/#/(#.+:.+)")  # type: Pattern
-    block_tags = ("p", "pre", "blockquote",
-                  "ol", "ul", "li",
-                  "h1", "h2", "h3", "h4", "h5", "h6",
-                  "div", "hr", "table")  # type: Tuple[str, ...]
-    list_bullets = ("●", "○", "■", "‣")  # type: Tuple[str, ...]
+class MatrixParser(BaseMatrixParser[TelegramMessage]):
+    e = TelegramEntityType
+    fs = TelegramMessage
+    read_html = read_html
 
     @classmethod
-    def list_bullet(cls, depth: int) -> str:
-        return cls.list_bullets[(depth - 1) % len(cls.list_bullets)] + " "
+    def custom_node_to_fstring(cls, node: HTMLNode, ctx: RecursionContext
+                               ) -> Optional[TelegramMessage]:
+        msg = cls.tag_aware_parse_node(node, ctx)
+        if node.tag == "command":
+            msg.format(TelegramEntityType.COMMAND)
+        return None
 
     @classmethod
-    def list_to_tmessage(cls, node: HTMLNode, ctx: RecursionContext) -> TelegramMessage:
-        ordered = node.tag == "ol"
-        tagged_children = cls.node_to_tagged_tmessages(node, ctx)
-        counter = 1
-        indent_length = 0
-        if ordered:
-            try:
-                counter = int(node.attrib.get("start", "1"))
-            except ValueError:
-                counter = 1
-
-            longest_index = counter - 1 + len(tagged_children)
-            indent_length = len(str(longest_index))
-        indent = (indent_length + 4) * " "
-        children = []  # type: List[TelegramMessage]
-        for child, tag in tagged_children:
-            if tag != "li":
-                continue
-
-            if ordered:
-                prefix = f"{counter}. "
-                counter += 1
-            else:
-                prefix = cls.list_bullet(ctx.ul_depth)
-            child = child.prepend(prefix)
-            parts = child.split("\n")
-            parts = parts[:1] + [part.prepend(indent) for part in parts[1:]]
-            child = TelegramMessage.join(parts, "\n")
-            children.append(child)
-        return TelegramMessage.join(children, "\n")
+    def user_pill_to_fstring(cls, msg: TelegramMessage, user_id: UserID) -> TelegramMessage:
+        user = (pu.Puppet.deprecated_sync_get_by_mxid(user_id)
+                or u.User.get_by_mxid(user_id, create=False))
+        if not user:
+            return msg
+        if user.username:
+            return TelegramMessage(f"@{user.username}").format(TelegramEntityType.MENTION)
+        elif user.tgid:
+            displayname = user.plain_displayname or msg.text
+            return TelegramMessage(displayname).format(TelegramEntityType.MENTION_NAME,
+                                                       user_id=user.tgid)
+        return msg
 
     @classmethod
-    def blockquote_to_tmessage(cls, node: HTMLNode, ctx: RecursionContext) -> TelegramMessage:
+    def url_to_fstring(cls, msg: TelegramMessage, url: str) -> TelegramMessage:
+        if url == msg.text:
+            return msg.format(cls.e.URL)
+        else:
+            return msg.format(cls.e.INLINE_URL, url=url)
+
+    @classmethod
+    def room_pill_to_fstring(cls, msg: TelegramMessage, room_id: RoomID) -> TelegramMessage:
+        username = po.Portal.get_username_from_mx_alias(room_id)
+        portal = po.Portal.find_by_username(username)
+        if portal and portal.username:
+            return TelegramMessage(f"@{portal.username}").format(TelegramEntityType.MENTION)
+
+    @classmethod
+    def header_to_fstring(cls, node: HTMLNode, ctx: RecursionContext) -> TelegramMessage:
+        children = cls.node_to_fstrings(node, ctx)
+        length = int(node.tag[1])
+        prefix = "#" * length + " "
+        return TelegramMessage.join(children, "").prepend(prefix).format(TelegramEntityType.BOLD)
+
+    @classmethod
+    def blockquote_to_fstring(cls, node: HTMLNode, ctx: RecursionContext) -> TelegramMessage:
         msg = cls.tag_aware_parse_node(node, ctx)
         children = msg.trim().split("\n")
         children = [child.prepend("> ") for child in children]
         return TelegramMessage.join(children, "\n")
-
-    @classmethod
-    def header_to_tmessage(cls, node: HTMLNode, ctx: RecursionContext) -> TelegramMessage:
-        children = cls.node_to_tmessages(node, ctx)
-        length = int(node.tag[1])
-        prefix = "#" * length + " "
-        return TelegramMessage.join(children, "").prepend(prefix).format(Bold)
-
-    @classmethod
-    def basic_format_to_tmessage(cls, node: HTMLNode, ctx: RecursionContext) -> TelegramMessage:
-        msg = cls.tag_aware_parse_node(node, ctx)
-        if node.tag in ("b", "strong"):
-            msg.format(Bold)
-        elif node.tag in ("i", "em"):
-            msg.format(Italic)
-        elif node.tag == "command":
-            msg.format(Command)
-        elif node.tag in ("s", "strike", "del"):
-            msg.text = html_to_unicode(msg.text, "\u0336")
-        elif node.tag in ("u", "ins"):
-            msg.text = html_to_unicode(msg.text, "\u0332")
-
-        if node.tag in ("s", "strike", "del", "u", "ins"):
-            msg.entities = Entity.adjust(msg.entities, offset_length_multiply(2))
-
-        return msg
-
-    @classmethod
-    def link_to_tstring(cls, node: HTMLNode, ctx: RecursionContext) -> TelegramMessage:
-        msg = cls.tag_aware_parse_node(node, ctx)
-        href = node.attrib.get("href", "")
-        if not href:
-            return msg
-
-        if href.startswith("mailto:"):
-            return TelegramMessage(href[len("mailto:"):]).format(Email)
-
-        mention = cls.mention_regex.match(href)
-        if mention:
-            mxid = MatrixUserID(mention.group(1))
-            user = (pu.Puppet.get_by_mxid(mxid)
-                    or u.User.get_by_mxid(mxid, create=False))
-            if not user:
-                return msg
-            if user.username:
-                return TelegramMessage(f"@{user.username}").format(Mention)
-            elif user.tgid:
-                displayname = user.plain_displayname or msg.text
-                return TelegramMessage(displayname).format(MentionName, user_id=user.tgid)
-            return msg
-
-        room = cls.room_regex.match(href)
-        if room:
-            username = po.Portal.get_username_from_mx_alias(room.group(1))
-            portal = po.Portal.find_by_username(username)
-            if portal and portal.username:
-                return TelegramMessage(f"@{portal.username}").format(Mention)
-
-        return (msg.format(URL)
-                if msg.text == href
-                else msg.format(TextURL, url=href))
-
-    @classmethod
-    def node_to_tmessage(cls, node: HTMLNode, ctx: RecursionContext) -> TelegramMessage:
-        if node.tag == "blockquote":
-            return cls.blockquote_to_tmessage(node, ctx)
-        elif node.tag == "ol":
-            return cls.list_to_tmessage(node, ctx)
-        elif node.tag == "ul":
-            return cls.list_to_tmessage(node, ctx.enter_list())
-        elif node.tag in ("h1", "h2", "h3", "h4", "h5", "h6"):
-            return cls.header_to_tmessage(node, ctx)
-        elif node.tag == "br":
-            return TelegramMessage("\n")
-        elif node.tag in ("b", "strong", "i", "em", "s", "del", "u", "ins", "command"):
-            return cls.basic_format_to_tmessage(node, ctx)
-        elif node.tag == "a":
-            return cls.link_to_tstring(node, ctx)
-        elif node.tag == "p":
-            return cls.tag_aware_parse_node(node, ctx).append("\n")
-        elif node.tag == "pre":
-            lang = ""
-            try:
-                if node[0].tag == "code":
-                    node = node[0]
-                    lang = node.attrib["class"][len("language-"):]
-            except (IndexError, KeyError):
-                pass
-            return cls.parse_node(node, ctx.enter_code_block()).format(Pre, language=lang)
-        elif node.tag == "code":
-            return cls.parse_node(node, ctx.enter_code_block()).format(Code)
-        return cls.tag_aware_parse_node(node, ctx)
-
-    @staticmethod
-    def text_to_tmessage(text: str, ctx: RecursionContext) -> TelegramMessage:
-        if ctx.strip_linebreaks:
-            text = text.replace("\n", "")
-        return TelegramMessage(text)
-
-    @classmethod
-    def node_to_tagged_tmessages(cls, node: HTMLNode, ctx: RecursionContext
-                                 ) -> List[Tuple[TelegramMessage, str]]:
-        output = []
-
-        if node.text:
-            output.append((cls.text_to_tmessage(node.text, ctx), "text"))
-        for child in node:
-            output.append((cls.node_to_tmessage(child, ctx), child.tag))
-            if child.tail:
-                output.append((cls.text_to_tmessage(child.tail, ctx), "text"))
-        return output
-
-    @classmethod
-    def node_to_tmessages(cls, node: HTMLNode, ctx: RecursionContext
-                          ) -> List[TelegramMessage]:
-        return [msg for (msg, tag) in cls.node_to_tagged_tmessages(node, ctx)]
-
-    @classmethod
-    def tag_aware_parse_node(cls, node: HTMLNode, ctx: RecursionContext
-                             ) -> TelegramMessage:
-        msgs = cls.node_to_tagged_tmessages(node, ctx)
-        output = TelegramMessage()
-        prev_was_block = False
-        for msg, tag in msgs:
-            if tag in cls.block_tags:
-                msg = msg.append("\n")
-                if not prev_was_block:
-                    msg = msg.prepend("\n")
-                prev_was_block = True
-            output = output.append(msg)
-        return output.trim()
-
-    @classmethod
-    def parse_node(cls, node: HTMLNode, ctx: RecursionContext) -> TelegramMessage:
-        return TelegramMessage.join(cls.node_to_tmessages(node, ctx))
-
-    @classmethod
-    def parse(cls, data: str) -> ParsedMessage:
-        msg = cls.node_to_tmessage(read_html(f"<body>{data}</body>"), RecursionContext())
-        return msg.text, msg.entities

mautrix_telegram/formatter/from_matrix/telegram_message.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,145 +13,87 @@
 #
 # 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 Callable, List, Optional, Sequence, Type, Union
+from typing import Optional, Union, Any, List, Type, Dict
+from enum import Enum
 
-from telethon.tl.types import (MessageEntityMentionName as MentionName,
-                               MessageEntityTextUrl as TextURL, MessageEntityPre as Pre,
-                               TypeMessageEntity, InputMessageEntityMentionName as InputMentionName)
+from telethon.tl.types import (MessageEntityMention as Mention, MessageEntityBotCommand as Command,
+                               MessageEntityMentionName as MentionName, MessageEntityUrl as URL,
+                               MessageEntityEmail as Email, MessageEntityTextUrl as TextURL,
+                               MessageEntityBold as Bold, MessageEntityItalic as Italic,
+                               MessageEntityCode as Code, MessageEntityPre as Pre,
+                               MessageEntityStrike as Strike, MessageEntityUnderline as Underline,
+                               MessageEntityBlockquote as Blockquote, TypeMessageEntity,
+                               InputMessageEntityMentionName as InputMentionName)
+
+from mautrix.util.formatter import EntityString, SemiAbstractEntity
 
 
-class Entity:
-    @staticmethod
-    def copy(entity: TypeMessageEntity) -> Optional[TypeMessageEntity]:
-        if not entity:
-            return None
-        kwargs = {
-            "offset": entity.offset,
-            "length": entity.length,
-        }
-        if isinstance(entity, Pre):
-            kwargs["language"] = entity.language
-        elif isinstance(entity, TextURL):
-            kwargs["url"] = entity.url
-        elif isinstance(entity, (MentionName, InputMentionName)):
-            kwargs["user_id"] = entity.user_id
-        return entity.__class__(**kwargs)
+class TelegramEntityType(Enum):
+    """EntityType is a Matrix formatting entity type."""
+    BOLD = Bold
+    ITALIC = Italic
+    STRIKETHROUGH = Strike
+    UNDERLINE = Underline
+    URL = URL
+    INLINE_URL = TextURL
+    EMAIL = Email
+    PREFORMATTED = Pre
+    INLINE_CODE = Code
+    BLOCKQUOTE = Blockquote
+    MENTION = Mention
+    MENTION_NAME = MentionName
+    COMMAND = Command
 
-    @classmethod
-    def adjust(cls, entity: Union[TypeMessageEntity, List[TypeMessageEntity]],
-               func: Callable[[TypeMessageEntity], None]
-               ) -> Union[Optional[TypeMessageEntity], List[TypeMessageEntity]]:
-        if isinstance(entity, list):
-            return [Entity.adjust(element, func) for element in entity if entity]
-        elif not entity:
-            return None
-        entity = cls.copy(entity)
-        func(entity)
-        if entity.offset < 0:
-            entity.length += entity.offset
-            entity.offset = 0
-        return entity
+    USER_MENTION = 1
+    ROOM_MENTION = 2
+    HEADER = 3
 
 
-def offset_diff(amount: int) -> Callable[[TypeMessageEntity], None]:
-    def func(entity: TypeMessageEntity) -> None:
-        entity.offset += amount
+class TelegramEntity(SemiAbstractEntity):
+    internal: TypeMessageEntity
 
-    return func
+    def __init__(self, type: Union[TelegramEntityType, Type[TypeMessageEntity]],
+                 offset: int, length: int, extra_info: Dict[str, Any]) -> None:
+        if isinstance(type, TelegramEntityType):
+            if isinstance(type.value, int):
+                raise ValueError(f"Can't create Entity with non-Telegram EntityType {type}")
+            type = type.value
+        self.internal = type(offset=offset, length=length, **extra_info)
+
+    def copy(self) -> Optional['TelegramEntity']:
+        extra_info = {}
+        if isinstance(self.internal, Pre):
+            extra_info["language"] = self.internal.language
+        elif isinstance(self.internal, TextURL):
+            extra_info["url"] = self.internal.url
+        elif isinstance(self.internal, (MentionName, InputMentionName)):
+            extra_info["user_id"] = self.internal.user_id
+        return TelegramEntity(type(self.internal), offset=self.internal.offset,
+                              length=self.internal.length, extra_info=extra_info)
+
+    def __repr__(self) -> str:
+        return str(self.internal)
+
+    @property
+    def offset(self) -> int:
+        return self.internal.offset
+
+    @offset.setter
+    def offset(self, value: int) -> None:
+        self.internal.offset = value
+
+    @property
+    def length(self) -> int:
+        return self.internal.length
+
+    @length.setter
+    def length(self, value: int) -> None:
+        self.internal.length = value
 
 
-def offset_length_multiply(amount: int) -> Callable[[TypeMessageEntity], None]:
-    def func(entity: TypeMessageEntity) -> None:
-        entity.offset *= amount
-        entity.length *= amount
+class TelegramMessage(EntityString[TelegramEntity, TelegramEntityType]):
+    entity_class = TelegramEntity
 
-    return func
-
-
-class TelegramMessage:
-    def __init__(self, text: str = "", entities: Optional[List[TypeMessageEntity]] = None) -> None:
-        self.text = text  # type: str
-        self.entities = entities or []  # type: List[TypeMessageEntity]
-
-    def offset_entities(self, offset: int) -> 'TelegramMessage':
-        def apply_offset(entity: TypeMessageEntity, inner_offset: int
-                         ) -> Optional[TypeMessageEntity]:
-            entity = Entity.copy(entity)
-            entity.offset += inner_offset
-            if entity.offset < 0:
-                entity.offset = 0
-            elif entity.offset > len(self.text):
-                return None
-            elif entity.offset + entity.length > len(self.text):
-                entity.length = len(self.text) - entity.offset
-            return entity
-
-        self.entities = [apply_offset(entity, offset) for entity in self.entities if entity]
-        self.entities = [x for x in self.entities if x is not None]
-        return self
-
-    def append(self, *args: Union[str, 'TelegramMessage']) -> 'TelegramMessage':
-        for msg in args:
-            if isinstance(msg, str):
-                msg = TelegramMessage(text=msg)
-            self.entities += Entity.adjust(msg.entities, offset_diff(len(self.text)))
-            self.text += msg.text
-        return self
-
-    def prepend(self, *args: Union[str, 'TelegramMessage']) -> 'TelegramMessage':
-        for msg in args:
-            if isinstance(msg, str):
-                msg = TelegramMessage(text=msg)
-            self.entities = msg.entities + Entity.adjust(self.entities, offset_diff(len(msg.text)))
-            self.text = msg.text + self.text
-        return self
-
-    def format(self, entity_type: Type[TypeMessageEntity], offset: int = None, length: int = None,
-               **kwargs) -> 'TelegramMessage':
-        self.entities.append(entity_type(offset=offset or 0,
-                                         length=length if length is not None else len(self.text),
-                                         **kwargs))
-        return self
-
-    def concat(self, *args: Union[str, 'TelegramMessage']) -> 'TelegramMessage':
-        return TelegramMessage().append(self, *args)
-
-    def trim(self) -> 'TelegramMessage':
-        orig_len = len(self.text)
-        self.text = self.text.lstrip()
-        diff = orig_len - len(self.text)
-        self.text = self.text.rstrip()
-        self.offset_entities(-diff)
-        return self
-
-    def split(self, separator, max_items: int = 0) -> List['TelegramMessage']:
-        text_parts = self.text.split(separator, max_items - 1)
-        output = []  # type: List[TelegramMessage]
-
-        offset = 0
-        for part in text_parts:
-            msg = TelegramMessage(part)
-            for entity in self.entities:
-                start_in_range = len(part) > entity.offset - offset >= 0
-                end_in_range = len(part) >= entity.offset - offset + entity.length > 0
-                if start_in_range and end_in_range:
-                    msg.entities.append(Entity.adjust(entity, offset_diff(-offset)))
-            output.append(msg)
-
-            offset += len(part)
-            offset += len(separator)
-
-        return output
-
-    @staticmethod
-    def join(items: Sequence[Union[str, 'TelegramMessage']],
-             separator: str = " ") -> 'TelegramMessage':
-        main = TelegramMessage()
-        for msg in items:
-            if isinstance(msg, str):
-                msg = TelegramMessage(text=msg)
-            main.entities += Entity.adjust(msg.entities, offset_diff(len(main.text)))
-            main.text += msg.text + separator
-        if len(separator) > 0:
-            main.text = main.text[:-len(separator)]
-        return main
+    @property
+    def telegram_entities(self) -> List[TypeMessageEntity]:
+        return [entity.internal for entity in self.entities]

mautrix_telegram/formatter/from_telegram.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,7 +13,7 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict, List, Optional, Tuple, TYPE_CHECKING
+from typing import List, Optional, TYPE_CHECKING
 from html import escape
 import logging
 import re
@@ -23,208 +22,163 @@ from telethon.tl.types import (MessageEntityMention, MessageEntityMentionName, M
                                MessageEntityEmail, MessageEntityTextUrl, MessageEntityBold,
                                MessageEntityItalic, MessageEntityCode, MessageEntityPre,
                                MessageEntityBotCommand, MessageEntityHashtag, MessageEntityCashtag,
-                               MessageEntityPhone, TypeMessageEntity, Message, PeerChannel,
-                               MessageFwdHeader, PeerUser)
+                               MessageEntityPhone, TypeMessageEntity, PeerChannel, PeerChat,
+                               MessageEntityBlockquote, MessageEntityStrike, MessageFwdHeader,
+                               MessageEntityUnderline, PeerUser)
+from telethon.tl.custom import Message
+from telethon.errors import RPCError
+from telethon.helpers import add_surrogate, del_surrogate
 
-from mautrix_appservice import MatrixRequestError
-from mautrix_appservice.intent_api import IntentAPI
+from mautrix.errors import MatrixRequestError
+from mautrix.appservice import IntentAPI
+from mautrix.types import (TextMessageEventContent, RelatesTo, RelationType, Format, MessageType,
+                           MessageEvent)
 
 from .. import user as u, puppet as pu, portal as po
 from ..types import TelegramID
 from ..db import Message as DBMessage
-from .util import (add_surrogates, remove_surrogates, trim_reply_fallback_html,
-                   trim_reply_fallback_text, unicode_to_html)
 
 if TYPE_CHECKING:
     from ..abstract_user import AbstractUser
-    from ..context import Context
 
-try:
-    from lxml.html.diff import htmldiff
-except ImportError:
-    htmldiff = None  # type: ignore
+log: logging.Logger = logging.getLogger("mau.fmt.tg")
 
 
-log = logging.getLogger("mau.fmt.tg")  # type: logging.Logger
-should_highlight_edits = False  # type: bool
-
-
-def telegram_reply_to_matrix(evt: Message, source: 'AbstractUser') -> Dict:
-    if evt.reply_to_msg_id:
-        space = (evt.to_id.channel_id
-                 if isinstance(evt, Message) and isinstance(evt.to_id, PeerChannel)
+def telegram_reply_to_matrix(evt: Message, source: 'AbstractUser') -> Optional[RelatesTo]:
+    if evt.reply_to:
+        space = (evt.peer_id.channel_id
+                 if isinstance(evt, Message) and isinstance(evt.peer_id, PeerChannel)
                  else source.tgid)
-        msg = DBMessage.get_by_tgid(evt.reply_to_msg_id, space)
+        msg = DBMessage.get_one_by_tgid(TelegramID(evt.reply_to.reply_to_msg_id), space)
         if msg:
-            return {
-                "m.in_reply_to": {
-                    "event_id": msg.mxid,
-                    "room_id": msg.mx_room,
-                }
-            }
-    return {}
+            return RelatesTo(rel_type=RelationType.REPLY, event_id=msg.mxid)
+    return None
 
 
-async def _add_forward_header(source, text: str, html: Optional[str],
-                              fwd_from: MessageFwdHeader) -> Tuple[str, str]:
-    if not html:
-        html = escape(text)
+async def _add_forward_header(source: 'AbstractUser', content: TextMessageEventContent,
+                              fwd_from: MessageFwdHeader) -> None:
+    if not content.formatted_body or content.format != Format.HTML:
+        content.format = Format.HTML
+        content.formatted_body = escape(content.body)
     fwd_from_html, fwd_from_text = None, None
-    if fwd_from.from_id:
-        user = u.User.get_by_tgid(fwd_from.from_id)
+    if isinstance(fwd_from.from_id, PeerUser):
+        user = u.User.get_by_tgid(TelegramID(fwd_from.from_id.user_id))
         if user:
             fwd_from_text = user.displayname or user.mxid
-            fwd_from_html = f"<a href='https://matrix.to/#/{user.mxid}'>{fwd_from_text}</a>"
+            fwd_from_html = (f"<a href='https://matrix.to/#/{user.mxid}'>"
+                             f"{escape(fwd_from_text)}</a>")
 
         if not fwd_from_text:
-            puppet = pu.Puppet.get(TelegramID(fwd_from.from_id), create=False)
+            puppet = pu.Puppet.get(TelegramID(fwd_from.from_id.user_id), create=False)
             if puppet and puppet.displayname:
                 fwd_from_text = puppet.displayname or puppet.mxid
-                fwd_from_html = f"<a href='https://matrix.to/#/{puppet.mxid}'>{fwd_from_text}</a>"
+                fwd_from_html = (f"<a href='https://matrix.to/#/{puppet.mxid}'>"
+                                 f"{escape(fwd_from_text)}</a>")
 
         if not fwd_from_text:
-            user = await source.client.get_entity(PeerUser(fwd_from.from_id))
-            if user:
-                fwd_from_text = pu.Puppet.get_displayname(user, False)
-                fwd_from_html = f"<b>{fwd_from_text}</b>"
-    else:
-        portal = po.Portal.get_by_tgid(TelegramID(fwd_from.channel_id))
-        if portal:
+            try:
+                user = await source.client.get_entity(fwd_from.from_id)
+                if user:
+                    fwd_from_text, _ = pu.Puppet.get_displayname(user, False)
+                    fwd_from_html = f"<b>{escape(fwd_from_text)}</b>"
+            except (ValueError, RPCError):
+                fwd_from_text = fwd_from_html = "unknown user"
+    elif isinstance(fwd_from.from_id, (PeerChannel, PeerChat)):
+        from_id = (fwd_from.from_id.chat_id if isinstance(fwd_from.from_id, PeerChat)
+                   else fwd_from.from_id.channel_id)
+        portal = po.Portal.get_by_tgid(TelegramID(from_id))
+        if portal and portal.title:
             fwd_from_text = portal.title
             if portal.alias:
-                fwd_from_html = f"<a href='https://matrix.to/#/{portal.alias}'>{fwd_from_text}</a>"
+                fwd_from_html = (f"<a href='https://matrix.to/#/{portal.alias}'>"
+                                 f"{escape(fwd_from_text)}</a>")
             else:
-                fwd_from_html = f"<b>{fwd_from_text}</b>"
+                fwd_from_html = f"channel <b>{escape(fwd_from_text)}</b>"
         else:
-            channel = await source.client.get_entity(PeerChannel(fwd_from.channel_id))
-            if channel:
-                fwd_from_text = channel.title
-                fwd_from_html = f"<b>{fwd_from_text}</b>"
+            try:
+                channel = await source.client.get_entity(fwd_from.from_id)
+                if channel:
+                    fwd_from_text = f"channel {channel.title}"
+                    fwd_from_html = f"channel <b>{escape(channel.title)}</b>"
+            except (ValueError, RPCError):
+                fwd_from_text = fwd_from_html = "unknown channel"
+    elif fwd_from.from_name:
+        fwd_from_text = fwd_from.from_name
+        fwd_from_html = f"<b>{escape(fwd_from.from_name)}</b>"
+    else:
+        fwd_from_text = "unknown source"
+        fwd_from_html = f"unknown source"
 
-    if not fwd_from_text:
-        if fwd_from.from_id:
-            fwd_from_text = "Unknown user"
-        else:
-            fwd_from_text = "Unknown source"
-        fwd_from_html = f"<b>{fwd_from_text}</b>"
-
-    text = "\n".join([f"> {line}" for line in text.split("\n")])
-    text = f"Forwarded from {fwd_from_text}:\n{text}"
-    html = (f"Forwarded message from {fwd_from_html}<br/>"
-            f"<tg-forward><blockquote>{html}</blockquote></tg-forward>")
-    return text, html
+    content.body = "\n".join([f"> {line}" for line in content.body.split("\n")])
+    content.body = f"Forwarded from {fwd_from_text}:\n{content.body}"
+    content.formatted_body = (
+        f"Forwarded message from {fwd_from_html}<br/>"
+        f"<tg-forward><blockquote>{content.formatted_body}</blockquote></tg-forward>")
 
 
-def highlight_edits(new_html: str, old_html: str) -> str:
-    # Don't include `Edit:` text in diff.
-    if old_html.startswith("<u>Edit:</u> "):
-        old_html = old_html[len("<u>Edit:</u> "):]
-
-    # Generate diff with lxml
-    new_html = htmldiff(old_html, new_html)
-
-    # Replace <ins> with <u> since Riot doesn't allow <ins>
-    new_html = new_html.replace("<ins>", "<u>").replace("</ins>", "</u>")
-    # Remove <del>s since we just want to hide deletions.
-    new_html = re.sub("<del>.+?</del>", "", new_html)
-    return new_html
-
-
-async def _add_reply_header(source: "AbstractUser", text: str, html: str, evt: Message,
-                            relates_to: Dict, main_intent: IntentAPI, is_edit: bool
-                            ) -> Tuple[str, str]:
-    space = (evt.to_id.channel_id
-             if isinstance(evt, Message) and isinstance(evt.to_id, PeerChannel)
+async def _add_reply_header(source: 'AbstractUser', content: TextMessageEventContent, evt: Message,
+                            main_intent: IntentAPI):
+    space = (evt.peer_id.channel_id
+             if isinstance(evt, Message) and isinstance(evt.peer_id, PeerChannel)
              else source.tgid)
 
-    msg = DBMessage.get_by_tgid(evt.reply_to_msg_id, space)
+    msg = DBMessage.get_one_by_tgid(TelegramID(evt.reply_to.reply_to_msg_id), space)
     if not msg:
-        return text, html
+        return
 
-    relates_to["m.in_reply_to"] = {
-        "event_id": msg.mxid,
-        "room_id": msg.mx_room,
-    }
+    content.relates_to = RelatesTo(rel_type=RelationType.REPLY, event_id=msg.mxid)
 
     try:
-        event = await main_intent.get_event(msg.mx_room, msg.mxid)
-
-        content = event["content"]
-        r_sender = event["sender"]
-
-        r_text_body = trim_reply_fallback_text(content["body"])
-        r_html_body = trim_reply_fallback_html(content["formatted_body"]
-                                               if "formatted_body" in content
-                                               else escape(content["body"]))
-
-        puppet = pu.Puppet.get_by_mxid(r_sender, create=False)
-        r_displayname = puppet.displayname if puppet else r_sender
-        r_sender_link = f"<a href='https://matrix.to/#/{r_sender}'>{r_displayname}</a>"
-
-        if is_edit and should_highlight_edits:
-            html = highlight_edits(html or escape(text), r_html_body)
-    except (ValueError, KeyError, MatrixRequestError):
-        r_sender_link = "unknown user"
-        r_displayname = "unknown user"
-        r_text_body = "Failed to fetch message"
-        r_html_body = "<em>Failed to fetch message</em>"
-
-    if is_edit:
-        html = f"<u>Edit:</u> {html or escape(text)}"
-        text = f"Edit: {text}"
-
-    r_keyword = "In reply to" if not is_edit else "Edit to"
-    r_msg_link = f"<a href='https://matrix.to/#/{msg.mx_room}/{msg.mxid}'>{r_keyword}</a>"
-    html = (
-        f"<mx-reply><blockquote>{r_msg_link} {r_sender_link}\n{r_html_body}</blockquote></mx-reply>"
-        + (html or escape(text)))
-
-    lines = r_text_body.strip().split("\n")
-    text_with_quote = f"> <{r_displayname}> {lines.pop(0)}"
-    for line in lines:
-        if line:
-            text_with_quote += f"\n> {line}"
-    text_with_quote += "\n\n"
-    text_with_quote += text
-    return text_with_quote, html
+        event: MessageEvent = await main_intent.get_event(msg.mx_room, msg.mxid)
+        if isinstance(event.content, TextMessageEventContent):
+            event.content.trim_reply_fallback()
+        puppet = await pu.Puppet.get_by_mxid(event.sender, create=False)
+        content.set_reply(event, displayname=puppet.displayname if puppet else event.sender)
+    except MatrixRequestError:
+        log.exception("Failed to get event to add reply fallback")
 
 
 async def telegram_to_matrix(evt: Message, source: "AbstractUser",
                              main_intent: Optional[IntentAPI] = None,
-                             is_edit: bool = False, prefix_text: Optional[str] = None,
-                             prefix_html: Optional[str] = None, override_text: str = None,
-                             override_entities: List[TypeMessageEntity] = None
-                             ) -> Tuple[str, str, Dict]:
-    text = add_surrogates(override_text or evt.message)
+                             prefix_text: Optional[str] = None, prefix_html: Optional[str] = None,
+                             override_text: str = None,
+                             override_entities: List[TypeMessageEntity] = None,
+                             no_reply_fallback: bool = False) -> TextMessageEventContent:
+    content = TextMessageEventContent(
+        msgtype=MessageType.TEXT,
+        body=add_surrogate(override_text or evt.message),
+    )
     entities = override_entities or evt.entities
-    html = _telegram_entities_to_matrix_catch(text, entities) if entities else None
-    relates_to = {}  # type: Dict
+    if entities:
+        content.format = Format.HTML
+        content.formatted_body = _telegram_entities_to_matrix_catch(content.body, entities)
 
     if prefix_html:
-        html = prefix_html + (html or escape(text))
+        if not content.formatted_body:
+            content.format = Format.HTML
+            content.formatted_body = escape(content.body)
+        content.formatted_body = prefix_html + content.formatted_body
     if prefix_text:
-        text = prefix_text + text
+        content.body = prefix_text + content.body
 
     if evt.fwd_from:
-        text, html = await _add_forward_header(source, text, html, evt.fwd_from)
+        await _add_forward_header(source, content, evt.fwd_from)
 
-    if evt.reply_to_msg_id:
-        text, html = await _add_reply_header(source, text, html, evt, relates_to, main_intent,
-                                             is_edit)
+    if evt.reply_to and not no_reply_fallback:
+        await _add_reply_header(source, content, evt, main_intent)
 
     if isinstance(evt, Message) and evt.post and evt.post_author:
-        if not html:
-            html = escape(text)
-        text += f"\n- {evt.post_author}"
-        html += f"<br/><i>- <u>{evt.post_author}</u></i>"
+        if not content.formatted_body:
+            content.formatted_body = escape(content.body)
+        content.body += f"\n- {evt.post_author}"
+        content.formatted_body += f"<br/><i>- <u>{evt.post_author}</u></i>"
 
-    html = unicode_to_html(text, html, "\u0336", "del")
-    html = unicode_to_html(text, html, "\u0332", "u")
+    content.body = del_surrogate(content.body)
 
-    if html:
-        html = html.replace("\n", "<br/>")
+    if content.formatted_body:
+        content.formatted_body = del_surrogate(content.formatted_body.replace("\n", "<br/>"))
 
-    return remove_surrogates(text), remove_surrogates(html), relates_to
+    return content
 
 
 def _telegram_entities_to_matrix_catch(text: str, entities: List[TypeMessageEntity]) -> str:
@@ -238,25 +192,39 @@ def _telegram_entities_to_matrix_catch(text: str, entities: List[TypeMessageEnti
     return "[failed conversion in _telegram_entities_to_matrix]"
 
 
-def _telegram_entities_to_matrix(text: str, entities: List[TypeMessageEntity]) -> str:
+def _telegram_entities_to_matrix(text: str, entities: List[TypeMessageEntity],
+                                 offset: int = 0, length: int = None) -> str:
     if not entities:
-        return text
+        return escape(text)
+    if length is None:
+        length = len(text)
     html = []
     last_offset = 0
-    for entity in entities:
-        if entity.offset > last_offset:
-            html.append(escape(text[last_offset:entity.offset]))
-        elif entity.offset < last_offset:
+    for i, entity in enumerate(entities):
+        if entity.offset > offset + length:
+            break
+        relative_offset = entity.offset - offset
+        if relative_offset > last_offset:
+            html.append(escape(text[last_offset:relative_offset]))
+        elif relative_offset < last_offset:
             continue
 
         skip_entity = False
-        entity_text = escape(text[entity.offset:entity.offset + entity.length])
+        entity_text = _telegram_entities_to_matrix(
+            text=text[relative_offset:relative_offset + entity.length],
+            entities=entities[i + 1:], offset=entity.offset, length=entity.length)
         entity_type = type(entity)
 
         if entity_type == MessageEntityBold:
             html.append(f"<strong>{entity_text}</strong>")
         elif entity_type == MessageEntityItalic:
             html.append(f"<em>{entity_text}</em>")
+        elif entity_type == MessageEntityUnderline:
+            html.append(f"<u>{entity_text}</u>")
+        elif entity_type == MessageEntityStrike:
+            html.append(f"<del>{entity_text}</del>")
+        elif entity_type == MessageEntityBlockquote:
+            html.append(f"<blockquote>{entity_text}</blockquote>")
         elif entity_type == MessageEntityCode:
             html.append(f"<pre><code>{entity_text}</code></pre>"
                         if "\n" in entity_text
@@ -278,8 +246,8 @@ def _telegram_entities_to_matrix(text: str, entities: List[TypeMessageEntity]) -
             html.append(f"<font color='blue'>{entity_text}</font>")
         else:
             skip_entity = True
-        last_offset = entity.offset + (0 if skip_entity else entity.length)
-    html.append(text[last_offset:])
+        last_offset = relative_offset + (0 if skip_entity else entity.length)
+    html.append(escape(text[last_offset:]))
 
     return "".join(html)
 
@@ -325,8 +293,8 @@ def _parse_name_mention(html: List[str], entity_text: str, user_id: TelegramID)
     return False
 
 
-message_link_regex = re.compile(
-    r"https?://t(?:elegram)?\.(?:me|dog)/([A-Za-z][A-Za-z0-9_]{3,}[A-Za-z0-9])/([0-9]{1,50})")
+message_link_regex = re.compile(r"https?://t(?:elegram)?\.(?:me|dog)/"
+                                r"([A-Za-z][A-Za-z0-9_]{3,}[A-Za-z0-9])/([0-9]{1,50})")
 
 
 def _parse_url(html: List[str], entity_text: str, url: str) -> bool:
@@ -341,14 +309,9 @@ def _parse_url(html: List[str], entity_text: str, url: str) -> bool:
 
         portal = po.Portal.find_by_username(group)
         if portal:
-            message = DBMessage.get_by_tgid(TelegramID(msgid), portal.tgid)
+            message = DBMessage.get_one_by_tgid(TelegramID(msgid), portal.tgid)
             if message:
                 url = f"https://matrix.to/#/{portal.mxid}/{message.mxid}"
 
     html.append(f"<a href='{url}'>{entity_text}</a>")
     return False
-
-
-def init_tg(context: "Context") -> None:
-    global should_highlight_edits
-    should_highlight_edits = htmldiff and context.config["bridge.highlight_edits"]

mautrix_telegram/formatter/util.py

@@ -1,89 +0,0 @@
-# -*- coding: future_fstrings -*-
-# mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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, Pattern
-from html import escape
-import struct
-import re
-
-
-def unicode_to_html(text: str, html: str, ctrl: str, tag: str) -> str:
-    if ctrl not in text:
-        return html
-    if not html:
-        html = escape(text)
-    tag_start = f"<{tag}>"
-    tag_end = f"</{tag}>"
-    characters = html.split(ctrl)
-    html = ""
-    in_tag = False
-    for char in characters:
-        if not in_tag:
-            if len(char) > 1:
-                html += char[0:-1]
-                char = char[-1]
-            html += tag_start
-            in_tag = True
-            html += char
-        else:
-            if len(char) > 1:
-                html += tag_end
-                in_tag = False
-            html += char
-    if in_tag:
-        html += tag_end
-    return html
-
-
-def html_to_unicode(text: str, ctrl: str) -> str:
-    return ctrl.join(text) + ctrl
-
-
-# add_surrogates and remove_surrogates are unicode surrogate utility functions from Telethon.
-# Licensed under the MIT license.
-# https://github.com/LonamiWebs/Telethon/blob/7cce7aa3e4c6c7019a55530391b1761d33e5a04e/telethon/helpers.py
-def add_surrogates(text: Optional[str]) -> Optional[str]:
-    if text is None:
-        return None
-    return "".join("".join(chr(y) for y in struct.unpack("<HH", x.encode("utf-16-le")))
-                   if (0x10000 <= ord(x) <= 0x10FFFF) else x for x in text)
-
-
-def remove_surrogates(text: Optional[str]) -> Optional[str]:
-    if text is None:
-        return None
-    return text.encode("utf-16", "surrogatepass").decode("utf-16")
-
-
-# trim_reply_fallback_text, html_reply_fallback_regex and trim_reply_fallback_html are Matrix
-# reply fallback utility functions.
-# You may copy and use them under any OSI-approved license.
-def trim_reply_fallback_text(text: str) -> str:
-    if not text.startswith("> ") or "\n" not in text:
-        return text
-    lines = text.split("\n")
-    while len(lines) > 0 and lines[0].startswith("> "):
-        lines.pop(0)
-    return "\n".join(lines)
-
-
-html_reply_fallback_regex = re.compile("^<mx-reply>"
-                                       r"[\s\S]+?"
-                                       "</mx-reply>")  # type: Pattern
-
-
-def trim_reply_fallback_html(html: str) -> str:
-    return html_reply_fallback_regex.sub("", html)

mautrix_telegram/get_version.py

@@ -0,0 +1,49 @@
+import subprocess
+import shutil
+import os
+
+from . import __version__
+
+cmd_env = {
+    "PATH": os.environ["PATH"],
+    "HOME": os.environ["HOME"],
+    "LANG": "C",
+    "LC_ALL": "C",
+}
+
+
+def run(cmd):
+    return subprocess.check_output(cmd, stderr=subprocess.DEVNULL, env=cmd_env)
+
+if os.path.exists(".git") and shutil.which("git"):
+    try:
+        git_revision = run(["git", "rev-parse", "HEAD"]).strip().decode("ascii")
+        git_revision_url = f"https://github.com/tulir/mautrix-telegram/commit/{git_revision}"
+        git_revision = git_revision[:8]
+    except (subprocess.SubprocessError, OSError):
+        git_revision = "unknown"
+        git_revision_url = None
+
+    try:
+        git_tag = run(["git", "describe", "--exact-match", "--tags"]).strip().decode("ascii")
+    except (subprocess.SubprocessError, OSError):
+        git_tag = None
+else:
+    git_revision = "unknown"
+    git_revision_url = None
+    git_tag = None
+
+git_tag_url = (f"https://github.com/tulir/mautrix-telegram/releases/tag/{git_tag}"
+               if git_tag else None)
+
+if git_tag and __version__ == git_tag[1:].replace("-", ""):
+    version = __version__
+    linkified_version = f"[{version}]({git_tag_url})"
+else:
+    if not __version__.endswith("+dev"):
+        __version__ += "+dev"
+    version = f"{__version__}.{git_revision}"
+    if git_revision_url:
+        linkified_version = f"{__version__}.[{git_revision}]({git_revision_url})"
+    else:
+        linkified_version = version

mautrix_telegram/matrix.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 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
@@ -14,50 +13,47 @@
 #
 # 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, Match, Optional, Set, Tuple, TYPE_CHECKING
-import logging
-import asyncio
-import re
+from typing import Dict, Set, Tuple, Union, Iterable, TYPE_CHECKING
 
-from mautrix_appservice import MatrixRequestError, IntentError
+from mautrix.bridge import BaseMatrixHandler
+from mautrix.types import (Event, EventType, RoomID, UserID, EventID, ReceiptEvent, ReceiptType,
+                           ReceiptEventContent, PresenceEvent, PresenceState, TypingEvent,
+                           MessageEvent, StateEvent, RedactionEvent, RoomNameStateEventContent,
+                           RoomAvatarStateEventContent, RoomTopicStateEventContent,
+                           MemberStateEventContent, EncryptedEvent, TextMessageEventContent,
+                           MessageType)
+from mautrix.errors import MatrixError
 
-from .types import MatrixEvent, MatrixEventID, MatrixRoomID, MatrixUserID
 from . import user as u, portal as po, puppet as pu, commands as com
 
 if TYPE_CHECKING:
     from .context import Context
+    from .bot import Bot
+
+RoomMetaStateEventContent = Union[RoomNameStateEventContent, RoomAvatarStateEventContent,
+                                  RoomTopicStateEventContent]
 
 
-class MatrixHandler:
-    log = logging.getLogger("mau.mx")  # type: logging.Logger
+class MatrixHandler(BaseMatrixHandler):
+    bot: 'Bot'
+    commands: 'com.CommandProcessor'
+    previously_typing: Dict[RoomID, Set[UserID]]
 
     def __init__(self, context: 'Context') -> None:
-        self.az, self.db, self.config, _, self.tgbot = context.core
-        self.commands = com.CommandProcessor(context)  # type: com.CommandProcessor
-        self.previously_typing = []  # type: List[MatrixUserID]
+        prefix, suffix = context.config["bridge.username_template"].format(userid=":").split(":")
+        homeserver = context.config["homeserver.domain"]
+        self.user_id_prefix = f"@{prefix}"
+        self.user_id_suffix = f"{suffix}:{homeserver}"
 
-        self.az.matrix_event_handler(self.handle_event)
+        super().__init__(command_processor=com.CommandProcessor(context), bridge=context.bridge)
 
-    async def init_as_bot(self) -> None:
-        displayname = self.config["appservice.bot_displayname"]
-        if displayname:
-            try:
-                await self.az.intent.set_display_name(
-                    displayname if displayname != "remove" else "")
-            except asyncio.TimeoutError:
-                self.log.exception("TimeoutError when trying to set displayname")
+        self.bot = context.bot
+        self.previously_typing = {}
 
-        avatar = self.config["appservice.bot_avatar"]
-        if avatar:
-            try:
-                await self.az.intent.set_avatar(avatar if avatar != "remove" else "")
-            except asyncio.TimeoutError:
-                self.log.exception("TimeoutError when trying to set avatar")
-
-    async def handle_puppet_invite(self, room_id: MatrixRoomID, puppet: pu.Puppet, inviter: u.User
-                                   ) -> None:
+    async def handle_puppet_invite(self, room_id: RoomID, puppet: pu.Puppet, inviter: u.User,
+                                   event_id: EventID) -> None:
         intent = puppet.default_mxid_intent
-        self.log.debug(f"{inviter} invited puppet for {puppet.tgid} to {room_id}")
+        self.log.debug(f"{inviter.mxid} invited puppet for {puppet.tgid} to {room_id}")
         if not await inviter.is_logged_in():
             await intent.error_and_leave(
                 room_id, text="Please log in before inviting Telegram puppets.")
@@ -72,11 +68,12 @@ class MatrixHandler:
             await intent.join_room(room_id)
             return
         try:
-            members = await self.az.intent.get_room_members(room_id)
-        except MatrixRequestError:
-            members = []
+            members = await intent.get_room_members(room_id)
+        except MatrixError:
+            self.log.exception(f"Failed to get members after joining {room_id} as {intent.mxid}")
+            return
         if self.az.bot_mxid not in members:
-            if len(members) > 1:
+            if len(members) > 2:
                 await intent.error_and_leave(room_id, text=None, html=(
                     f"Please invite "
                     f"<a href='https://matrix.to/#/{self.az.bot_mxid}'>the bridge bot</a> "
@@ -85,70 +82,57 @@ class MatrixHandler:
 
             await intent.join_room(room_id)
             portal = po.Portal.get_by_tgid(puppet.tgid, inviter.tgid, "user")
-            # TODO: if portal is None:
             if portal.mxid:
                 try:
-                    await intent.invite(portal.mxid, inviter.mxid)
-                    await intent.send_notice(room_id, text=None, html=(
-                        "You already have a private chat with me: "
-                        f"<a href='https://matrix.to/#/{portal.mxid}'>"
-                        "Link to room"
-                        "</a>"))
+                    await intent.invite_user(portal.mxid, inviter.mxid)
+                    await intent.send_notice(
+                        room_id, text=f"You already have a private chat with me: {portal.mxid}",
+                        html=("You already have a private chat with me: "
+                              f"<a href='https://matrix.to/#/{portal.mxid}'>Link to room</a>"))
                     await intent.leave_room(room_id)
                     return
-                except MatrixRequestError:
+                except MatrixError:
                     pass
             portal.mxid = room_id
-            portal.save()
-            inviter.register_portal(portal)
-            await intent.send_notice(room_id, "Portal to private chat created.")
+            e2be_ok = await portal.check_dm_encryption()
+            await portal.save()
+            await inviter.register_portal(portal)
+            if e2be_ok is True:
+                evt_type, content = await self.e2ee.encrypt(
+                    room_id, EventType.ROOM_MESSAGE,
+                    TextMessageEventContent(msgtype=MessageType.NOTICE,
+                                            body="Portal to private chat created and end-to-bridge"
+                                                 " encryption enabled."))
+                await intent.send_message_event(room_id, evt_type, content)
+            else:
+                message = "Portal to private chat created."
+                if e2be_ok is False:
+                    message += "\n\nWarning: Failed to enable end-to-bridge encryption"
+                await intent.send_notice(room_id, message)
         else:
             await intent.join_room(room_id)
             await intent.send_notice(room_id, "This puppet will remain inactive until a "
                                               "Telegram chat is created for this room.")
 
-    async def accept_bot_invite(self, room_id: MatrixRoomID, inviter: u.User) -> None:
-        tries = 0
-        while tries < 5:
-            try:
-                await self.az.intent.join_room(room_id)
-                break
-            except (IntentError, MatrixRequestError):
-                tries += 1
-                wait_for_seconds = (tries + 1) * 10
-                if tries < 5:
-                    self.log.exception(f"Failed to join room {room_id} with bridge bot, "
-                                       f"retrying in {wait_for_seconds} seconds...")
-                    await asyncio.sleep(wait_for_seconds)
-                else:
-                    self.log.exception("Failed to join room {room}, giving up.")
-                    return
-
-        if not inviter.whitelisted:
-            await self.az.intent.send_notice(
-                room_id, text="",
-                html="You are not whitelisted to use this bridge.<br/><br/>"
-                     "If you are the owner of this bridge, see the "
-                     "<code>bridge.permissions</code> section in your config file.")
-            await self.az.intent.leave_room(room_id)
-
-    async def handle_invite(self, room_id: MatrixRoomID, user_id: MatrixUserID,
-                            inviter_mxid: MatrixUserID) -> None:
-        self.log.debug(f"{inviter_mxid} invited {user_id} to {room_id}")
-        inviter = u.User.get_by_mxid(inviter_mxid)
-        if inviter is None:
-            self.log.exception("Failed to find user with Matrix ID {inviter_mxid}")
-        await inviter.ensure_started()
-        if user_id == self.az.bot_mxid:
-            return await self.accept_bot_invite(room_id, inviter)
-        elif not inviter.whitelisted:
-            return
-
-        puppet = pu.Puppet.get_by_mxid(user_id)
-        if puppet:
-            await self.handle_puppet_invite(room_id, puppet, inviter)
+    async def send_welcome_message(self, room_id: RoomID, inviter: 'u.User') -> None:
+        try:
+            is_management = len(await self.az.intent.get_room_members(room_id)) == 2
+        except MatrixError:
+            # The AS bot is not in the room.
             return
+        cmd_prefix = self.commands.command_prefix
+        text = html = "Hello, I'm a Telegram bridge bot. "
+        if is_management and inviter.puppet_whitelisted and not await inviter.is_logged_in():
+            text += f"Use `{cmd_prefix} help` for help or `{cmd_prefix} login` to log in."
+            html += (f"Use <code>{cmd_prefix} help</code> for help"
+                     f" or <code>{cmd_prefix} login</code> to log in.")
+        else:
+            text += f"Use `{cmd_prefix} help` for help."
+            html += f"Use <code>{cmd_prefix} help</code> for help."
+        await self.az.intent.send_notice(room_id, text=text, html=html)
 
+    async def handle_invite(self, room_id: RoomID, user_id: UserID, inviter: 'u.User',
+                            event_id: EventID) -> None:
         user = u.User.get_by_mxid(user_id, create=False)
         if not user:
             return
@@ -156,12 +140,8 @@ class MatrixHandler:
         portal = po.Portal.get_by_mxid(room_id)
         if user and await user.has_full_access(allow_bot=True) and portal:
             await portal.invite_telegram(inviter, user)
-            return
 
-        # The rest can probably be ignored
-
-    async def handle_join(self, room_id: MatrixRoomID, user_id: MatrixUserID,
-                          event_id: MatrixEventID) -> None:
+    async def handle_join(self, room_id: RoomID, user_id: UserID, event_id: EventID) -> None:
         user = await u.User.get_by_mxid(user_id).ensure_started()
 
         portal = po.Portal.get_by_mxid(room_id)
@@ -169,35 +149,58 @@ class MatrixHandler:
             return
 
         if not user.relaybot_whitelisted:
-            await portal.main_intent.kick(room_id, user.mxid,
-                                          "You are not whitelisted on this Telegram bridge.")
+            await portal.main_intent.kick_user(room_id, user.mxid,
+                                               "You are not whitelisted on this Telegram bridge.")
             return
         elif not await user.is_logged_in() and not portal.has_bot:
-            await portal.main_intent.kick(room_id, user.mxid,
-                                          "This chat does not have a bot relaying "
-                                          "messages for unauthenticated users.")
+            await portal.main_intent.kick_user(room_id, user.mxid,
+                                               "This chat does not have a bot relaying "
+                                               "messages for unauthenticated users.")
             return
 
-        self.log.debug(f"{user} joined {room_id}")
+        self.log.debug(f"{user.mxid} joined {room_id}")
         if await user.is_logged_in() or portal.has_bot:
             await portal.join_matrix(user, event_id)
 
-    async def handle_part(self, room_id: MatrixRoomID, user_id: MatrixUserID,
-                          sender_mxid: MatrixUserID, event_id: MatrixEventID) -> None:
+    async def get_leave_handle_info(self) -> Tuple[po.Portal, u.User]:
+        pass
+
+    async def handle_leave(self, room_id: RoomID, user_id: UserID, event_id: EventID) -> None:
         self.log.debug(f"{user_id} left {room_id}")
-
-        sender = u.User.get_by_mxid(sender_mxid, create=False)
-        if not sender:
-            return
-        await sender.ensure_started()
-
         portal = po.Portal.get_by_mxid(room_id)
         if not portal:
             return
 
-        puppet = pu.Puppet.get_by_mxid(user_id)
+        user = u.User.get_by_mxid(user_id, create=False)
+        if not user:
+            return
+        await user.ensure_started()
+        await portal.leave_matrix(user, event_id)
+
+    async def handle_kick_ban(self, ban: bool, room_id: RoomID, user_id: UserID, sender: UserID,
+                              reason: str, event_id: EventID) -> None:
+        action = "banned" if ban else "kicked"
+        self.log.debug(f"{user_id} was {action} from {room_id} by {sender} for {reason}")
+        portal = po.Portal.get_by_mxid(room_id)
+        if not portal:
+            return
+
+        if user_id == self.az.bot_mxid:
+            # Direct chat portal unbridging is handled in portal.kick_matrix
+            if portal.peer_type != "user":
+                await portal.unbridge()
+            return
+
+        sender = u.User.get_by_mxid(sender, create=False)
+        if not sender:
+            return
+        await sender.ensure_started()
+
+        puppet = await pu.Puppet.get_by_mxid(user_id)
         if puppet:
-            if sender:
+            if ban:
+                await portal.ban_matrix(puppet, sender)
+            else:
                 await portal.kick_matrix(puppet, sender)
             return
 
@@ -205,228 +208,192 @@ class MatrixHandler:
         if not user:
             return
         await user.ensure_started()
-        if await user.is_logged_in() or portal.has_bot:
-            await portal.leave_matrix(user, sender, event_id)
+        if ban:
+            await portal.ban_matrix(user, sender)
+        else:
+            await portal.kick_matrix(user, sender)
 
-    def is_command(self, message: Dict) -> Tuple[bool, str]:
-        text = message.get("body", "")
-        prefix = self.config["bridge.command_prefix"]
-        is_command = text.startswith(prefix)
-        if is_command:
-            text = text[len(prefix) + 1:]
-        return is_command, text
+    async def handle_kick(self, room_id: RoomID, user_id: UserID, kicked_by: UserID, reason: str,
+                          event_id: EventID) -> None:
+        await self.handle_kick_ban(False, room_id, user_id, kicked_by, reason, event_id)
 
-    async def handle_message(self, room: MatrixRoomID, sender_id: MatrixUserID, message: Dict,
-                             event_id: MatrixEventID) -> None:
-        is_command, text = self.is_command(message)
-        sender = await u.User.get_by_mxid(sender_id).ensure_started()
-        if not sender.relaybot_whitelisted:
-            self.log.debug(f"Ignoring message \"{message}\" from {sender} to {room}:"
-                           " User is not whitelisted.")
-            return
-        self.log.debug(f"Received Matrix event \"{message}\" from {sender} in {room}")
+    async def handle_unban(self, room_id: RoomID, user_id: UserID, unbanned_by: UserID,
+                           reason: str, event_id: EventID) -> None:
+        # TODO handle unbans properly instead of handling it as a kick
+        await self.handle_kick_ban(False, room_id, user_id, unbanned_by, reason, event_id)
 
-        portal = po.Portal.get_by_mxid(room)
-        if not is_command and portal and (await sender.is_logged_in() or portal.has_bot):
-            await portal.handle_matrix_message(sender, message, event_id)
-            return
-
-        if not sender.whitelisted or message.get("msgtype", "m.unknown") != "m.text":
-            return
-
-        try:
-            is_management = len(await self.az.intent.get_room_members(room)) == 2
-        except MatrixRequestError:
-            # The AS bot is not in the room.
-            return
-
-        if is_command or is_management:
-            try:
-                command, arguments = text.split(" ", 1)
-                args = arguments.split(" ")
-            except ValueError:
-                # Not enough values to unpack, i.e. no arguments
-                command = text
-                args = []
-            await self.commands.handle(room, sender, command, args, is_management,
-                                       is_portal=portal is not None)
+    async def handle_ban(self, room_id: RoomID, user_id: UserID, banned_by: UserID, reason: str,
+                         event_id: EventID) -> None:
+        await self.handle_kick_ban(True, room_id, user_id, banned_by, reason, event_id)
 
     @staticmethod
-    async def handle_redaction(room_id: MatrixRoomID, sender_mxid: MatrixUserID,
-                               event_id: MatrixEventID) -> None:
-        sender = await u.User.get_by_mxid(sender_mxid).ensure_started()
+    async def allow_message(user: 'u.User') -> bool:
+        return user.relaybot_whitelisted
+
+    @staticmethod
+    async def allow_command(user: 'u.User') -> bool:
+        return user.whitelisted
+
+    @staticmethod
+    async def allow_bridging_message(user: 'u.User', portal: 'po.Portal') -> bool:
+        return await user.is_logged_in() or portal.has_bot
+
+    @staticmethod
+    async def handle_redaction(evt: RedactionEvent) -> None:
+        sender = await u.User.get_by_mxid(evt.sender).ensure_started()
         if not sender.relaybot_whitelisted:
             return
 
-        portal = po.Portal.get_by_mxid(room_id)
+        portal = po.Portal.get_by_mxid(evt.room_id)
         if not portal:
             return
 
-        await portal.handle_matrix_deletion(sender, event_id)
+        await portal.handle_matrix_deletion(sender, evt.redacts, evt.event_id)
 
     @staticmethod
-    async def handle_power_levels(room_id: MatrixRoomID, sender_mxid: MatrixUserID,
-                                  new: Dict, old: Dict) -> None:
+    async def handle_power_levels(evt: StateEvent) -> None:
+        portal = po.Portal.get_by_mxid(evt.room_id)
+        sender = await u.User.get_by_mxid(evt.sender).ensure_started()
+        if await sender.has_full_access(allow_bot=True) and portal:
+            await portal.handle_matrix_power_levels(sender, evt.content.users,
+                                                    evt.unsigned.prev_content.users,
+                                                    evt.event_id)
+
+    @staticmethod
+    async def handle_room_meta(evt_type: EventType, room_id: RoomID, sender_mxid: UserID,
+                               content: RoomMetaStateEventContent, event_id: EventID) -> None:
         portal = po.Portal.get_by_mxid(room_id)
         sender = await u.User.get_by_mxid(sender_mxid).ensure_started()
         if await sender.has_full_access(allow_bot=True) and portal:
-            await portal.handle_matrix_power_levels(sender, new["users"], old["users"])
-
-    @staticmethod
-    async def handle_room_meta(evt_type: str, room_id: MatrixRoomID, sender_mxid: MatrixUserID,
-                               content: dict) -> None:
-        portal = po.Portal.get_by_mxid(room_id)
-        sender = await u.User.get_by_mxid(sender_mxid).ensure_started()
-        if await sender.has_full_access(allow_bot=True) and portal:
-            handler, content_key = {
-                "m.room.name": (portal.handle_matrix_title, "name"),
-                "m.room.topic": (portal.handle_matrix_about, "topic"),
-                "m.room.avatar": (portal.handle_matrix_avatar, "url"),
+            handler, content_type, content_key = {
+                EventType.ROOM_NAME: (portal.handle_matrix_title, RoomNameStateEventContent, "name"),
+                EventType.ROOM_TOPIC: (portal.handle_matrix_about, RoomTopicStateEventContent, "topic"),
+                EventType.ROOM_AVATAR: (portal.handle_matrix_avatar, RoomAvatarStateEventContent, "url"),
             }[evt_type]
-            if content_key not in content:
+            if not isinstance(content, content_type):
                 return
-            await handler(sender, content[content_key])
+            await handler(sender, content[content_key], event_id)
 
     @staticmethod
-    async def handle_room_pin(room_id: MatrixRoomID, sender_mxid: MatrixUserID,
-                              new_events: Set[str], old_events: Set[str]) -> None:
+    async def handle_room_pin(room_id: RoomID, sender_mxid: UserID,
+                              new_events: Set[str], old_events: Set[str],
+                              event_id: EventID) -> None:
         portal = po.Portal.get_by_mxid(room_id)
         sender = await u.User.get_by_mxid(sender_mxid).ensure_started()
         if await sender.has_full_access(allow_bot=True) and portal:
-            events = new_events - old_events
-            if len(events) > 0:
-                # New event pinned, set that as pinned in Telegram.
-                await portal.handle_matrix_pin(sender, MatrixEventID(events.pop()))
-            elif len(new_events) == 0:
-                # All pinned events removed, remove pinned event in Telegram.
-                await portal.handle_matrix_pin(sender, None)
+            if not new_events:
+                await portal.handle_matrix_unpin_all(sender, event_id)
+            else:
+                changes = {event_id: event_id in new_events
+                           for event_id in new_events ^ old_events}
+                await portal.handle_matrix_pin(sender, changes, event_id)
 
     @staticmethod
-    async def handle_room_upgrade(room_id: MatrixRoomID, new_room_id: MatrixRoomID) -> None:
+    async def handle_room_upgrade(room_id: RoomID, sender: UserID, new_room_id: RoomID,
+                                  event_id: EventID) -> None:
         portal = po.Portal.get_by_mxid(room_id)
         if portal:
-            await portal.handle_matrix_upgrade(new_room_id)
+            await portal.handle_matrix_upgrade(sender, new_room_id, event_id)
+
+    async def handle_member_info_change(self, room_id: RoomID, user_id: UserID,
+                                        profile: MemberStateEventContent,
+                                        prev_profile: MemberStateEventContent,
+                                        event_id: EventID) -> None:
+        if profile.displayname == prev_profile.displayname:
+            return
 
-    @staticmethod
-    async def handle_name_change(room_id: MatrixRoomID, user_id: MatrixUserID, displayname: str,
-                                 prev_displayname: str, event_id: MatrixEventID) -> None:
         portal = po.Portal.get_by_mxid(room_id)
         if not portal or not portal.has_bot:
             return
 
         user = await u.User.get_by_mxid(user_id).ensure_started()
         if await user.needs_relaybot(portal):
-            await portal.name_change_matrix(user, displayname, prev_displayname, event_id)
+            await portal.name_change_matrix(user, profile.displayname, prev_profile.displayname,
+                                            event_id)
 
     @staticmethod
-    def parse_read_receipts(content: Dict) -> Dict[MatrixUserID, MatrixEventID]:
-        return {user_id: event_id
+    def parse_read_receipts(content: ReceiptEventContent) -> Iterable[Tuple[UserID, EventID]]:
+        return ((user_id, event_id)
                 for event_id, receipts in content.items()
-                for user_id in receipts.get("m.read", {})}
+                for user_id in receipts.get(ReceiptType.READ, {}))
 
     @staticmethod
-    async def handle_read_receipts(room_id: MatrixRoomID,
-                                   receipts: Dict[MatrixUserID, MatrixEventID]) -> None:
+    async def handle_read_receipts(room_id: RoomID, receipts: Iterable[Tuple[UserID, EventID]]
+                                   ) -> None:
         portal = po.Portal.get_by_mxid(room_id)
         if not portal:
             return
 
-        for user_id, event_id in receipts.items():
-            user = await u.User.get_by_mxid(user_id).ensure_started()
-            if not await user.is_logged_in():
-                continue
-            await portal.mark_read(user, event_id)
+        for user_id, event_id in receipts:
+            user = u.User.get_by_mxid(user_id, check_db=False, create=False)
+            if user and await user.is_logged_in():
+                await portal.mark_read(user, event_id)
 
     @staticmethod
-    async def handle_presence(user_id: MatrixUserID, presence: str) -> None:
-        user = await u.User.get_by_mxid(user_id).ensure_started()
-        if not await user.is_logged_in():
-            return
-        await user.set_presence(presence == "online")
+    async def handle_presence(user_id: UserID, presence: PresenceState) -> None:
+        user = u.User.get_by_mxid(user_id, check_db=False, create=False)
+        if user and await user.is_logged_in():
+            await user.set_presence(presence == PresenceState.ONLINE)
 
-    async def handle_typing(self, room_id: MatrixRoomID, now_typing: List[MatrixUserID]) -> None:
+    async def handle_typing(self, room_id: RoomID, now_typing: Set[UserID]) -> None:
         portal = po.Portal.get_by_mxid(room_id)
         if not portal:
             return
 
-        for user_id in set(self.previously_typing + now_typing):
+        previously_typing = self.previously_typing.get(room_id, set())
+
+        for user_id in set(previously_typing | now_typing):
             is_typing = user_id in now_typing
-            was_typing = user_id in self.previously_typing
+            was_typing = user_id in previously_typing
             if is_typing and was_typing:
                 continue
 
-            user = await u.User.get_by_mxid(user_id).ensure_started()
-            if not await user.is_logged_in():
-                continue
+            user = u.User.get_by_mxid(user_id, check_db=False, create=False)
+            if user and await user.is_logged_in():
+                await portal.set_typing(user, is_typing)
 
-            await portal.set_typing(user, is_typing)
+        self.previously_typing[room_id] = now_typing
 
-        self.previously_typing = now_typing
-
-    def filter_matrix_event(self, event: MatrixEvent) -> bool:
-        sender = event.get("sender", None)
-        if not sender:
+    def filter_matrix_event(self, evt: Event) -> bool:
+        if isinstance(evt, (TypingEvent, ReceiptEvent, PresenceEvent)):
             return False
-        return (sender == self.az.bot_mxid
-                or pu.Puppet.get_id_from_mxid(sender) is not None)
+        elif not isinstance(evt, (RedactionEvent, MessageEvent, StateEvent, EncryptedEvent)):
+            return True
+        if evt.content.get(self.az.real_user_content_key, False):
+            puppet = pu.Puppet.deprecated_sync_get_by_custom_mxid(evt.sender)
+            if puppet:
+                self.log.debug("Ignoring puppet-sent event %s", evt.event_id)
+                return True
+        return evt.sender and (evt.sender == self.az.bot_mxid
+                               or pu.Puppet.get_id_from_mxid(evt.sender) is not None)
 
-    async def try_handle_event(self, evt: MatrixEvent) -> None:
-        try:
-            await self.handle_event(evt)
-        except Exception:
-            self.log.exception("Error handling manually received Matrix event")
+    async def handle_ephemeral_event(self, evt: Union[ReceiptEvent, PresenceEvent, TypingEvent]
+                                     ) -> None:
+        if evt.type == EventType.RECEIPT:
+            await self.handle_read_receipts(evt.room_id, self.parse_read_receipts(evt.content))
+        elif evt.type == EventType.PRESENCE:
+            await self.handle_presence(evt.sender, evt.content.presence)
+        elif evt.type == EventType.TYPING:
+            await self.handle_typing(evt.room_id, set(evt.content.user_ids))
 
-    async def handle_event(self, evt: MatrixEvent) -> None:
-        if self.filter_matrix_event(evt):
-            return
-        self.log.debug("Received event: %s", evt)
-        evt_type = evt.get("type", "m.unknown")  # type: str
-        room_id = evt.get("room_id", None)  # type: Optional[MatrixRoomID]
-        event_id = evt.get("event_id", None)  # type: Optional[MatrixEventID]
-        sender = evt.get("sender", None)  # type: Optional[MatrixUserID]
-        content = evt.get("content", {})  # type: Dict
-        if evt_type == "m.room.member":
-            state_key = evt["state_key"]  # type: MatrixUserID
-            prev_content = evt.get("unsigned", {}).get("prev_content", {})  # type: Dict
-            membership = content.get("membership", "")  # type: str
-            prev_membership = prev_content.get("membership", "leave")  # type: str
-            if membership == prev_membership:
-                match = re.compile("@(.+):(.+)").match(state_key)  # type: Match
-                mxid = match.group(0)  # type: str
-                displayname = content.get("displayname", None) or mxid  # type: str
-                prev_displayname = prev_content.get("displayname", None) or mxid  # type: str
-                if displayname != prev_displayname:
-                    await self.handle_name_change(room_id, state_key, displayname,
-                                                  prev_displayname, event_id)
-            elif membership == "invite":
-                await self.handle_invite(room_id, state_key, sender)
-            elif prev_membership == "join" and membership == "leave":
-                await self.handle_part(room_id, state_key, sender, event_id)
-            elif membership == "join":
-                await self.handle_join(room_id, state_key, event_id)
-        elif evt_type in ("m.room.message", "m.sticker"):
-            if evt_type != "m.room.message":
-                content["msgtype"] = evt_type
-            await self.handle_message(room_id, sender, content, event_id)
-        elif evt_type == "m.room.redaction":
-            await self.handle_redaction(room_id, sender, evt["redacts"])
-        elif evt_type == "m.room.power_levels":
-            prev_content = evt.get("unsigned", {}).get("prev_content", {})
-            await self.handle_power_levels(room_id, sender, evt["content"], prev_content)
-        elif evt_type in ("m.room.name", "m.room.avatar", "m.room.topic"):
-            await self.handle_room_meta(evt_type, room_id, sender, evt["content"])
-        elif evt_type == "m.room.pinned_events":
-            new_events = set(evt["content"]["pinned"])
+    async def handle_event(self, evt: Event) -> None:
+        if evt.type == EventType.ROOM_REDACTION:
+            await self.handle_redaction(evt)
+
+    async def handle_state_event(self, evt: StateEvent) -> None:
+        if evt.type == EventType.ROOM_POWER_LEVELS:
+            await self.handle_power_levels(evt)
+        elif evt.type in (EventType.ROOM_NAME, EventType.ROOM_AVATAR, EventType.ROOM_TOPIC):
+            await self.handle_room_meta(evt.type, evt.room_id, evt.sender, evt.content,
+                                        evt.event_id)
+        elif evt.type == EventType.ROOM_PINNED_EVENTS:
+            new_events = set(evt.content.pinned)
             try:
-                old_events = set(evt["unsigned"]["prev_content"]["pinned"])
-            except KeyError:
+                old_events = set(evt.unsigned.prev_content.pinned)
+            except (KeyError, ValueError, TypeError, AttributeError):
                 old_events = set()
-            await self.handle_room_pin(room_id, sender, new_events, old_events)
-        elif evt_type == "m.room.tombstone":
-            await self.handle_room_upgrade(room_id, evt["content"]["replacement_room"])
-        elif evt_type == "m.receipt":
-            await self.handle_read_receipts(room_id, self.parse_read_receipts(content))
-        elif evt_type == "m.presence":
-            await self.handle_presence(sender, content.get("presence", "offline"))
-        elif evt_type == "m.typing":
-            await self.handle_typing(room_id, content.get("user_ids", []))
+            await self.handle_room_pin(evt.room_id, evt.sender, new_events, old_events,
+                                       evt.event_id)
+        elif evt.type == EventType.ROOM_TOMBSTONE:
+            await self.handle_room_upgrade(evt.room_id, evt.sender, evt.content.replacement_room,
+                                           evt.event_id)

mautrix_telegram/portal/__init__.py

@@ -0,0 +1,21 @@
+from .base import BasePortal, init as init_base
+from .matrix import PortalMatrix, init as init_matrix
+from .metadata import PortalMetadata, init as init_metadata
+from .telegram import PortalTelegram, init as init_telegram
+from .deduplication import init as init_dedup
+from ..context import Context
+
+
+class Portal(PortalMatrix, PortalTelegram, PortalMetadata):
+    pass
+
+
+def init(context: Context) -> None:
+    init_base(context)
+    init_dedup(context)
+    init_metadata(context)
+    init_telegram(context)
+    init_matrix(context)
+
+
+__all__ = ["Portal", "init"]

mautrix_telegram/portal/__init__.pyi

@@ -0,0 +1,15 @@
+from typing import Union
+from .base import BasePortal
+from .matrix import PortalMatrix
+from .metadata import PortalMetadata
+from .telegram import PortalTelegram
+from ..context import Context
+
+Portal = Union[BasePortal, PortalMatrix, PortalMetadata, PortalTelegram]
+
+
+def init(context: Context) -> None:
+	pass
+
+
+__all__ = ["Portal", "init"]

mautrix_telegram/portal/base.py

@@ -0,0 +1,552 @@
+# mautrix-telegram - A Matrix-Telegram puppeting bridge
+# Copyright (C) 2020 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 Awaitable, Dict, List, Optional, Tuple, Union, Any, Set, Iterable, TYPE_CHECKING
+from abc import ABC, abstractmethod
+from datetime import datetime
+import asyncio
+import logging
+import json
+
+from telethon.tl.functions.messages import ExportChatInviteRequest
+from telethon.tl.types import (Channel, ChannelFull, Chat, ChatFull, InputChannel,
+                               InputPeerChannel, InputPeerChat, InputPeerUser, InputUser,
+                               PeerChannel, PeerChat, PeerUser, TypeChat, TypeInputPeer, TypePeer,
+                               TypeUser, TypeUserFull, User, UserFull, TypeInputChannel, Photo,
+                               Document, TypePhotoSize, PhotoSize, InputPhotoFileLocation,
+                               TypeChatParticipant, TypeChannelParticipant, PhotoEmpty, ChatPhoto,
+                               ChatPhotoEmpty, PhotoSizeProgressive, PhotoSizeEmpty)
+
+from mautrix.errors import MatrixRequestError, IntentError
+from mautrix.appservice import AppService, IntentAPI
+from mautrix.types import (RoomID, RoomAlias, UserID, EventID, EventType,
+                           PowerLevelStateEventContent, ContentURI)
+from mautrix.util.simple_template import SimpleTemplate
+from mautrix.util.simple_lock import SimpleLock
+from mautrix.util.logging import TraceLogger
+from mautrix.bridge import BasePortal as MautrixBasePortal
+
+from ..types import TelegramID
+from ..context import Context
+from ..db import Portal as DBPortal, Message as DBMessage
+from .. import puppet as p, user as u, util
+from .deduplication import PortalDedup
+from .send_lock import PortalSendLock
+
+if TYPE_CHECKING:
+    from ..bot import Bot
+    from ..abstract_user import AbstractUser
+    from ..config import Config
+    from ..matrix import MatrixHandler
+    from . import Portal
+
+TypeParticipant = Union[TypeChatParticipant, TypeChannelParticipant]
+TypeChatPhoto = Union[ChatPhoto, ChatPhotoEmpty, Photo, PhotoEmpty]
+InviteList = Union[UserID, List[UserID]]
+
+config: Optional['Config'] = None
+
+
+class BasePortal(MautrixBasePortal, ABC):
+    base_log: TraceLogger = logging.getLogger("mau.portal")
+    az: AppService = None
+    bot: 'Bot' = None
+    loop: asyncio.AbstractEventLoop = None
+    matrix: 'MatrixHandler' = None
+
+    # Config cache
+    filter_mode: str = None
+    filter_list: List[str] = None
+
+    max_initial_member_sync: int = -1
+    sync_channel_members: bool = True
+    sync_matrix_state: bool = True
+    public_portals: bool = False
+    private_chat_portal_meta: bool = False
+
+    alias_template: SimpleTemplate[str]
+    hs_domain: str
+
+    # Instance cache
+    by_mxid: Dict[RoomID, 'Portal'] = {}
+    by_tgid: Dict[Tuple[TelegramID, TelegramID], 'Portal'] = {}
+
+    mxid: Optional[RoomID]
+    tgid: TelegramID
+    tg_receiver: TelegramID
+    peer_type: str
+    username: str
+    megagroup: bool
+    title: Optional[str]
+    about: Optional[str]
+    photo_id: Optional[str]
+    local_config: Dict[str, Any]
+    avatar_url: Optional[ContentURI]
+    encrypted: bool
+    deleted: bool
+    backfill_lock: SimpleLock
+    backfill_method_lock: asyncio.Lock
+    backfill_leave: Optional[Set[IntentAPI]]
+    log: TraceLogger
+
+    alias: Optional[RoomAlias]
+
+    dedup: PortalDedup
+    send_lock: PortalSendLock
+    _pin_lock: asyncio.Lock
+
+    _db_instance: DBPortal
+    _main_intent: Optional[IntentAPI]
+    _room_create_lock: asyncio.Lock
+
+    def __init__(self, tgid: TelegramID, peer_type: str, tg_receiver: Optional[TelegramID] = None,
+                 mxid: Optional[RoomID] = None, username: Optional[str] = None,
+                 megagroup: Optional[bool] = False, title: Optional[str] = None,
+                 about: Optional[str] = None, photo_id: Optional[str] = None,
+                 local_config: Optional[str] = None, avatar_url: Optional[ContentURI] = None,
+                 encrypted: Optional[bool] = False, db_instance: DBPortal = None) -> None:
+        self.mxid = mxid
+        self.tgid = tgid
+        self.tg_receiver = tg_receiver or tgid
+        self.peer_type = peer_type
+        self.username = username
+        self.megagroup = megagroup
+        self.title = title
+        self.about = about
+        self.photo_id = photo_id
+        self.local_config = json.loads(local_config or "{}")
+        self.avatar_url = avatar_url
+        self.encrypted = encrypted
+        self._db_instance = db_instance
+        self._main_intent = None
+        self.deleted = False
+        self.log = self.base_log.getChild(self.tgid_log if self.tgid else self.mxid)
+        self.backfill_lock = SimpleLock("Waiting for backfilling to finish before handling %s",
+                                        log=self.log)
+        self.backfill_method_lock = asyncio.Lock()
+        self.backfill_leave = None
+
+        self.dedup = PortalDedup(self)
+        self.send_lock = PortalSendLock()
+        self._pin_lock = asyncio.Lock()
+
+        if tgid:
+            self.by_tgid[self.tgid_full] = self
+        if mxid:
+            self.by_mxid[mxid] = self
+
+    # region Properties
+
+    @property
+    def tgid_full(self) -> Tuple[TelegramID, TelegramID]:
+        return self.tgid, self.tg_receiver
+
+    @property
+    def tgid_log(self) -> str:
+        if self.tgid == self.tg_receiver:
+            return str(self.tgid)
+        return f"{self.tg_receiver}<->{self.tgid}"
+
+    @property
+    def name(self) -> str:
+        return self.title
+
+    @property
+    def alias(self) -> Optional[RoomAlias]:
+        if not self.username:
+            return None
+        return RoomAlias(f"#{self.alias_localpart}:{self.hs_domain}")
+
+    @property
+    def alias_localpart(self) -> Optional[str]:
+        if not self.username:
+            return None
+        return self.alias_template.format(self.username)
+
+    @property
+    def peer(self) -> Union[TypePeer, TypeInputPeer]:
+        if self.peer_type == "user":
+            return PeerUser(user_id=self.tgid)
+        elif self.peer_type == "chat":
+            return PeerChat(chat_id=self.tgid)
+        elif self.peer_type == "channel":
+            return PeerChannel(channel_id=self.tgid)
+
+    @property
+    def is_direct(self) -> bool:
+        return self.peer_type == "user"
+
+    @property
+    def has_bot(self) -> bool:
+        return (bool(self.bot)
+                and (self.bot.is_in_chat(self.tgid)
+                     or (self.peer_type == "user" and self.tg_receiver == self.bot.tgid)))
+
+    @property
+    def main_intent(self) -> IntentAPI:
+        if not self._main_intent:
+            direct = self.peer_type == "user"
+            puppet = p.Puppet.get(self.tgid) if direct else None
+            self._main_intent = puppet.intent_for(self) if direct else self.az.intent
+        return self._main_intent
+
+    @property
+    def allow_bridging(self) -> bool:
+        if self.peer_type == "user":
+            return True
+        elif self.filter_mode == "whitelist":
+            return self.tgid in self.filter_list
+        elif self.filter_mode == "blacklist":
+            return self.tgid not in self.filter_list
+        return True
+
+    # endregion
+    # region Miscellaneous getters
+
+    def get_config(self, key: str) -> Any:
+        local = util.recursive_get(self.local_config, key)
+        if local is not None:
+            return local
+        return config[f"bridge.{key}"]
+
+    @staticmethod
+    def _photo_size_key(photo: TypePhotoSize) -> int:
+        if isinstance(photo, PhotoSize):
+            return photo.size
+        elif isinstance(photo, PhotoSizeProgressive):
+            return max(photo.sizes)
+        elif isinstance(photo, PhotoSizeEmpty):
+            return 0
+        else:
+            return len(photo.bytes)
+
+    @classmethod
+    def _get_largest_photo_size(cls, photo: Union[Photo, Document]
+                                ) -> Tuple[Optional[InputPhotoFileLocation],
+                                           Optional[TypePhotoSize]]:
+        if not photo or isinstance(photo, PhotoEmpty) or (isinstance(photo, Document)
+                                                          and not photo.thumbs):
+            return None, None
+
+        largest = max(photo.thumbs if isinstance(photo, Document) else photo.sizes,
+                      key=cls._photo_size_key)
+        return InputPhotoFileLocation(
+            id=photo.id,
+            access_hash=photo.access_hash,
+            file_reference=photo.file_reference,
+            thumb_size=largest.type,
+        ), largest
+
+    async def can_user_perform(self, user: 'u.User', event: str) -> bool:
+        if user.is_admin:
+            return True
+        if not self.mxid:
+            # No room for anybody to perform actions in
+            return False
+        try:
+            await self.main_intent.get_power_levels(self.mxid)
+        except MatrixRequestError:
+            return False
+        evt_type = EventType.find(f"net.maunium.telegram.{event}", t_class=EventType.Class.STATE)
+        return await self.main_intent.state_store.has_power_level(self.mxid, user.mxid, evt_type)
+
+    def get_input_entity(self, user: 'AbstractUser'
+                         ) -> Awaitable[Union[TypeInputPeer, TypeInputChannel]]:
+        return user.client.get_input_entity(self.peer)
+
+    async def get_entity(self, user: 'AbstractUser') -> TypeChat:
+        try:
+            return await user.client.get_entity(self.peer)
+        except ValueError:
+            if user.is_bot:
+                self.log.warning(f"Could not find entity with bot {user.tgid}. Failing...")
+                raise
+            self.log.warning(f"Could not find entity with user {user.tgid}. "
+                             "falling back to get_dialogs.")
+            async for dialog in user.client.iter_dialogs():
+                if dialog.entity.id == self.tgid:
+                    return dialog.entity
+            raise
+
+    async def get_invite_link(self, user: 'u.User', uses: Optional[int] = None,
+                              expire: Optional[datetime] = None) -> str:
+        if self.peer_type == "user":
+            raise ValueError("You can't invite users to private chats.")
+        if self.username:
+            return f"https://t.me/{self.username}"
+        link = await user.client(ExportChatInviteRequest(peer=await self.get_input_entity(user),
+                                                         expire_date=expire, usage_limit=uses))
+        return link.link
+
+    # endregion
+    # region Matrix room cleanup
+
+    async def get_authenticated_matrix_users(self) -> List[UserID]:
+        try:
+            members = await self.main_intent.get_room_members(self.mxid)
+        except MatrixRequestError:
+            return []
+        authenticated: List[UserID] = []
+        has_bot = self.has_bot
+        for member in members:
+            if p.Puppet.get_id_from_mxid(member) or member == self.az.bot_mxid:
+                continue
+            user = await u.User.get_by_mxid(member).ensure_started()
+            authenticated_through_bot = has_bot and user.relaybot_whitelisted
+            if authenticated_through_bot or await user.has_full_access(allow_bot=True):
+                authenticated.append(user.mxid)
+        return authenticated
+
+    async def cleanup_portal(self, message: str, puppets_only: bool = False, delete: bool = True
+                             ) -> None:
+        if self.username:
+            try:
+                await self.main_intent.remove_room_alias(self.alias_localpart)
+            except (MatrixRequestError, IntentError):
+                self.log.warning("Failed to remove alias when cleaning up room", exc_info=True)
+        await self.cleanup_room(self.main_intent, self.mxid, message, puppets_only)
+        if delete:
+            await self.delete()
+
+    # endregion
+    # region Database conversion
+
+    @property
+    def db_instance(self) -> DBPortal:
+        if not self._db_instance:
+            self._db_instance = self.new_db_instance()
+        return self._db_instance
+
+    def new_db_instance(self) -> DBPortal:
+        return DBPortal(tgid=self.tgid, tg_receiver=self.tg_receiver, peer_type=self.peer_type,
+                        mxid=self.mxid, username=self.username, megagroup=self.megagroup,
+                        title=self.title, about=self.about, photo_id=self.photo_id,
+                        config=json.dumps(self.local_config), avatar_url=self.avatar_url,
+                        encrypted=self.encrypted)
+
+    async def save(self) -> None:
+        self.db_instance.edit(mxid=self.mxid, username=self.username, title=self.title,
+                              about=self.about, photo_id=self.photo_id, megagroup=self.megagroup,
+                              config=json.dumps(self.local_config), avatar_url=self.avatar_url,
+                              encrypted=self.encrypted)
+
+    async def delete(self) -> None:
+        self.delete_sync()
+
+    def delete_sync(self) -> None:
+        try:
+            del self.by_tgid[self.tgid_full]
+        except KeyError:
+            pass
+        try:
+            del self.by_mxid[self.mxid]
+        except KeyError:
+            pass
+        if self._db_instance:
+            self._db_instance.delete()
+        DBMessage.delete_all(self.mxid)
+        self.deleted = True
+
+    @classmethod
+    def from_db(cls, db_portal: DBPortal) -> 'Portal':
+        return cls(tgid=db_portal.tgid, tg_receiver=db_portal.tg_receiver,
+                   peer_type=db_portal.peer_type, mxid=db_portal.mxid, username=db_portal.username,
+                   megagroup=db_portal.megagroup, title=db_portal.title, about=db_portal.about,
+                   photo_id=db_portal.photo_id, local_config=db_portal.config,
+                   avatar_url=db_portal.avatar_url, encrypted=db_portal.encrypted,
+                   db_instance=db_portal)
+
+    # endregion
+    # region Class instance lookup
+
+    @classmethod
+    def all(cls) -> Iterable['Portal']:
+        for db_portal in DBPortal.all():
+            try:
+                yield cls.by_tgid[(db_portal.tgid, db_portal.tg_receiver)]
+            except KeyError:
+                yield cls.from_db(db_portal)
+
+    @classmethod
+    def get_by_mxid(cls, mxid: RoomID) -> Optional['Portal']:
+        try:
+            return cls.by_mxid[mxid]
+        except KeyError:
+            pass
+
+        portal = DBPortal.get_by_mxid(mxid)
+        if portal:
+            return cls.from_db(portal)
+
+        return None
+
+    @classmethod
+    def get_username_from_mx_alias(cls, alias: str) -> Optional[str]:
+        return cls.alias_template.parse(alias)
+
+    @classmethod
+    def find_by_username(cls, username: str) -> Optional['Portal']:
+        if not username:
+            return None
+
+        username = username.lower()
+
+        for _, portal in cls.by_tgid.items():
+            if portal.username and portal.username.lower() == username:
+                return portal
+
+        dbportal = DBPortal.get_by_username(username)
+        if dbportal:
+            return cls.from_db(dbportal)
+
+        return None
+
+    @classmethod
+    def get_by_tgid(cls, tgid: TelegramID, tg_receiver: Optional[TelegramID] = None,
+                    peer_type: str = None) -> Optional['Portal']:
+        if peer_type == "user" and tg_receiver is None:
+            raise ValueError("tg_receiver is required when peer_type is \"user\"")
+        tg_receiver = tg_receiver or tgid
+        tgid_full = (tgid, tg_receiver)
+        try:
+            return cls.by_tgid[tgid_full]
+        except KeyError:
+            pass
+
+        db_portal = DBPortal.get_by_tgid(tgid, tg_receiver)
+        if db_portal:
+            return cls.from_db(db_portal)
+
+        if peer_type:
+            cls.log.info(f"Creating portal for {peer_type} {tgid} (receiver {tg_receiver})")
+            # TODO enable this for non-release builds
+            #      (or add better wrong peer type error handling)
+            # if peer_type == "chat":
+            #     import traceback
+            #     cls.log.info("Chat portal stack trace:\n" + "".join(traceback.format_stack()))
+            portal = cls(tgid, peer_type=peer_type, tg_receiver=tg_receiver)
+            portal.db_instance.insert()
+            return portal
+
+        return None
+
+    @classmethod
+    def get_by_entity(cls, entity: Union[TypeChat, TypePeer, TypeUser, TypeUserFull,
+                                         TypeInputPeer],
+                      receiver_id: Optional[TelegramID] = None, create: bool = True
+                      ) -> Optional['Portal']:
+        entity_type = type(entity)
+        if entity_type in (Chat, ChatFull):
+            type_name = "chat"
+            entity_id = entity.id
+        elif entity_type in (PeerChat, InputPeerChat):
+            type_name = "chat"
+            entity_id = entity.chat_id
+        elif entity_type in (Channel, ChannelFull):
+            type_name = "channel"
+            entity_id = entity.id
+        elif entity_type in (PeerChannel, InputPeerChannel, InputChannel):
+            type_name = "channel"
+            entity_id = entity.channel_id
+        elif entity_type in (User, UserFull):
+            type_name = "user"
+            entity_id = entity.id
+        elif entity_type in (PeerUser, InputPeerUser, InputUser):
+            type_name = "user"
+            entity_id = entity.user_id
+        else:
+            raise ValueError(f"Unknown entity type {entity_type.__name__}")
+        return cls.get_by_tgid(TelegramID(entity_id),
+                               receiver_id if type_name == "user" else entity_id,
+                               type_name if create else None)
+
+    # endregion
+    # region Abstract methods (cross-called in matrix/metadata/telegram classes)
+
+    @abstractmethod
+    async def update_matrix_room(self, user: 'AbstractUser', entity: Union[TypeChat, User],
+                                 direct: bool, puppet: p.Puppet = None,
+                                 levels: PowerLevelStateEventContent = None,
+                                 users: List[User] = None,
+                                 participants: List[TypeParticipant] = None) -> None:
+        pass
+
+    @abstractmethod
+    async def create_matrix_room(self, user: 'AbstractUser', entity: TypeChat = None,
+                                 invites: InviteList = None, update_if_exists: bool = True,
+                                 synchronous: bool = False) -> Optional[str]:
+        pass
+
+    @abstractmethod
+    async def _add_telegram_user(self, user_id: TelegramID, source: Optional['AbstractUser'] = None
+                                 ) -> None:
+        pass
+
+    @abstractmethod
+    async def _delete_telegram_user(self, user_id: TelegramID, sender: p.Puppet) -> None:
+        pass
+
+    @abstractmethod
+    async def _update_title(self, title: str, sender: Optional['p.Puppet'] = None,
+                            save: bool = False) -> bool:
+        pass
+
+    @abstractmethod
+    async def _update_avatar(self, user: 'AbstractUser', photo: Union[TypeChatPhoto],
+                             sender: Optional['p.Puppet'] = None, save: bool = False) -> bool:
+        pass
+
+    @abstractmethod
+    def _migrate_and_save_telegram(self, new_id: TelegramID) -> None:
+        pass
+
+    @abstractmethod
+    async def update_bridge_info(self) -> None:
+        pass
+
+    @abstractmethod
+    def handle_matrix_power_levels(self, sender: 'u.User', new_levels: Dict[UserID, int],
+                                   old_levels: Dict[UserID, int], event_id: Optional[EventID]
+                                   ) -> Awaitable[None]:
+        pass
+
+    @abstractmethod
+    def backfill(self, source: 'AbstractUser', is_initial: bool = False,
+                 limit: Optional[int] = None, last_id: Optional[int] = None) -> Awaitable[None]:
+        pass
+
+    @abstractmethod
+    async def _send_delivery_receipt(self, event_id: EventID, room_id: Optional[RoomID] = None
+                                     ) -> None:
+        pass
+
+    # endregion
+
+
+def init(context: Context) -> None:
+    global config
+    BasePortal.az, config, BasePortal.loop, BasePortal.bot = context.core
+    BasePortal.matrix = context.mx
+    MautrixBasePortal.bridge = context.bridge
+    BasePortal.max_initial_member_sync = config["bridge.max_initial_member_sync"]
+    BasePortal.sync_channel_members = config["bridge.sync_channel_members"]
+    BasePortal.sync_matrix_state = config["bridge.sync_matrix_state"]
+    BasePortal.public_portals = config["bridge.public_portals"]
+    BasePortal.private_chat_portal_meta = config["bridge.private_chat_portal_meta"]
+    BasePortal.filter_mode = config["bridge.filter.mode"]
+    BasePortal.filter_list = config["bridge.filter.list"]
+    BasePortal.hs_domain = config["homeserver.domain"]
+    BasePortal.alias_template = SimpleTemplate(config["bridge.alias_template"], "groupname",
+                                               prefix="#", suffix=f":{BasePortal.hs_domain}")

mautrix_telegram/portal/deduplication.py

@@ -0,0 +1,133 @@
+# 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, Deque, Dict, Tuple, TYPE_CHECKING
+from collections import deque
+import hashlib
+
+from telethon.tl.patched import Message, MessageService
+from telethon.tl.types import (MessageMediaContact, MessageMediaDocument, MessageMediaGeo,
+                               MessageMediaPhoto, TypeMessage, TypeUpdates, UpdateNewMessage,
+                               UpdateNewChannelMessage)
+
+from mautrix.types import EventID
+
+from ..context import Context
+from ..types import TelegramID
+
+if TYPE_CHECKING:
+    from .base import BasePortal
+
+DedupMXID = Tuple[EventID, TelegramID]
+
+
+class PortalDedup:
+    pre_db_check: bool = False
+    cache_queue_length: int = 20
+
+    _dedup: Deque[str]
+    _dedup_mxid: Dict[str, DedupMXID]
+    _dedup_action: Deque[str]
+    _portal: 'BasePortal'
+
+    def __init__(self, portal: 'BasePortal') -> None:
+        self._dedup = deque()
+        self._dedup_mxid = {}
+        self._dedup_action = deque()
+        self._portal = portal
+
+    @property
+    def _always_force_hash(self) -> bool:
+        return self._portal.peer_type == 'chat'
+
+    @staticmethod
+    def _hash_event(event: TypeMessage) -> str:
+        # Non-channel messages are unique per-user (wtf telegram), so we have no other choice than
+        # to deduplicate based on a hash of the message content.
+
+        # The timestamp is only accurate to the second, so we can't rely solely on that either.
+        if isinstance(event, MessageService):
+            hash_content = [event.date.timestamp(), event.from_id, event.action]
+        else:
+            hash_content = [event.date.timestamp(), event.message.strip()]
+            if event.fwd_from:
+                hash_content += [event.fwd_from.from_id]
+            elif isinstance(event, Message) and event.media:
+                try:
+                    hash_content += {
+                        MessageMediaContact: lambda media: [media.user_id],
+                        MessageMediaDocument: lambda media: [media.document.id],
+                        MessageMediaPhoto: lambda media: [media.photo.id if media.photo else 0],
+                        MessageMediaGeo: lambda media: [media.geo.long, media.geo.lat],
+                    }[type(event.media)](event.media)
+                except KeyError:
+                    pass
+        return hashlib.md5("-"
+                           .join(str(a) for a in hash_content)
+                           .encode("utf-8")
+                           ).hexdigest()
+
+    def check_action(self, event: TypeMessage) -> bool:
+        evt_hash = self._hash_event(event) if self._always_force_hash else event.id
+        if evt_hash in self._dedup_action:
+            return True
+
+        self._dedup_action.append(evt_hash)
+
+        if len(self._dedup_action) > self.cache_queue_length:
+            self._dedup_action.popleft()
+        return False
+
+    def update(self, event: TypeMessage, mxid: DedupMXID = None,
+               expected_mxid: Optional[DedupMXID] = None, force_hash: bool = False
+               ) -> Optional[DedupMXID]:
+        evt_hash = self._hash_event(event) if self._always_force_hash or force_hash else event.id
+        try:
+            found_mxid = self._dedup_mxid[evt_hash]
+        except KeyError:
+            return EventID("None"), TelegramID(0)
+
+        if found_mxid != expected_mxid:
+            return found_mxid
+        self._dedup_mxid[evt_hash] = mxid
+        return None
+
+    def check(self, event: TypeMessage, mxid: DedupMXID = None, force_hash: bool = False
+              ) -> Optional[DedupMXID]:
+        evt_hash = (self._hash_event(event)
+                    if self._always_force_hash or force_hash
+                    else event.id)
+        if evt_hash in self._dedup:
+            return self._dedup_mxid[evt_hash]
+
+        self._dedup_mxid[evt_hash] = mxid
+        self._dedup.append(evt_hash)
+
+        if len(self._dedup) > self.cache_queue_length:
+            del self._dedup_mxid[self._dedup.popleft()]
+        return None
+
+    def register_outgoing_actions(self, response: TypeUpdates) -> None:
+        for update in response.updates:
+            check_dedup = (isinstance(update, (UpdateNewMessage, UpdateNewChannelMessage))
+                           and isinstance(update.message, MessageService))
+            if check_dedup:
+                self.check(update.message)
+
+
+def init(context: Context) -> None:
+    cfg = context.config
+    PortalDedup.dedup_pre_db_check = cfg["bridge.deduplication.pre_db_check"]
+    PortalDedup.dedup_cache_queue_length = cfg["bridge.deduplication.cache_queue_length"]

mautrix_telegram/portal/matrix.py

@@ -0,0 +1,600 @@
+# mautrix-telegram - A Matrix-Telegram puppeting bridge
+# Copyright (C) 2020 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 Awaitable, Dict, Optional, Union, Any, TYPE_CHECKING
+from html import escape as escape_html
+from string import Template
+from abc import ABC
+
+import magic
+
+from telethon.tl.functions.messages import (EditChatPhotoRequest, EditChatTitleRequest,
+                                            UpdatePinnedMessageRequest, SetTypingRequest,
+                                            EditChatAboutRequest, UnpinAllMessagesRequest)
+from telethon.tl.functions.channels import EditPhotoRequest, EditTitleRequest, JoinChannelRequest
+from telethon.errors import (ChatNotModifiedError, PhotoExtInvalidError, MessageIdInvalidError,
+                             PhotoInvalidDimensionsError, PhotoSaveFileInvalidError, RPCError)
+from telethon.tl.patched import Message, MessageService
+from telethon.tl.types import (DocumentAttributeFilename, DocumentAttributeImageSize, GeoPoint,
+                               InputChatUploadedPhoto, MessageActionChatEditPhoto, MessageMediaGeo,
+                               SendMessageCancelAction, SendMessageTypingAction, TypeInputPeer,
+                               UpdateNewMessage, InputMediaUploadedDocument,
+                               InputMediaUploadedPhoto)
+
+from mautrix.types import (EventID, RoomID, UserID, ContentURI, MessageType, MessageEventContent,
+                           TextMessageEventContent, MediaMessageEventContent, Format,
+                           LocationMessageEventContent, ImageInfo, VideoInfo)
+
+from ..types import TelegramID
+from ..db import Message as DBMessage
+from ..util import sane_mimetypes, parallel_transfer_to_telegram
+from ..context import Context
+from .. import puppet as p, user as u, formatter, util
+from .base import BasePortal
+
+if TYPE_CHECKING:
+    from ..abstract_user import AbstractUser
+    from ..tgclient import MautrixTelegramClient
+    from ..config import Config
+
+try:
+    from mautrix.crypto.attachments import decrypt_attachment
+except ImportError:
+    decrypt_attachment = None
+
+TypeMessage = Union[Message, MessageService]
+
+config: Optional['Config'] = None
+
+
+class PortalMatrix(BasePortal, ABC):
+    async def _get_state_change_message(self, event: str, user: 'u.User', **kwargs: Any
+                                        ) -> Optional[str]:
+        tpl = self.get_config(f"state_event_formats.{event}")
+        if len(tpl) == 0:
+            # Empty format means they don't want the message
+            return None
+        displayname = await self.get_displayname(user)
+
+        tpl_args = {
+            "mxid": user.mxid,
+            "username": user.mxid_localpart,
+            "displayname": escape_html(displayname),
+            **kwargs,
+        }
+        return Template(tpl).safe_substitute(tpl_args)
+
+    async def _send_state_change_message(self, event: str, user: 'u.User', event_id: EventID,
+                                         **kwargs: Any) -> None:
+        if not self.has_bot:
+            return
+        elif self.peer_type == "user" and not config["bridge.relaybot.private_chat.state_changes"]:
+            return
+        async with self.send_lock(self.bot.tgid):
+            message = await self._get_state_change_message(event, user, **kwargs)
+            if not message:
+                return
+            message, entities = await formatter.matrix_to_telegram(self.bot.client, html=message)
+            response = await self.bot.client.send_message(self.peer, message,
+                                                          formatting_entities=entities)
+            space = self.tgid if self.peer_type == "channel" else self.bot.tgid
+            self.dedup.check(response, (event_id, space))
+
+    async def name_change_matrix(self, user: 'u.User', displayname: str, prev_displayname: str,
+                                 event_id: EventID) -> None:
+        await self._send_state_change_message("name_change", user, event_id,
+                                              displayname=displayname,
+                                              prev_displayname=prev_displayname)
+
+    async def get_displayname(self, user: 'u.User') -> str:
+        return await self.main_intent.get_room_displayname(self.mxid, user.mxid) or user.mxid
+
+    def set_typing(self, user: 'u.User', typing: bool = True,
+                   action: type = SendMessageTypingAction) -> Awaitable[bool]:
+        return user.client(SetTypingRequest(
+            self.peer, action() if typing else SendMessageCancelAction()))
+
+    async def mark_read(self, user: 'u.User', event_id: EventID) -> None:
+        if user.is_bot:
+            return
+        space = self.tgid if self.peer_type == "channel" else user.tgid
+        message = DBMessage.get_by_mxid(event_id, self.mxid, space)
+        if not message:
+            message = DBMessage.find_last(self.mxid, space)
+            if not message:
+                self.log.debug(f"Dropping Matrix read receipt from {user.mxid}: "
+                               f"target message {event_id} not known and last message"
+                               " in chat not found")
+                return
+            else:
+                self.log.debug(f"Matrix read receipt target {event_id} not known, marking "
+                               f"messages up to most recent ({message.mxid}/{message.tgid}) "
+                               f"as read by {user.mxid}/{user.tgid}")
+        else:
+            self.log.debug("Handling Matrix read receipt: marking messages up to "
+                           f"{message.mxid}/{message.tgid} as read by {user.mxid}/{user.tgid}")
+        await user.client.send_read_acknowledge(self.peer, max_id=message.tgid,
+                                                clear_mentions=True)
+
+    async def _preproc_kick_ban(self, user: Union['u.User', 'p.Puppet'], source: 'u.User'
+                                ) -> Optional['AbstractUser']:
+        if user.tgid == source.tgid:
+            return None
+        if self.peer_type == "user" and user.tgid == self.tgid:
+            await self.delete()
+            return None
+        if isinstance(user, u.User) and await user.needs_relaybot(self):
+            if not self.bot:
+                return None
+            # TODO kick message
+            return None
+        if await source.needs_relaybot(self):
+            if not self.has_bot:
+                return None
+            return self.bot
+        return source
+
+    async def kick_matrix(self, user: Union['u.User', 'p.Puppet'], source: 'u.User') -> None:
+        source = await self._preproc_kick_ban(user, source)
+        if source is not None:
+            await source.client.kick_participant(self.peer, user.peer)
+
+    async def ban_matrix(self, user: Union['u.User', 'p.Puppet'], source: 'u.User'):
+        source = await self._preproc_kick_ban(user, source)
+        if source is not None:
+            await source.client.edit_permissions(self.peer, user.peer, view_messages=False)
+
+    async def leave_matrix(self, user: 'u.User', event_id: EventID) -> None:
+        if await user.needs_relaybot(self):
+            await self._send_state_change_message("leave", user, event_id)
+            return
+
+        if self.peer_type == "user":
+            await self.main_intent.leave_room(self.mxid)
+            await self.delete()
+            try:
+                del self.by_tgid[self.tgid_full]
+                del self.by_mxid[self.mxid]
+            except KeyError:
+                pass
+        else:
+            await user.client.delete_dialog(self.peer)
+
+    async def join_matrix(self, user: 'u.User', event_id: EventID) -> None:
+        if await user.needs_relaybot(self):
+            await self._send_state_change_message("join", user, event_id)
+            return
+
+        if self.peer_type == "channel" and not user.is_bot:
+            await user.client(JoinChannelRequest(channel=await self.get_input_entity(user)))
+        else:
+            # We'll just assume the user is already in the chat.
+            pass
+
+    async def _apply_msg_format(self, sender: 'u.User', content: MessageEventContent
+                                ) -> None:
+        if not isinstance(content, TextMessageEventContent) or content.format != Format.HTML:
+            content.format = Format.HTML
+            content.formatted_body = escape_html(content.body).replace("\n", "<br/>")
+
+        tpl = (self.get_config(f"message_formats.[{content.msgtype.value}]")
+               or "<b>$sender_displayname</b>: $message")
+        displayname = await self.get_displayname(sender)
+        tpl_args = dict(sender_mxid=sender.mxid,
+                        sender_username=sender.mxid_localpart,
+                        sender_displayname=escape_html(displayname),
+                        message=content.formatted_body,
+                        body=content.body, formatted_body=content.formatted_body)
+        content.formatted_body = Template(tpl).safe_substitute(tpl_args)
+
+    async def _apply_emote_format(self, sender: 'u.User',
+                                  content: TextMessageEventContent) -> None:
+        if content.format != Format.HTML:
+            content.format = Format.HTML
+            content.formatted_body = escape_html(content.body).replace("\n", "<br/>")
+
+        tpl = self.get_config("emote_format")
+        puppet = p.Puppet.get(sender.tgid)
+        content.formatted_body = Template(tpl).safe_substitute(
+            dict(sender_mxid=sender.mxid,
+                 sender_username=sender.mxid_localpart,
+                 sender_displayname=escape_html(await self.get_displayname(sender)),
+                 mention=f"<a href='https://matrix.to/#/{puppet.mxid}'>{puppet.displayname}</a>",
+                 username=sender.username,
+                 displayname=puppet.displayname,
+                 body=content.body,
+                 formatted_body=content.formatted_body))
+        content.msgtype = MessageType.TEXT
+
+    async def _pre_process_matrix_message(self, sender: 'u.User', use_relaybot: bool,
+                                          content: MessageEventContent) -> None:
+        if use_relaybot:
+            await self._apply_msg_format(sender, content)
+        elif content.msgtype == MessageType.EMOTE:
+            await self._apply_emote_format(sender, content)
+
+    async def _handle_matrix_text(self, sender_id: TelegramID, event_id: EventID,
+                                  space: TelegramID, client: 'MautrixTelegramClient',
+                                  content: TextMessageEventContent, reply_to: TelegramID) -> None:
+        message, entities = await formatter.matrix_to_telegram(client, text=content.body,
+                                                               html=content.formatted(Format.HTML))
+        async with self.send_lock(sender_id):
+            lp = self.get_config("telegram_link_preview")
+            if content.get_edit():
+                orig_msg = DBMessage.get_by_mxid(content.get_edit(), self.mxid, space)
+                if orig_msg:
+                    response = await client.edit_message(self.peer, orig_msg.tgid, message,
+                                                         formatting_entities=entities,
+                                                         link_preview=lp)
+                    self._add_telegram_message_to_db(event_id, space, -1, response)
+                    return
+            response = await client.send_message(self.peer, message, reply_to=reply_to,
+                                                 formatting_entities=entities,
+                                                 link_preview=lp)
+            self._add_telegram_message_to_db(event_id, space, 0, response)
+        await self._send_delivery_receipt(event_id)
+
+    async def _handle_matrix_file(self, sender_id: TelegramID, event_id: EventID,
+                                  space: TelegramID, client: 'MautrixTelegramClient',
+                                  content: MediaMessageEventContent, reply_to: TelegramID,
+                                  caption: TextMessageEventContent = None) -> None:
+        mime = content.info.mimetype
+        if isinstance(content.info, (ImageInfo, VideoInfo)):
+            w, h = content.info.width, content.info.height
+        else:
+            w = h = None
+        file_name = content["net.maunium.telegram.internal.filename"]
+        max_image_size = config["bridge.image_as_file_size"] * 1000 ** 2
+
+        if config["bridge.parallel_file_transfer"] and content.url:
+            file_handle, file_size = await parallel_transfer_to_telegram(client, self.main_intent,
+                                                                         content.url, sender_id)
+        else:
+            if content.file:
+                if not decrypt_attachment:
+                    self.log.warning(f"Can't bridge encrypted media event {event_id}:"
+                                     " matrix-nio not installed")
+                    return
+                file = await self.main_intent.download_media(content.file.url)
+                file = decrypt_attachment(file, content.file.key.key,
+                                          content.file.hashes.get("sha256"), content.file.iv)
+            else:
+                file = await self.main_intent.download_media(content.url)
+
+            if content.msgtype == MessageType.STICKER:
+                if mime != "image/gif":
+                    mime, file, w, h = util.convert_image(file, source_mime=mime,
+                                                          target_type="webp")
+                else:
+                    # Remove sticker description
+                    file_name = "sticker.gif"
+
+            file_handle = await client.upload_file(file)
+            file_size = len(file)
+
+        file_handle.name = file_name
+
+        attributes = [DocumentAttributeFilename(file_name=file_name)]
+        if w and h:
+            attributes.append(DocumentAttributeImageSize(w, h))
+
+        if (mime == "image/png" or mime == "image/jpeg") and file_size < max_image_size:
+            media = InputMediaUploadedPhoto(file_handle)
+        else:
+            media = InputMediaUploadedDocument(file=file_handle, attributes=attributes,
+                                               mime_type=mime or "application/octet-stream")
+
+        capt, entities = (await formatter.matrix_to_telegram(client, text=caption.body,
+                                                             html=caption.formatted(Format.HTML))
+                          if caption else (None, None))
+
+        async with self.send_lock(sender_id):
+            if await self._matrix_document_edit(client, content, space, capt, media, event_id):
+                return
+            try:
+                response = await client.send_media(self.peer, media, reply_to=reply_to,
+                                                   caption=capt, entities=entities)
+            except (PhotoInvalidDimensionsError, PhotoSaveFileInvalidError, PhotoExtInvalidError):
+                media = InputMediaUploadedDocument(file=media.file, mime_type=mime,
+                                                   attributes=attributes)
+                response = await client.send_media(self.peer, media, reply_to=reply_to,
+                                                   caption=capt, entities=entities)
+            self._add_telegram_message_to_db(event_id, space, 0, response)
+        await self._send_delivery_receipt(event_id)
+
+    async def _matrix_document_edit(self, client: 'MautrixTelegramClient',
+                                    content: MessageEventContent, space: TelegramID,
+                                    caption: str, media: Any, event_id: EventID) -> bool:
+        if content.get_edit():
+            orig_msg = DBMessage.get_by_mxid(content.get_edit(), self.mxid, space)
+            if orig_msg:
+                response = await client.edit_message(self.peer, orig_msg.tgid,
+                                                     caption, file=media)
+                self._add_telegram_message_to_db(event_id, space, -1, response)
+                await self._send_delivery_receipt(event_id)
+                return True
+        return False
+
+    async def _handle_matrix_location(self, sender_id: TelegramID, event_id: EventID,
+                                      space: TelegramID, client: 'MautrixTelegramClient',
+                                      content: LocationMessageEventContent, reply_to: TelegramID
+                                      ) -> None:
+        try:
+            lat, long = content.geo_uri[len("geo:"):].split(",")
+            lat, long = float(lat), float(long)
+        except (KeyError, ValueError):
+            self.log.exception("Failed to parse location")
+            return None
+        caption, entities = await formatter.matrix_to_telegram(client, text=content.body)
+        media = MessageMediaGeo(geo=GeoPoint(lat=lat, long=long, access_hash=0))
+
+        async with self.send_lock(sender_id):
+            if await self._matrix_document_edit(client, content, space, caption, media, event_id):
+                return
+            response = await client.send_media(self.peer, media, reply_to=reply_to,
+                                               caption=caption, entities=entities)
+            self._add_telegram_message_to_db(event_id, space, 0, response)
+        await self._send_delivery_receipt(event_id)
+
+    def _add_telegram_message_to_db(self, event_id: EventID, space: TelegramID,
+                                    edit_index: int, response: TypeMessage) -> None:
+        self.log.trace("Handled Matrix message: %s", response)
+        self.dedup.check(response, (event_id, space), force_hash=edit_index != 0)
+        if edit_index < 0:
+            prev_edit = DBMessage.get_one_by_tgid(TelegramID(response.id), space, -1)
+            edit_index = prev_edit.edit_index + 1
+        DBMessage(
+            tgid=TelegramID(response.id),
+            tg_space=space,
+            mx_room=self.mxid,
+            mxid=event_id,
+            edit_index=edit_index).insert()
+
+    async def _send_bridge_error(self, msg: str) -> None:
+        if config["bridge.delivery_error_reports"]:
+            await self._send_message(self.main_intent,
+                                     TextMessageEventContent(msgtype=MessageType.NOTICE, body=msg))
+
+    async def handle_matrix_message(self, sender: 'u.User', content: MessageEventContent,
+                                    event_id: EventID) -> None:
+        try:
+            await self._handle_matrix_message(sender, content, event_id)
+        except RPCError as e:
+            if config["bridge.delivery_error_reports"]:
+                await self._send_bridge_error(
+                    f"\u26a0 Your message may not have been bridged: {e}")
+            raise
+
+    async def _handle_matrix_message(self, sender: 'u.User', content: MessageEventContent,
+                                     event_id: EventID) -> None:
+        if not content.body or not content.msgtype:
+            self.log.debug(f"Ignoring message {event_id} in {self.mxid} without body or msgtype")
+            return
+
+        logged_in = not await sender.needs_relaybot(self)
+        client = sender.client if logged_in else self.bot.client
+        sender_id = sender.tgid if logged_in else self.bot.tgid
+        space = (self.tgid if self.peer_type == "channel"  # Channels have their own ID space
+                 else (sender.tgid if logged_in else self.bot.tgid))
+        reply_to = formatter.matrix_reply_to_telegram(content, space, room_id=self.mxid)
+
+        media = (MessageType.STICKER, MessageType.IMAGE, MessageType.FILE, MessageType.AUDIO,
+                 MessageType.VIDEO)
+
+        if content.msgtype == MessageType.NOTICE:
+            bridge_notices = self.get_config("bridge_notices.default")
+            excepted = sender.mxid in self.get_config("bridge_notices.exceptions")
+            if not bridge_notices and not excepted:
+                return
+
+        if content.msgtype in (MessageType.TEXT, MessageType.EMOTE, MessageType.NOTICE):
+            await self._pre_process_matrix_message(sender, not logged_in, content)
+            await self._handle_matrix_text(sender_id, event_id, space, client, content, reply_to)
+        elif content.msgtype == MessageType.LOCATION:
+            await self._pre_process_matrix_message(sender, not logged_in, content)
+            await self._handle_matrix_location(sender_id, event_id, space, client, content,
+                                               reply_to)
+        elif content.msgtype in media:
+            content["net.maunium.telegram.internal.filename"] = content.body
+            try:
+                caption_content: MessageEventContent = sender.command_status["caption"]
+                reply_to = reply_to or formatter.matrix_reply_to_telegram(caption_content, space,
+                                                                          room_id=self.mxid)
+                sender.command_status = None
+            except (KeyError, TypeError):
+                caption_content = None if logged_in else TextMessageEventContent(body=content.body)
+            if caption_content:
+                caption_content.msgtype = content.msgtype
+                await self._pre_process_matrix_message(sender, not logged_in, caption_content)
+            await self._handle_matrix_file(sender_id, event_id, space, client, content, reply_to,
+                                           caption_content)
+        else:
+            self.log.trace("Unhandled Matrix event: %s", content)
+
+    async def handle_matrix_unpin_all(self, sender: 'u.User', pin_event_id: EventID) -> None:
+        await sender.client(UnpinAllMessagesRequest(peer=self.peer))
+        await self._send_delivery_receipt(pin_event_id)
+
+    async def handle_matrix_pin(self, sender: 'u.User', changes: Dict[EventID, bool],
+                                pin_event_id: EventID) -> None:
+        tg_space = self.tgid if self.peer_type == "channel" else sender.tgid
+        ids = {msg.mxid: msg.tgid
+               for msg in DBMessage.get_by_mxids(list(changes.keys()),
+                                                 mx_room=self.mxid, tg_space=tg_space)}
+        for event_id, pinned in changes.items():
+            try:
+                await sender.client(UpdatePinnedMessageRequest(peer=self.peer, id=ids[event_id],
+                                                               unpin=not pinned))
+            except (ChatNotModifiedError, MessageIdInvalidError, KeyError):
+                pass
+        await self._send_delivery_receipt(pin_event_id)
+
+    async def handle_matrix_deletion(self, deleter: 'u.User', event_id: EventID,
+                                     redaction_event_id: EventID) -> None:
+        real_deleter = deleter if not await deleter.needs_relaybot(self) else self.bot
+        space = self.tgid if self.peer_type == "channel" else real_deleter.tgid
+        message = DBMessage.get_by_mxid(event_id, self.mxid, space)
+        if not message:
+            self.log.trace(f"Ignoring Matrix redaction of unknown event {event_id}")
+        elif message.redacted:
+            self.log.debug("Ignoring Matrix redaction of already redacted event "
+                           f"{message.mxid} in {message.mx_room}")
+        elif message.edit_index != 0:
+            message.edit(redacted=True)
+            self.log.debug("Ignoring Matrix redaction of edit event "
+                           f"{message.mxid} in {message.mx_room}")
+        else:
+            message.edit(redacted=True)
+            await real_deleter.client.delete_messages(self.peer, [message.tgid])
+            await self._send_delivery_receipt(redaction_event_id)
+
+    async def _update_telegram_power_level(self, sender: 'u.User', user_id: TelegramID,
+                                           level: int) -> None:
+        moderator = level >= 50
+        admin = level >= 75
+        await sender.client.edit_admin(self.peer, user_id,
+                                       change_info=moderator, post_messages=moderator,
+                                       edit_messages=moderator, delete_messages=moderator,
+                                       ban_users=moderator, invite_users=moderator,
+                                       pin_messages=moderator, add_admins=admin)
+
+    async def handle_matrix_power_levels(self, sender: 'u.User', new_users: Dict[UserID, int],
+                                         old_users: Dict[UserID, int], event_id: Optional[EventID]
+                                         ) -> None:
+        # TODO handle all power level changes and bridge exact admin rights to supergroups/channels
+        for user, level in new_users.items():
+            if not user or user == self.main_intent.mxid or user == sender.mxid:
+                continue
+            user_id = p.Puppet.get_id_from_mxid(user)
+            if not user_id:
+                mx_user = u.User.get_by_mxid(user, create=False)
+                if not mx_user or not mx_user.tgid:
+                    continue
+                user_id = mx_user.tgid
+            if not user_id or user_id == sender.tgid:
+                continue
+            if user not in old_users or level != old_users[user]:
+                await self._update_telegram_power_level(sender, user_id, level)
+
+    async def handle_matrix_about(self, sender: 'u.User', about: str, event_id: EventID) -> None:
+        if self.peer_type not in ("chat", "channel"):
+            return
+        peer = await self.get_input_entity(sender)
+        await sender.client(EditChatAboutRequest(peer=peer, about=about))
+        self.about = about
+        await self.save()
+        await self._send_delivery_receipt(event_id)
+
+    async def handle_matrix_title(self, sender: 'u.User', title: str, event_id: EventID) -> None:
+        if self.peer_type not in ("chat", "channel"):
+            return
+
+        if self.peer_type == "chat":
+            response = await sender.client(EditChatTitleRequest(chat_id=self.tgid, title=title))
+        else:
+            channel = await self.get_input_entity(sender)
+            response = await sender.client(EditTitleRequest(channel=channel, title=title))
+        self.dedup.register_outgoing_actions(response)
+        self.title = title
+        await self.save()
+        await self._send_delivery_receipt(event_id)
+        await self.update_bridge_info()
+
+    async def handle_matrix_avatar(self, sender: 'u.User', url: ContentURI, event_id: EventID
+                                   ) -> None:
+        if self.peer_type not in ("chat", "channel"):
+            # Invalid peer type
+            return
+        elif self.avatar_url == url:
+            return
+
+        self.avatar_url = url
+        file = await self.main_intent.download_media(url)
+        mime = magic.from_buffer(file, mime=True)
+        ext = sane_mimetypes.guess_extension(mime)
+        uploaded = await sender.client.upload_file(file, file_name=f"avatar{ext}")
+        photo = InputChatUploadedPhoto(file=uploaded)
+
+        if self.peer_type == "chat":
+            response = await sender.client(EditChatPhotoRequest(chat_id=self.tgid, photo=photo))
+        else:
+            channel = await self.get_input_entity(sender)
+            response = await sender.client(EditPhotoRequest(channel=channel, photo=photo))
+        self.dedup.register_outgoing_actions(response)
+        for update in response.updates:
+            is_photo_update = (isinstance(update, UpdateNewMessage)
+                               and isinstance(update.message, MessageService)
+                               and isinstance(update.message.action, MessageActionChatEditPhoto))
+            if is_photo_update:
+                loc, size = self._get_largest_photo_size(update.message.action.photo)
+                self.photo_id = f"{size.location.volume_id}-{size.location.local_id}"
+                await self.save()
+                break
+        await self._send_delivery_receipt(event_id)
+        await self.update_bridge_info()
+
+    async def handle_matrix_upgrade(self, sender: UserID, new_room: RoomID, event_id: EventID
+                                    ) -> None:
+        _, server = self.main_intent.parse_user_id(sender)
+        old_room = self.mxid
+        self.migrate_and_save_matrix(new_room)
+        await self.main_intent.join_room(new_room, servers=[server])
+        entity: Optional[TypeInputPeer] = None
+        user: Optional[AbstractUser] = None
+        if self.bot and self.has_bot:
+            user = self.bot
+            entity = await self.get_input_entity(self.bot)
+        if not entity:
+            user_mxids = await self.main_intent.get_room_members(self.mxid)
+            for user_str in user_mxids:
+                user_id = UserID(user_str)
+                if user_id == self.az.bot_mxid:
+                    continue
+                user = u.User.get_by_mxid(user_id, create=False)
+                if user and user.tgid:
+                    entity = await self.get_input_entity(user)
+                    if entity:
+                        break
+        if not entity:
+            self.log.error("Failed to fully migrate to upgraded Matrix room: "
+                           "no Telegram user found.")
+            return
+        await self.update_matrix_room(user, entity, direct=self.peer_type == "user")
+        self.log.info(f"{sender} upgraded room from {old_room} to {self.mxid}")
+        await self._send_delivery_receipt(event_id, room_id=old_room)
+
+    def migrate_and_save_matrix(self, new_id: RoomID) -> None:
+        try:
+            del self.by_mxid[self.mxid]
+        except KeyError:
+            pass
+        self.mxid = new_id
+        self.db_instance.edit(mxid=self.mxid)
+        self.by_mxid[self.mxid] = self
+
+    async def enable_dm_encryption(self) -> bool:
+        ok = await super().enable_dm_encryption()
+        if ok:
+            try:
+                puppet = p.Puppet.get(self.tgid)
+                await self.main_intent.set_room_name(self.mxid, puppet.displayname)
+            except Exception:
+                self.log.warning(f"Failed to set room name", exc_info=True)
+        return ok
+
+
+def init(context: Context) -> None:
+    global config
+    config = context.config

mautrix_telegram/portal/metadata.py

@@ -0,0 +1,860 @@
+# mautrix-telegram - A Matrix-Telegram puppeting bridge
+# Copyright (C) 2020 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 List, Optional, Iterable, Union, Dict, Any, Tuple, TYPE_CHECKING
+from abc import ABC
+import asyncio
+
+from telethon.tl.functions.messages import (AddChatUserRequest, CreateChatRequest,
+                                            GetFullChatRequest, MigrateChatRequest)
+from telethon.tl.functions.channels import (CreateChannelRequest, GetParticipantsRequest,
+                                            InviteToChannelRequest, UpdateUsernameRequest)
+from telethon.errors import ChatAdminRequiredError
+from telethon.tl.types import (
+    Channel, ChatBannedRights, ChannelParticipantsRecent, ChannelParticipantsSearch, ChatPhoto,
+    PhotoEmpty, InputChannel, InputUser, ChatPhotoEmpty, PeerUser, Photo, TypeChat, TypeInputPeer,
+    TypeUser, User, InputPeerPhotoFileLocation, ChatParticipantAdmin, ChannelParticipantAdmin,
+    ChatParticipantCreator, ChannelParticipantCreator, UserProfilePhoto, UserProfilePhotoEmpty,
+    InputPeerUser)
+
+from mautrix.errors import MForbidden
+from mautrix.types import (RoomID, UserID, RoomCreatePreset, EventType, Membership,
+                           PowerLevelStateEventContent, RoomTopicStateEventContent,
+                           RoomNameStateEventContent, RoomAvatarStateEventContent,
+                           StateEventContent, EventID)
+
+from ..types import TelegramID
+from ..context import Context
+from .. import puppet as p, user as u, util
+from .base import BasePortal, InviteList, TypeParticipant, TypeChatPhoto
+
+if TYPE_CHECKING:
+    from ..abstract_user import AbstractUser
+    from ..config import Config
+
+config: Optional['Config'] = None
+
+StateBridge = EventType.find("m.bridge", EventType.Class.STATE)
+StateHalfShotBridge = EventType.find("uk.half-shot.bridge", EventType.Class.STATE)
+
+
+class PortalMetadata(BasePortal, ABC):
+    _room_create_lock: asyncio.Lock
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._room_create_lock = asyncio.Lock()
+
+    # region Matrix -> Telegram
+
+    async def get_telegram_users_in_matrix_room(self, source: 'u.User'
+                                                ) -> Tuple[List[InputPeerUser], List[UserID]]:
+        user_tgids = {}
+        user_mxids = await self.main_intent.get_room_members(self.mxid, (Membership.JOIN,
+                                                                         Membership.INVITE))
+        for mxid in user_mxids:
+            if mxid == self.az.bot_mxid:
+                continue
+            mx_user = u.User.get_by_mxid(mxid, create=False)
+            if mx_user and mx_user.tgid:
+                user_tgids[mx_user.tgid] = mxid
+            puppet_id = p.Puppet.get_id_from_mxid(mxid)
+            if puppet_id:
+                user_tgids[puppet_id] = mxid
+        input_users = []
+        errors = []
+        for tgid, mxid in user_tgids.items():
+            try:
+                input_users.append(await source.client.get_input_entity(tgid))
+            except ValueError as e:
+                source.log.debug(f"Failed to find the input entity for {tgid} ({mxid}) for "
+                                 f"creating a group: {e}")
+                errors.append(mxid)
+        return input_users, errors
+
+    async def upgrade_telegram_chat(self, source: 'u.User') -> None:
+        if self.peer_type != "chat":
+            raise ValueError("Only normal group chats are upgradable to supergroups.")
+
+        response = await source.client(MigrateChatRequest(chat_id=self.tgid))
+        entity = None
+        for chat in response.chats:
+            if isinstance(chat, Channel):
+                entity = chat
+                break
+        if not entity:
+            raise ValueError("Upgrade may have failed: output channel not found.")
+        self.peer_type = "channel"
+        self._migrate_and_save_telegram(TelegramID(entity.id))
+        await self.update_info(source, entity)
+
+    def _migrate_and_save_telegram(self, new_id: TelegramID) -> None:
+        try:
+            del self.by_tgid[self.tgid_full]
+        except KeyError:
+            pass
+        try:
+            existing = self.by_tgid[(new_id, new_id)]
+            existing.delete_sync()
+        except KeyError:
+            pass
+        self.db_instance.edit(tgid=new_id, tg_receiver=new_id, peer_type=self.peer_type)
+        old_id = self.tgid
+        self.tgid = new_id
+        self.tg_receiver = new_id
+        self.by_tgid[self.tgid_full] = self
+        self.log = self.base_log.getChild(self.tgid_log)
+        self.log.info(f"Telegram chat upgraded from {old_id}")
+
+    async def set_telegram_username(self, source: 'u.User', username: str) -> None:
+        if self.peer_type != "channel":
+            raise ValueError("Only channels and supergroups have usernames.")
+        await source.client(
+            UpdateUsernameRequest(await self.get_input_entity(source), username))
+        if await self._update_username(username):
+            await self.save()
+
+    async def create_telegram_chat(self, source: 'u.User', invites: List[InputUser],
+                                   supergroup: bool = False) -> None:
+        if not self.mxid:
+            raise ValueError("Can't create Telegram chat for portal without Matrix room.")
+        elif self.tgid:
+            raise ValueError("Can't create Telegram chat for portal with existing Telegram chat.")
+
+        if len(invites) < 2:
+            if self.bot is not None:
+                info, mxid = await self.bot.get_me()
+                raise ValueError("Not enough Telegram users to create a chat. "
+                                 "Invite more Telegram ghost users to the room, such as the "
+                                 f"relaybot ([{info.first_name}](https://matrix.to/#/{mxid})).")
+            raise ValueError("Not enough Telegram users to create a chat. "
+                             "Invite more Telegram ghost users to the room.")
+        if self.peer_type == "chat":
+            response = await source.client(CreateChatRequest(title=self.title, users=invites))
+            entity = response.chats[0]
+        elif self.peer_type == "channel":
+            response = await source.client(CreateChannelRequest(title=self.title,
+                                                                about=self.about or "",
+                                                                megagroup=supergroup))
+            entity = response.chats[0]
+            await source.client(InviteToChannelRequest(
+                channel=await source.client.get_input_entity(entity),
+                users=invites))
+        else:
+            raise ValueError("Invalid peer type for Telegram chat creation")
+
+        self.tgid = entity.id
+        self.tg_receiver = self.tgid
+        self.by_tgid[self.tgid_full] = self
+        await self.update_info(source, entity)
+        self.db_instance.insert()
+        self.log = self.base_log.getChild(self.tgid_log)
+
+        if self.bot and self.bot.tgid in invites:
+            self.bot.add_chat(self.tgid, self.peer_type)
+
+        levels = await self.main_intent.get_power_levels(self.mxid)
+        if levels.get_user_level(self.main_intent.mxid) == 100:
+            levels = self._get_base_power_levels(levels, entity)
+            await self.main_intent.set_power_levels(self.mxid, levels)
+        await self.handle_matrix_power_levels(source, levels.users, {}, None)
+
+    async def invite_telegram(self, source: 'u.User',
+                              puppet: Union[p.Puppet, 'AbstractUser']) -> None:
+        if self.peer_type == "chat":
+            await source.client(
+                AddChatUserRequest(chat_id=self.tgid, user_id=puppet.tgid, fwd_limit=0))
+        elif self.peer_type == "channel":
+            await source.client(InviteToChannelRequest(channel=self.peer, users=[puppet.tgid]))
+        # We don't care if there are invites for private chat portals with the relaybot.
+        elif not self.bot or self.tg_receiver != self.bot.tgid:
+            raise ValueError("Invalid peer type for Telegram user invite")
+
+    # endregion
+    # region Telegram -> Matrix
+
+    async def invite_to_matrix(self, users: InviteList) -> None:
+        if isinstance(users, list):
+            for user in users:
+                await self.main_intent.invite_user(self.mxid, user, check_cache=True)
+        else:
+            await self.main_intent.invite_user(self.mxid, users, check_cache=True)
+
+    async def update_matrix_room(self, user: 'AbstractUser', entity: Union[TypeChat, User],
+                                 direct: bool = None, puppet: p.Puppet = None,
+                                 levels: PowerLevelStateEventContent = None,
+                                 users: List[User] = None) -> None:
+        if direct is None:
+            direct = self.peer_type == "user"
+        try:
+            await self._update_matrix_room(user, entity, direct, puppet, levels, users)
+        except Exception:
+            self.log.exception("Fatal error updating Matrix room")
+
+    async def _update_matrix_room(self, user: 'AbstractUser', entity: Union[TypeChat, User],
+                                  direct: bool, puppet: p.Puppet = None,
+                                  levels: PowerLevelStateEventContent = None,
+                                  users: List[User] = None) -> None:
+        if not direct:
+            await self.update_info(user, entity)
+            if not users:
+                users = await self._get_users(user, entity)
+            await self._sync_telegram_users(user, users)
+            await self.update_power_levels(users, levels)
+        else:
+            if not puppet:
+                puppet = p.Puppet.get(self.tgid)
+            await puppet.update_info(user, entity)
+            await puppet.intent_for(self).join_room(self.mxid)
+            if self.encrypted or self.private_chat_portal_meta:
+                # The bridge bot needs to join for e2ee, but that messes up the default name
+                # generation. If/when canonical DMs happen, this might not be necessary anymore.
+                changed = await self._update_title(puppet.displayname)
+                changed = await self._update_avatar(user, entity.photo) or changed
+                if changed:
+                    await self.save()
+                    await self.update_bridge_info()
+
+            puppet = await p.Puppet.get_by_custom_mxid(user.mxid)
+            if puppet:
+                try:
+                    did_join = await puppet.intent.ensure_joined(self.mxid)
+                    if isinstance(user, u.User) and did_join and self.peer_type == "user":
+                        await user.update_direct_chats({self.main_intent.mxid: [self.mxid]})
+                except Exception:
+                    self.log.exception("Failed to ensure %s is joined to portal", user.mxid)
+
+        if self.sync_matrix_state:
+            await self.main_intent.get_joined_members(self.mxid)
+
+    async def create_matrix_room(self, user: 'AbstractUser', entity: Union[TypeChat, User] = None,
+                                 invites: InviteList = None, update_if_exists: bool = True
+                                 ) -> Optional[RoomID]:
+        if self.mxid:
+            if update_if_exists:
+                if not entity:
+                    try:
+                        entity = await self.get_entity(user)
+                    except Exception:
+                        self.log.exception(f"Failed to get entity through {user.tgid} for update")
+                        return self.mxid
+                update = self.update_matrix_room(user, entity, self.peer_type == "user")
+                self.loop.create_task(update)
+                await self.invite_to_matrix(invites or [])
+            return self.mxid
+        async with self._room_create_lock:
+            try:
+                return await self._create_matrix_room(user, entity, invites)
+            except Exception:
+                self.log.exception("Fatal error creating Matrix room")
+
+    @property
+    def bridge_info_state_key(self) -> str:
+        return f"net.maunium.telegram://telegram/{self.tgid}"
+
+    @property
+    def bridge_info(self) -> Dict[str, Any]:
+        info = {
+            "bridgebot": self.az.bot_mxid,
+            "creator": self.main_intent.mxid,
+            "protocol": {
+                "id": "telegram",
+                "displayname": "Telegram",
+                "avatar_url": config["appservice.bot_avatar"],
+                "external_url": "https://telegram.org",
+            },
+            "channel": {
+                "id": str(self.tgid),
+                "displayname": self.title,
+                "avatar_url": self.avatar_url,
+            }
+        }
+        if self.username:
+            info["channel"]["external_url"] = f"https://t.me/{self.username}"
+        elif self.peer_type == "user":
+            puppet = p.Puppet.get(self.tgid)
+            if puppet and puppet.username:
+                info["channel"]["external_url"] = f"https://t.me/{puppet.username}"
+        return info
+
+    async def update_bridge_info(self) -> None:
+        if not self.mxid:
+            self.log.debug("Not updating bridge info: no Matrix room created")
+            return
+        try:
+            self.log.debug("Updating bridge info...")
+            await self.main_intent.send_state_event(self.mxid, StateBridge,
+                                                    self.bridge_info, self.bridge_info_state_key)
+            # TODO remove this once https://github.com/matrix-org/matrix-doc/pull/2346 is in spec
+            await self.main_intent.send_state_event(self.mxid, StateHalfShotBridge,
+                                                    self.bridge_info, self.bridge_info_state_key)
+        except Exception:
+            self.log.warning("Failed to update bridge info", exc_info=True)
+
+    async def _create_matrix_room(self, user: 'AbstractUser', entity: Union[TypeChat, User],
+                                  invites: InviteList) -> Optional[RoomID]:
+        if self.mxid:
+            return self.mxid
+        elif not self.allow_bridging:
+            return None
+
+        direct = self.peer_type == "user"
+        invites = invites or []
+
+        if not entity:
+            entity = await self.get_entity(user)
+            self.log.trace("Fetched data: %s", entity)
+
+        self.log.debug("Creating room")
+
+        try:
+            self.title = entity.title
+        except AttributeError:
+            self.title = None
+
+        if direct and self.tgid == user.tgid:
+            self.title = "Telegram Saved Messages"
+            self.about = "Your Telegram cloud storage chat"
+
+        puppet = p.Puppet.get(self.tgid) if direct else None
+        if puppet:
+            await puppet.update_info(user, entity)
+        self._main_intent = puppet.intent_for(self) if direct else self.az.intent
+
+        if self.peer_type == "channel":
+            self.megagroup = entity.megagroup
+
+        if self.peer_type == "channel" and entity.username:
+            preset = RoomCreatePreset.PUBLIC
+            self.username = entity.username
+            alias = self.alias_localpart
+        else:
+            preset = RoomCreatePreset.PRIVATE
+            # TODO invite link alias?
+            alias = None
+
+        if alias:
+            # TODO? properly handle existing room aliases
+            await self.main_intent.remove_room_alias(alias)
+
+        power_levels = self._get_base_power_levels(entity=entity)
+        users = None
+        if not direct:
+            users = await self._get_users(user, entity)
+            if self.has_bot:
+                extra_invites = config["bridge.relaybot.group_chat_invite"]
+                invites += extra_invites
+                for invite in extra_invites:
+                    power_levels.users.setdefault(invite, 100)
+            await self._participants_to_power_levels(users, power_levels)
+        elif self.bot and self.tg_receiver == self.bot.tgid:
+            invites = config["bridge.relaybot.private_chat.invite"]
+            for invite in invites:
+                power_levels.users.setdefault(invite, 100)
+            self.title = puppet.displayname
+
+        initial_state = [{
+            "type": EventType.ROOM_POWER_LEVELS.serialize(),
+            "content": power_levels.serialize(),
+        }, {
+            "type": str(StateBridge),
+            "state_key": self.bridge_info_state_key,
+            "content": self.bridge_info,
+        }, {
+            # TODO remove this once https://github.com/matrix-org/matrix-doc/pull/2346 is in spec
+            "type": str(StateHalfShotBridge),
+            "state_key": self.bridge_info_state_key,
+            "content": self.bridge_info,
+        }]
+        if config["bridge.encryption.default"] and self.matrix.e2ee:
+            self.encrypted = True
+            initial_state.append({
+                "type": "m.room.encryption",
+                "content": {"algorithm": "m.megolm.v1.aes-sha2"},
+            })
+            if direct:
+                invites.append(self.az.bot_mxid)
+        if direct and (self.encrypted or self.private_chat_portal_meta):
+            self.title = puppet.displayname
+        if config["appservice.community_id"]:
+            initial_state.append({
+                "type": "m.room.related_groups",
+                "content": {"groups": [config["appservice.community_id"]]},
+            })
+        creation_content = {}
+        if not config["bridge.federate_rooms"]:
+            creation_content["m.federate"] = False
+
+        with self.backfill_lock:
+            room_id = await self.main_intent.create_room(alias_localpart=alias, preset=preset,
+                                                         is_direct=direct, invitees=invites or [],
+                                                         name=self.title, topic=self.about,
+                                                         initial_state=initial_state,
+                                                         creation_content=creation_content)
+            if not room_id:
+                raise Exception(f"Failed to create room")
+
+            if self.encrypted and self.matrix.e2ee and direct:
+                try:
+                    await self.az.intent.ensure_joined(room_id)
+                except Exception:
+                    self.log.warning(f"Failed to add bridge bot to new private chat {room_id}")
+
+            self.mxid = room_id
+            self.by_mxid[self.mxid] = self
+            await self.save()
+            await self.az.state_store.set_power_levels(self.mxid, power_levels)
+            await user.register_portal(self)
+
+            update_room = self.loop.create_task(self.update_matrix_room(
+                user, entity, direct, puppet,
+                levels=power_levels, users=users))
+
+            if config["bridge.backfill.initial_limit"] > 0:
+                self.log.debug("Initial backfill is enabled. Waiting for room members to sync "
+                               "and then starting backfill")
+                await update_room
+
+                try:
+                    await self.backfill(user, is_initial=True)
+                except Exception:
+                    self.log.exception("Failed to backfill new portal")
+
+        return self.mxid
+
+    def _get_base_power_levels(self, levels: PowerLevelStateEventContent = None,
+                               entity: TypeChat = None) -> PowerLevelStateEventContent:
+        levels = levels or PowerLevelStateEventContent()
+        if self.peer_type == "user":
+            overrides = config["bridge.initial_power_level_overrides.user"]
+            levels.ban = overrides.get("ban", 100)
+            levels.kick = overrides.get("kick", 100)
+            levels.invite = overrides.get("invite", 100)
+            levels.redact = overrides.get("redact", 0)
+            levels.events[EventType.ROOM_NAME] = 0
+            levels.events[EventType.ROOM_AVATAR] = 0
+            levels.events[EventType.ROOM_TOPIC] = 0
+            levels.state_default = overrides.get("state_default", 0)
+            levels.users_default = overrides.get("users_default", 0)
+            levels.events_default = overrides.get("events_default", 0)
+        else:
+            overrides = config["bridge.initial_power_level_overrides.group"]
+            dbr = entity.default_banned_rights
+            if not dbr:
+                self.log.debug(f"default_banned_rights is None in {entity}")
+                dbr = ChatBannedRights(invite_users=True, change_info=True, pin_messages=True,
+                                       send_stickers=False, send_messages=False, until_date=None)
+            levels.ban = overrides.get("ban", 50)
+            levels.kick = overrides.get("kick", 50)
+            levels.redact = overrides.get("redact", 50)
+            levels.invite = overrides.get("invite", 50 if dbr.invite_users else 0)
+            levels.events[EventType.ROOM_ENCRYPTION] = 50 if self.matrix.e2ee else 99
+            levels.events[EventType.ROOM_TOMBSTONE] = 99
+            levels.events[EventType.ROOM_NAME] = 50 if dbr.change_info else 0
+            levels.events[EventType.ROOM_AVATAR] = 50 if dbr.change_info else 0
+            levels.events[EventType.ROOM_TOPIC] = 50 if dbr.change_info else 0
+            levels.events[EventType.ROOM_PINNED_EVENTS] = 50 if dbr.pin_messages else 0
+            levels.events[EventType.ROOM_POWER_LEVELS] = 75
+            levels.events[EventType.ROOM_HISTORY_VISIBILITY] = 75
+            levels.events[EventType.STICKER] = 50 if dbr.send_stickers else levels.events_default
+            levels.state_default = overrides.get("state_default", 50)
+            levels.users_default = overrides.get("users_default", 0)
+            levels.events_default = (
+                overrides.get("events_default",
+                              50 if (self.peer_type == "channel" and not entity.megagroup
+                                     or entity.default_banned_rights.send_messages)
+                              else 0))
+        for evt_type, value in overrides.get("events", {}).items():
+            levels.events[EventType.find(evt_type)] = value
+        levels.users = overrides.get("users", {})
+        if self.main_intent.mxid not in levels.users:
+            levels.users[self.main_intent.mxid] = 100
+        return levels
+
+    @staticmethod
+    def _get_level_from_participant(participant: TypeParticipant) -> int:
+        # TODO use the power level requirements to get better precision in channels
+        if isinstance(participant, (ChatParticipantAdmin, ChannelParticipantAdmin)):
+            return 50
+        elif isinstance(participant, (ChatParticipantCreator, ChannelParticipantCreator)):
+            return 95
+        return 0
+
+    @staticmethod
+    def _participant_to_power_levels(levels: PowerLevelStateEventContent,
+                                     user: Union['u.User', p.Puppet], new_level: int,
+                                     bot_level: int) -> bool:
+        new_level = min(new_level, bot_level)
+        user_level = levels.get_user_level(user.mxid)
+        if user_level != new_level and user_level < bot_level:
+            levels.users[user.mxid] = new_level
+            return True
+        return False
+
+    async def _participants_to_power_levels(self, users: List[Union[TypeUser, TypeParticipant]],
+                                            levels: PowerLevelStateEventContent) -> bool:
+        bot_level = levels.get_user_level(self.main_intent.mxid)
+        if bot_level < levels.get_event_level(EventType.ROOM_POWER_LEVELS):
+            return False
+        changed = False
+        admin_power_level = min(75 if self.peer_type == "channel" else 50, bot_level)
+        if levels.get_event_level(EventType.ROOM_POWER_LEVELS) != admin_power_level:
+            changed = True
+            levels.events[EventType.ROOM_POWER_LEVELS] = admin_power_level
+
+        for user in users:
+            # The User objects we get from TelegramClient.get_participants have a custom
+            # participant property
+            participant = getattr(user, "participant", user)
+
+            puppet = p.Puppet.get(TelegramID(participant.user_id))
+            user = u.User.get_by_tgid(TelegramID(participant.user_id))
+            new_level = self._get_level_from_participant(participant)
+
+            if user:
+                await user.register_portal(self)
+                changed = self._participant_to_power_levels(levels, user, new_level,
+                                                            bot_level) or changed
+
+            if puppet:
+                changed = self._participant_to_power_levels(levels, puppet, new_level,
+                                                            bot_level) or changed
+        return changed
+
+    async def update_power_levels(self, users: List[Union[TypeUser, TypeParticipant]],
+                                  levels: PowerLevelStateEventContent = None) -> None:
+        if not levels:
+            levels = await self.main_intent.get_power_levels(self.mxid)
+        if await self._participants_to_power_levels(users, levels):
+            await self.main_intent.set_power_levels(self.mxid, levels)
+
+    async def _add_bot_chat(self, bot: User) -> None:
+        if self.bot and bot.id == self.bot.tgid:
+            self.bot.add_chat(self.tgid, self.peer_type)
+            return
+
+        user = u.User.get_by_tgid(TelegramID(bot.id))
+        if user and user.is_bot:
+            await user.register_portal(self)
+
+    async def _sync_telegram_users(self, source: 'AbstractUser', users: List[User]) -> None:
+        allowed_tgids = set()
+        skip_deleted = config["bridge.skip_deleted_members"]
+        for entity in users:
+            puppet = p.Puppet.get(TelegramID(entity.id))
+            if entity.bot:
+                await self._add_bot_chat(entity)
+            allowed_tgids.add(entity.id)
+
+            await puppet.update_info(source, entity)
+            if skip_deleted and entity.deleted:
+                continue
+
+            await puppet.intent_for(self).ensure_joined(self.mxid)
+
+            user = u.User.get_by_tgid(TelegramID(entity.id))
+            if user:
+                await self.invite_to_matrix(user.mxid)
+
+                puppet = await p.Puppet.get_by_custom_mxid(user.mxid)
+                if puppet:
+                    try:
+                        await puppet.intent.ensure_joined(self.mxid)
+                    except Exception:
+                        self.log.exception("Failed to ensure %s is joined to portal", user.mxid)
+
+        # We can't trust the member list if any of the following cases is true:
+        #  * There are close to 10 000 users, because Telegram might not be sending all members.
+        #  * The member sync count is limited, because then we might ignore some members.
+        #  * It's a channel, because non-admins don't have access to the member list.
+        trust_member_list = ((len(allowed_tgids) < 9900
+                              if self.max_initial_member_sync < 0
+                              else len(allowed_tgids) < self.max_initial_member_sync - 10)
+                             and (self.megagroup or self.peer_type != "channel"))
+        if not trust_member_list:
+            return
+
+        for user_mxid in await self.main_intent.get_room_members(self.mxid):
+            if user_mxid == self.az.bot_mxid:
+                continue
+
+            puppet_id = p.Puppet.get_id_from_mxid(user_mxid)
+            if puppet_id:
+                if puppet_id in allowed_tgids:
+                    continue
+                if self.bot and puppet_id == self.bot.tgid:
+                    self.bot.remove_chat(self.tgid)
+                try:
+                    await self.main_intent.kick_user(self.mxid, user_mxid,
+                                                     "User had left this Telegram chat.")
+                except MForbidden:
+                    pass
+                continue
+
+            mx_user = u.User.get_by_mxid(user_mxid, create=False)
+            if mx_user:
+                if mx_user.tgid in allowed_tgids:
+                    continue
+                if mx_user.is_bot:
+                    await mx_user.unregister_portal(*self.tgid_full)
+                if not self.has_bot:
+                    try:
+                        await self.main_intent.kick_user(self.mxid, mx_user.mxid,
+                                                         "You had left this Telegram chat.")
+                    except MForbidden:
+                        pass
+
+    async def _add_telegram_user(self, user_id: TelegramID, source: Optional['AbstractUser'] = None
+                                 ) -> None:
+        puppet = p.Puppet.get(user_id)
+        if source:
+            entity: User = await source.client.get_entity(PeerUser(user_id))
+            await puppet.update_info(source, entity)
+            await puppet.intent_for(self).ensure_joined(self.mxid)
+
+        user = u.User.get_by_tgid(user_id)
+        if user:
+            await user.register_portal(self)
+            await self.invite_to_matrix(user.mxid)
+
+    async def _delete_telegram_user(self, user_id: TelegramID, sender: p.Puppet) -> None:
+        puppet = p.Puppet.get(user_id)
+        user = u.User.get_by_tgid(user_id)
+        kick_message = (f"Kicked by {sender.displayname}"
+                        if sender and sender.tgid != puppet.tgid
+                        else "Left Telegram chat")
+        if sender.tgid != puppet.tgid:
+            try:
+                await sender.intent_for(self).kick_user(self.mxid, puppet.mxid)
+            except MForbidden:
+                await self.main_intent.kick_user(self.mxid, puppet.mxid, kick_message)
+        else:
+            await puppet.intent_for(self).leave_room(self.mxid)
+        if user:
+            await user.unregister_portal(*self.tgid_full)
+            if sender.tgid != puppet.tgid:
+                try:
+                    await sender.intent_for(self).kick_user(self.mxid, puppet.mxid)
+                    return
+                except MForbidden:
+                    pass
+            try:
+                await self.main_intent.kick_user(self.mxid, user.mxid, kick_message)
+            except MForbidden as e:
+                self.log.warning(f"Failed to kick {user.mxid}: {e}")
+
+    async def update_info(self, user: 'AbstractUser', entity: TypeChat = None) -> None:
+        if self.peer_type == "user":
+            self.log.warning("Called update_info() for direct chat portal")
+            return
+
+        changed = False
+        self.log.debug("Updating info")
+        try:
+            if not entity:
+                entity = await self.get_entity(user)
+                self.log.trace("Fetched data: %s", entity)
+
+            if self.peer_type == "channel":
+                changed = self.megagroup != entity.megagroup or changed
+                self.megagroup = entity.megagroup
+                changed = await self._update_username(entity.username) or changed
+
+            if hasattr(entity, "about"):
+                changed = self._update_about(entity.about) or changed
+
+            changed = await self._update_title(entity.title) or changed
+
+            if isinstance(entity.photo, ChatPhoto):
+                changed = await self._update_avatar(user, entity.photo) or changed
+        except Exception:
+            self.log.exception(f"Failed to update info from source {user.tgid}")
+
+        if changed:
+            await self.save()
+            await self.update_bridge_info()
+
+    async def _update_username(self, username: str, save: bool = False) -> bool:
+        if self.username == username:
+            return False
+
+        if self.username:
+            await self.main_intent.remove_room_alias(self.alias_localpart)
+        self.username = username or None
+        if self.username:
+            await self.main_intent.add_room_alias(self.mxid, self.alias_localpart, override=True)
+            if self.public_portals:
+                await self.main_intent.set_join_rule(self.mxid, "public")
+        else:
+            await self.main_intent.set_join_rule(self.mxid, "invite")
+
+        if save:
+            await self.save()
+        return True
+
+    async def _try_set_state(self, sender: Optional['p.Puppet'], evt_type: EventType,
+                             content: StateEventContent) -> None:
+        if sender:
+            try:
+                intent = sender.intent_for(self)
+                if sender.is_real_user:
+                    content[self.az.real_user_content_key] = True
+                await intent.send_state_event(self.mxid, evt_type, content)
+            except MForbidden:
+                await self.main_intent.send_state_event(self.mxid, evt_type, content)
+        else:
+            await self.main_intent.send_state_event(self.mxid, evt_type, content)
+
+    async def _update_about(self, about: str, sender: Optional['p.Puppet'] = None,
+                            save: bool = False) -> bool:
+        if self.about == about:
+            return False
+
+        self.about = about
+        await self._try_set_state(sender, EventType.ROOM_TOPIC,
+                                  RoomTopicStateEventContent(topic=self.about))
+        if save:
+            await self.save()
+        return True
+
+    async def _update_title(self, title: str, sender: Optional['p.Puppet'] = None,
+                            save: bool = False) -> bool:
+        if self.title == title:
+            return False
+
+        self.title = title
+        await self._try_set_state(sender, EventType.ROOM_NAME,
+                                  RoomNameStateEventContent(name=self.title))
+        if save:
+            await self.save()
+        return True
+
+    async def _update_avatar(self, user: 'AbstractUser', photo: TypeChatPhoto,
+                             sender: Optional['p.Puppet'] = None, save: bool = False) -> bool:
+        if isinstance(photo, (ChatPhoto, UserProfilePhoto)):
+            loc = InputPeerPhotoFileLocation(
+                peer=await self.get_input_entity(user),
+                local_id=photo.photo_big.local_id,
+                volume_id=photo.photo_big.volume_id,
+                big=True
+            )
+            photo_id = (f"{loc.volume_id}-{loc.local_id}" if isinstance(photo, ChatPhoto)
+                        else photo.photo_id)
+        elif isinstance(photo, Photo):
+            loc, largest = self._get_largest_photo_size(photo)
+            photo_id = f"{largest.location.volume_id}-{largest.location.local_id}"
+        elif isinstance(photo, (UserProfilePhotoEmpty, ChatPhotoEmpty, PhotoEmpty, type(None))):
+            photo_id = ""
+            loc = None
+        else:
+            raise ValueError(f"Unknown photo type {type(photo)}")
+        if self.peer_type == "user" and not photo_id and not config["bridge.allow_avatar_remove"]:
+            return False
+        if self.photo_id != photo_id:
+            if not photo_id:
+                await self._try_set_state(sender, EventType.ROOM_AVATAR,
+                                          RoomAvatarStateEventContent(url=None))
+                self.photo_id = ""
+                self.avatar_url = None
+                if save:
+                    await self.save()
+                return True
+            file = await util.transfer_file_to_matrix(user.client, self.main_intent, loc)
+            if file:
+                await self._try_set_state(sender, EventType.ROOM_AVATAR,
+                                          RoomAvatarStateEventContent(url=file.mxc))
+                self.photo_id = photo_id
+                self.avatar_url = file.mxc
+                if save:
+                    await self.save()
+                return True
+        return False
+
+    @staticmethod
+    def _filter_participants(users: List[TypeUser], participants: List[TypeParticipant]
+                             ) -> Iterable[TypeUser]:
+        participant_map = {part.user_id: part for part in participants}
+        for user in users:
+            try:
+                user.participant = participant_map[user.id]
+            except KeyError:
+                pass
+            else:
+                yield user
+
+    async def _get_channel_users(self, user: 'AbstractUser', entity: InputChannel, limit: int
+                                 ) -> List[TypeUser]:
+        if 0 < limit <= 200:
+            response = await user.client(GetParticipantsRequest(
+                entity, ChannelParticipantsRecent(), offset=0, limit=limit, hash=0))
+            return list(self._filter_participants(response.users, response.participants))
+        elif limit > 200 or limit == -1:
+            users: List[TypeUser] = []
+            offset = 0
+            remaining_quota = limit if limit > 0 else 1000000
+            query = (ChannelParticipantsSearch("") if limit == -1
+                     else ChannelParticipantsRecent())
+            while True:
+                if remaining_quota <= 0:
+                    break
+                response = await user.client(GetParticipantsRequest(
+                    entity, query, offset=offset, limit=min(remaining_quota, 200), hash=0))
+                if not response.users:
+                    break
+                users += self._filter_participants(response.users, response.participants)
+                offset += len(response.participants)
+                remaining_quota -= len(response.participants)
+            return users
+
+    async def _get_users(self, user: 'AbstractUser',
+                         entity: Union[TypeInputPeer, InputUser, TypeChat, TypeUser, InputChannel]
+                         ) -> List[TypeUser]:
+        if self.peer_type == "chat":
+            chat = await user.client(GetFullChatRequest(chat_id=self.tgid))
+            return list(self._filter_participants(chat.users,
+                                                  chat.full_chat.participants.participants))
+        elif self.peer_type == "channel":
+            if not self.megagroup and not self.sync_channel_members:
+                return []
+
+            limit = self.max_initial_member_sync
+            if limit == 0:
+                return []
+
+            try:
+                return await self._get_channel_users(user, entity, limit)
+            except ChatAdminRequiredError:
+                return []
+        elif self.peer_type == "user":
+            return [entity]
+        else:
+            raise RuntimeError(f"Unexpected peer type {self.peer_type}")
+
+    # endregion
+
+    async def _send_delivery_receipt(self, event_id: EventID, room_id: Optional[RoomID] = None
+                                     ) -> None:
+        # TODO maybe check if the bot is in the room rather than assuming based on self.encrypted
+        if event_id and config["bridge.delivery_receipts"] and (self.encrypted
+                                                                or self.peer_type != "user"):
+            try:
+                await self.az.intent.mark_read(room_id or self.mxid, event_id)
+            except Exception:
+                self.log.exception("Failed to send delivery receipt for %s", event_id)
+
+
+def init(context: Context) -> None:
+    global config
+    config = context.config

mautrix_telegram/portal/send_lock.py

@@ -0,0 +1,44 @@
+# 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
+from asyncio import Lock
+
+from ..types import TelegramID
+
+
+class FakeLock:
+    async def __aenter__(self) -> None:
+        pass
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        pass
+
+
+class PortalSendLock:
+    _send_locks: Dict[int, Lock]
+    _noop_lock: Lock = FakeLock()
+
+    def __init__(self) -> None:
+        self._send_locks = {}
+
+    def __call__(self, user_id: TelegramID, required: bool = True) -> Lock:
+        if user_id is None and required:
+            raise ValueError("Required send lock for none id")
+        try:
+            return self._send_locks[user_id]
+        except KeyError:
+            return (self._send_locks.setdefault(user_id, Lock())
+                    if required else self._noop_lock)

mautrix_telegram/portal/telegram.py

@@ -0,0 +1,788 @@
+# mautrix-telegram - A Matrix-Telegram puppeting bridge
+# Copyright (C) 2020 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 Awaitable, Dict, List, Optional, Tuple, Union, NamedTuple, TYPE_CHECKING
+from abc import ABC
+import random
+import mimetypes
+import codecs
+import unicodedata
+import base64
+import asyncio
+
+from sqlalchemy.exc import IntegrityError
+
+from telethon.tl.patched import Message, MessageService
+from telethon.tl.types import (
+    Poll, DocumentAttributeFilename, DocumentAttributeSticker, DocumentAttributeVideo,
+    MessageMediaPoll, MessageActionChannelCreate, MessageActionChatAddUser,
+    MessageActionChatCreate, MessageActionChatDeletePhoto, MessageActionChatDeleteUser,
+    MessageActionChatEditPhoto, MessageActionChatEditTitle, MessageActionChatJoinedByLink,
+    MessageActionChatMigrateTo, MessageActionGameScore, MessageMediaDocument, MessageMediaGeo,
+    MessageMediaPhoto, MessageMediaDice, MessageMediaGame, MessageMediaUnsupported, PeerUser,
+    PhotoCachedSize, TypeChannelParticipant, TypeChatParticipant, TypeDocumentAttribute,
+    TypeMessageAction, TypePhotoSize, PhotoSize, UpdateChatUserTyping, UpdateUserTyping,
+    MessageEntityPre, ChatPhotoEmpty, DocumentAttributeImageSize)
+
+from mautrix.appservice import IntentAPI
+from mautrix.types import (EventID, UserID, ImageInfo, ThumbnailInfo, RelatesTo, MessageType,
+                           EventType, MediaMessageEventContent, TextMessageEventContent,
+                           LocationMessageEventContent, Format)
+from mautrix.bridge import NotificationDisabler
+
+from ..types import TelegramID
+from ..db import Message as DBMessage, TelegramFile as DBTelegramFile
+from ..util import sane_mimetypes
+from ..context import Context
+from ..tgclient import TelegramClient
+from .. import puppet as p, user as u, formatter, util
+from .base import BasePortal
+
+if TYPE_CHECKING:
+    from ..abstract_user import AbstractUser
+    from ..config import Config
+
+InviteList = Union[UserID, List[UserID]]
+TypeParticipant = Union[TypeChatParticipant, TypeChannelParticipant]
+DocAttrs = NamedTuple("DocAttrs", name=Optional[str], mime_type=Optional[str], is_sticker=bool,
+                      sticker_alt=Optional[str], width=int, height=int)
+
+config: Optional['Config'] = None
+
+
+class PortalTelegram(BasePortal, ABC):
+    async def handle_telegram_typing(self, user: p.Puppet,
+                                     _: Union[UpdateUserTyping, UpdateChatUserTyping]) -> None:
+        await user.intent_for(self).set_typing(self.mxid, is_typing=True)
+
+    def _get_external_url(self, evt: Message) -> Optional[str]:
+        if self.peer_type == "channel" and self.username is not None:
+            return f"https://t.me/{self.username}/{evt.id}"
+        elif self.peer_type != "user":
+            return f"https://t.me/c/{self.tgid}/{evt.id}"
+        return None
+
+    async def _expire_telegram_photo(self, intent: IntentAPI, event_id: EventID, ttl: int) -> None:
+        try:
+            content = TextMessageEventContent(msgtype=MessageType.NOTICE, body="Photo has expired")
+            content.set_edit(event_id)
+            await asyncio.sleep(ttl)
+            await self._send_message(intent, content)
+        except Exception:
+            self.log.warning("Failed to expire Telegram photo %s", event_id, exc_info=True)
+
+    async def handle_telegram_photo(self, source: 'AbstractUser', intent: IntentAPI, evt: Message,
+                                    relates_to: RelatesTo = None) -> Optional[EventID]:
+        media: MessageMediaPhoto = evt.media
+        if media.photo is None and media.ttl_seconds:
+            return await self._send_message(intent, TextMessageEventContent(
+                msgtype=MessageType.NOTICE, body="Photo has expired"))
+        loc, largest_size = self._get_largest_photo_size(media.photo)
+        if loc is None:
+            content = TextMessageEventContent(msgtype=MessageType.TEXT,
+                                              body="Failed to bridge image",
+                                              external_url=self._get_external_url(evt))
+            return await self._send_message(intent, content, timestamp=evt.date)
+        file = await util.transfer_file_to_matrix(source.client, intent, loc,
+                                                  encrypt=self.encrypted)
+        if not file:
+            return None
+        if self.get_config("inline_images") and (evt.message or evt.fwd_from or evt.reply_to):
+            content = await formatter.telegram_to_matrix(
+                evt, source, self.main_intent,
+                prefix_html=f"<img src='{file.mxc}' alt='Inline Telegram photo'/><br/>",
+                prefix_text="Inline image: ")
+            content.external_url = self._get_external_url(evt)
+            await intent.set_typing(self.mxid, is_typing=False)
+            return await self._send_message(intent, content, timestamp=evt.date)
+        info = ImageInfo(
+            height=largest_size.h, width=largest_size.w, orientation=0, mimetype=file.mime_type,
+            size=self._photo_size_key(largest_size))
+        ext = sane_mimetypes.guess_extension(file.mime_type)
+        name = f"disappearing_image{ext}" if media.ttl_seconds else f"image{ext}"
+        await intent.set_typing(self.mxid, is_typing=False)
+        content = MediaMessageEventContent(msgtype=MessageType.IMAGE, info=info,
+                                           body=name, relates_to=relates_to,
+                                           external_url=self._get_external_url(evt))
+        if file.decryption_info:
+            content.file = file.decryption_info
+        else:
+            content.url = file.mxc
+        result = await self._send_message(intent, content, timestamp=evt.date)
+        if media.ttl_seconds:
+            self.loop.create_task(self._expire_telegram_photo(intent, result,
+                                                              media.ttl_seconds))
+        if evt.message:
+            caption_content = await formatter.telegram_to_matrix(evt, source, self.main_intent,
+                                                                 no_reply_fallback=True)
+            caption_content.external_url = content.external_url
+            result = await self._send_message(intent, caption_content, timestamp=evt.date)
+        return result
+
+    @staticmethod
+    def _parse_telegram_document_attributes(attributes: List[TypeDocumentAttribute]) -> DocAttrs:
+        name, mime_type, is_sticker, sticker_alt, width, height = None, None, False, None, 0, 0
+        for attr in attributes:
+            if isinstance(attr, DocumentAttributeFilename):
+                name = name or attr.file_name
+                mime_type, _ = mimetypes.guess_type(attr.file_name)
+            elif isinstance(attr, DocumentAttributeSticker):
+                is_sticker = True
+                sticker_alt = attr.alt
+            elif isinstance(attr, DocumentAttributeVideo):
+                width, height = attr.w, attr.h
+            elif isinstance(attr, DocumentAttributeImageSize):
+                width, height = attr.w, attr.h
+        return DocAttrs(name, mime_type, is_sticker, sticker_alt, width, height)
+
+    @staticmethod
+    def _parse_telegram_document_meta(evt: Message, file: DBTelegramFile, attrs: DocAttrs,
+                                      thumb_size: TypePhotoSize) -> Tuple[ImageInfo, str]:
+        document = evt.media.document
+        name = attrs.name
+        if attrs.is_sticker:
+            alt = attrs.sticker_alt
+            if len(alt) > 0:
+                try:
+                    name = f"{alt} ({unicodedata.name(alt[0]).lower()})"
+                except ValueError:
+                    name = alt
+
+        generic_types = ("text/plain", "application/octet-stream")
+        if file.mime_type in generic_types and document.mime_type not in generic_types:
+            mime_type = document.mime_type or file.mime_type
+        elif file.mime_type == 'application/ogg':
+            mime_type = 'audio/ogg'
+        else:
+            mime_type = file.mime_type or document.mime_type
+        info = ImageInfo(size=file.size, mimetype=mime_type)
+
+        if attrs.mime_type and not file.was_converted:
+            file.mime_type = attrs.mime_type or file.mime_type
+        if file.width and file.height:
+            info.width, info.height = file.width, file.height
+        elif attrs.width and attrs.height:
+            info.width, info.height = attrs.width, attrs.height
+
+        if file.thumbnail:
+            if file.thumbnail.decryption_info:
+                info.thumbnail_file = file.thumbnail.decryption_info
+            else:
+                info.thumbnail_url = file.thumbnail.mxc
+            info.thumbnail_info = ThumbnailInfo(mimetype=file.thumbnail.mime_type,
+                                                height=file.thumbnail.height or thumb_size.h,
+                                                width=file.thumbnail.width or thumb_size.w,
+                                                size=file.thumbnail.size)
+        else:
+            # This is a hack for bad clients like Element iOS that require a thumbnail
+            if file.decryption_info:
+                info.thumbnail_file = file.decryption_info
+            else:
+                info.thumbnail_url = file.mxc
+            info.thumbnail_info = ImageInfo.deserialize(info.serialize())
+
+        return info, name
+
+    async def handle_telegram_document(self, source: 'AbstractUser', intent: IntentAPI,
+                                       evt: Message, relates_to: RelatesTo = None
+                                       ) -> Optional[EventID]:
+        document = evt.media.document
+
+        attrs = self._parse_telegram_document_attributes(document.attributes)
+
+        if document.size > config["bridge.max_document_size"] * 1000 ** 2:
+            name = attrs.name or ""
+            caption = f"\n{evt.message}" if evt.message else ""
+            # TODO encrypt
+            return await intent.send_notice(self.mxid, f"Too large file {name}{caption}")
+
+        thumb_loc, thumb_size = self._get_largest_photo_size(document)
+        if thumb_size and not isinstance(thumb_size, (PhotoSize, PhotoCachedSize)):
+            self.log.debug(f"Unsupported thumbnail type {type(thumb_size)}")
+            thumb_loc = None
+            thumb_size = None
+        parallel_id = source.tgid if config["bridge.parallel_file_transfer"] else None
+        file = await util.transfer_file_to_matrix(source.client, intent, document, thumb_loc,
+                                                  is_sticker=attrs.is_sticker,
+                                                  tgs_convert=config["bridge.animated_sticker"],
+                                                  filename=attrs.name, parallel_id=parallel_id,
+                                                  encrypt=self.encrypted)
+        if not file:
+            return None
+
+        info, name = self._parse_telegram_document_meta(evt, file, attrs, thumb_size)
+
+        await intent.set_typing(self.mxid, is_typing=False)
+
+        event_type = EventType.ROOM_MESSAGE
+        # Elements only support images as stickers, so send animated webm stickers as m.video
+        if attrs.is_sticker and file.mime_type.startswith("image/"):
+            event_type = EventType.STICKER
+            # Tell clients to render the stickers as 256x256 if they're bigger
+            if info.width > 256 or info.height > 256:
+                if info.width > info.height:
+                    info.height = int(info.height / (info.width / 256))
+                    info.width = 256
+                else:
+                    info.width = int(info.width / (info.height / 256))
+                    info.height = 256
+            if info.thumbnail_info:
+                info.thumbnail_info.width = info.width
+                info.thumbnail_info.height = info.height
+
+        content = MediaMessageEventContent(
+            body=name or "unnamed file", info=info, relates_to=relates_to,
+            external_url=self._get_external_url(evt),
+            msgtype={
+                "video/": MessageType.VIDEO,
+                "audio/": MessageType.AUDIO,
+                "image/": MessageType.IMAGE,
+            }.get(info.mimetype[:6], MessageType.FILE))
+        if file.decryption_info:
+            content.file = file.decryption_info
+        else:
+            content.url = file.mxc
+        res = await self._send_message(intent, content, event_type=event_type, timestamp=evt.date)
+        if evt.message:
+            caption_content = await formatter.telegram_to_matrix(evt, source, self.main_intent,
+                                                                 no_reply_fallback=True)
+            caption_content.external_url = content.external_url
+            res = await self._send_message(intent, caption_content, timestamp=evt.date)
+        return res
+
+    def handle_telegram_location(self, source: 'AbstractUser', intent: IntentAPI, evt: Message,
+                                 relates_to: RelatesTo = None) -> Awaitable[EventID]:
+        long = evt.media.geo.long
+        lat = evt.media.geo.lat
+        long_char = "E" if long > 0 else "W"
+        lat_char = "N" if lat > 0 else "S"
+        geo = f"{round(lat, 6)},{round(long, 6)}"
+
+        body = f"{round(abs(lat), 4)}° {lat_char}, {round(abs(long), 4)}° {long_char}"
+        url = f"https://maps.google.com/?q={geo}"
+
+        content = LocationMessageEventContent(
+            msgtype=MessageType.LOCATION, geo_uri=f"geo:{geo}",
+            body=f"Location: {body}\n{url}",
+            relates_to=relates_to, external_url=self._get_external_url(evt))
+        content["format"] = str(Format.HTML)
+        content["formatted_body"] = f"Location: <a href='{url}'>{body}</a>"
+
+        return self._send_message(intent, content, timestamp=evt.date)
+
+    async def handle_telegram_text(self, source: 'AbstractUser', intent: IntentAPI, is_bot: bool,
+                                   evt: Message) -> EventID:
+        self.log.trace(f"Sending {evt.message} to {self.mxid} by {intent.mxid}")
+        content = await formatter.telegram_to_matrix(evt, source, self.main_intent)
+        content.external_url = self._get_external_url(evt)
+        if is_bot and self.get_config("bot_messages_as_notices"):
+            content.msgtype = MessageType.NOTICE
+        await intent.set_typing(self.mxid, is_typing=False)
+        return await self._send_message(intent, content, timestamp=evt.date)
+
+    async def handle_telegram_unsupported(self, source: 'AbstractUser', intent: IntentAPI,
+                                          evt: Message, relates_to: RelatesTo = None) -> EventID:
+        override_text = ("This message is not supported on your version of Mautrix-Telegram. "
+                         "Please check https://github.com/tulir/mautrix-telegram or ask your "
+                         "bridge administrator about possible updates.")
+        content = await formatter.telegram_to_matrix(
+            evt, source, self.main_intent, override_text=override_text)
+        content.msgtype = MessageType.NOTICE
+        content.external_url = self._get_external_url(evt)
+        content["net.maunium.telegram.unsupported"] = True
+        await intent.set_typing(self.mxid, is_typing=False)
+        return await self._send_message(intent, content, timestamp=evt.date)
+
+    async def handle_telegram_poll(self, source: 'AbstractUser', intent: IntentAPI, evt: Message,
+                                   relates_to: RelatesTo) -> EventID:
+        poll: Poll = evt.media.poll
+        poll_id = self._encode_msgid(source, evt)
+
+        _n = 0
+
+        def n() -> int:
+            nonlocal _n
+            _n += 1
+            return _n
+
+        text_answers = "\n".join(f"{n()}. {answer.text}" for answer in poll.answers)
+        html_answers = "\n".join(f"<li>{answer.text}</li>" for answer in poll.answers)
+        content = TextMessageEventContent(
+            msgtype=MessageType.TEXT, format=Format.HTML,
+            body=f"Poll: {poll.question}\n{text_answers}\n"
+                 f"Vote with !tg vote {poll_id} <choice number>",
+            formatted_body=f"<strong>Poll</strong>: {poll.question}<br/>\n"
+                           f"<ol>{html_answers}</ol>\n"
+                           f"Vote with <code>!tg vote {poll_id} &lt;choice number&gt;</code>",
+            relates_to=relates_to, external_url=self._get_external_url(evt))
+
+        await intent.set_typing(self.mxid, is_typing=False)
+        return await self._send_message(intent, content, timestamp=evt.date)
+
+    @staticmethod
+    def _format_dice(roll: MessageMediaDice) -> str:
+        if roll.emoticon == "\U0001F3B0":
+            emojis = {
+                0: "\U0001F36B",  # "🍫",
+                1: "\U0001F352",  # "🍒",
+                2: "\U0001F34B",  # "🍋",
+                3: "7\ufe0f\u20e3"  # "7️⃣",
+            }
+            res = roll.value - 1
+            slot1, slot2, slot3 = emojis[res % 4], emojis[res // 4 % 4], emojis[res // 16]
+            return f"{slot1} {slot2} {slot3} ({roll.value})"
+        elif roll.emoticon == "\u26BD":
+            results = {
+                1: "miss",
+                2: "hit the woodwork",
+                3: "goal",  # seems to go in through the center
+                4: "goal",
+                5: "goal 🎉",  # seems to go in through the top right corner, includes confetti
+            }
+        elif roll.emoticon == "\U0001F3B3":
+            results = {
+                1: "miss",
+                2: "1 pin down",
+                3: "3 pins down, split",
+                4: "4 pins down, split",
+                5: "5 pins down",
+                6: "strike 🎉",
+            }
+        # elif roll.emoticon == "\U0001F3C0":
+        #     results = {
+        #         2: "rolled off",
+        #         3: "stuck",
+        #     }
+        # elif roll.emoticon == "\U0001F3AF":
+        #     results = {
+        #         1: "bounced off",
+        #         2: "outer rim",
+        #
+        #         6: "bullseye",
+        #     }
+        else:
+            return str(roll.value)
+        return f"{results[roll.value]} ({roll.value})"
+
+    async def handle_telegram_dice(self, source: 'AbstractUser', intent: IntentAPI, evt: Message,
+                                   relates_to: RelatesTo) -> EventID:
+        emoji_text = {
+            "\U0001F3AF": " Dart throw",
+            "\U0001F3B2": " Dice roll",
+            "\U0001F3C0": " Basketball throw",
+            "\U0001F3B0": " Slot machine",
+            "\U0001F3B3": " Bowling",
+            "\u26BD": " Football kick"
+        }
+        roll: MessageMediaDice = evt.media
+        text = f"{roll.emoticon}{emoji_text.get(roll.emoticon, '')} result: {self._format_dice(roll)}"
+        content = TextMessageEventContent(msgtype=MessageType.TEXT, format=Format.HTML, body=text,
+                                          formatted_body=f"<h4>{text}</h4>", relates_to=relates_to,
+                                          external_url=self._get_external_url(evt))
+        content["net.maunium.telegram.dice"] = {"emoticon": roll.emoticon, "value": roll.value}
+        await intent.set_typing(self.mxid, is_typing=False)
+        return await self._send_message(intent, content, timestamp=evt.date)
+
+    @staticmethod
+    def _int_to_bytes(i: int) -> bytes:
+        hex_value = "{0:010x}".format(i).encode("utf-8")
+        return codecs.decode(hex_value, "hex_codec")
+
+    def _encode_msgid(self, source: 'AbstractUser', evt: Message) -> str:
+        if self.peer_type == "channel":
+            play_id = (b"c"
+                       + self._int_to_bytes(self.tgid)
+                       + self._int_to_bytes(evt.id))
+        elif self.peer_type == "chat":
+            play_id = (b"g"
+                       + self._int_to_bytes(self.tgid)
+                       + self._int_to_bytes(evt.id)
+                       + self._int_to_bytes(source.tgid))
+        elif self.peer_type == "user":
+            play_id = (b"u"
+                       + self._int_to_bytes(self.tgid)
+                       + self._int_to_bytes(evt.id))
+        else:
+            raise ValueError("Portal has invalid peer type")
+        return base64.b64encode(play_id).decode("utf-8").rstrip("=")
+
+    async def handle_telegram_game(self, source: 'AbstractUser', intent: IntentAPI,
+                                   evt: Message, relates_to: RelatesTo = None) -> EventID:
+        game = evt.media.game
+        play_id = self._encode_msgid(source, evt)
+        command = f"!tg play {play_id}"
+        override_text = f"Run {command} in your bridge management room to play {game.title}"
+        override_entities = [
+            MessageEntityPre(offset=len("Run "), length=len(command), language="")]
+
+        content = await formatter.telegram_to_matrix(
+            evt, source, self.main_intent,
+            override_text=override_text, override_entities=override_entities)
+        content.msgtype = MessageType.NOTICE
+        content.external_url = self._get_external_url(evt)
+        content["net.maunium.telegram.game"] = play_id
+
+        await intent.set_typing(self.mxid, is_typing=False)
+        return await self._send_message(intent, content, timestamp=evt.date)
+
+    async def handle_telegram_edit(self, source: 'AbstractUser', sender: p.Puppet, evt: Message
+                                   ) -> None:
+        if not self.mxid:
+            self.log.trace("Ignoring edit to %d as chat has no Matrix room", evt.id)
+            return
+        elif hasattr(evt, "media") and isinstance(evt.media, MessageMediaGame):
+            self.log.debug("Ignoring game message edit event")
+            return
+
+        async with self.send_lock(sender.tgid if sender else None, required=False):
+            tg_space = self.tgid if self.peer_type == "channel" else source.tgid
+
+            temporary_identifier = EventID(
+                f"${random.randint(1000000000000, 9999999999999)}TGBRIDGEDITEMP")
+            duplicate_found = self.dedup.check(evt, (temporary_identifier, tg_space),
+                                               force_hash=True)
+            if duplicate_found:
+                mxid, other_tg_space = duplicate_found
+                if tg_space != other_tg_space:
+                    prev_edit_msg = DBMessage.get_one_by_tgid(TelegramID(evt.id), tg_space, -1)
+                    if not prev_edit_msg:
+                        return
+                    DBMessage(mxid=mxid, mx_room=self.mxid, tg_space=tg_space,
+                              tgid=TelegramID(evt.id), edit_index=prev_edit_msg.edit_index + 1
+                              ).insert()
+                return
+
+        content = await formatter.telegram_to_matrix(evt, source, self.main_intent,
+                                                     no_reply_fallback=True)
+        editing_msg = DBMessage.get_one_by_tgid(TelegramID(evt.id), tg_space)
+        if not editing_msg:
+            self.log.info(f"Didn't find edited message {evt.id}@{tg_space} (src {source.tgid}) "
+                          "in database.")
+            return
+
+        content.msgtype = (MessageType.NOTICE if (sender and sender.is_bot
+                                                  and self.get_config("bot_messages_as_notices"))
+                           else MessageType.TEXT)
+        content.external_url = self._get_external_url(evt)
+        content.set_edit(editing_msg.mxid)
+
+        intent = sender.intent_for(self) if sender else self.main_intent
+        await intent.set_typing(self.mxid, is_typing=False)
+        event_id = await self._send_message(intent, content)
+
+        prev_edit_msg = DBMessage.get_one_by_tgid(TelegramID(evt.id), tg_space, -1) or editing_msg
+        DBMessage(mxid=event_id, mx_room=self.mxid, tg_space=tg_space, tgid=TelegramID(evt.id),
+                  edit_index=prev_edit_msg.edit_index + 1).insert()
+        DBMessage.update_by_mxid(temporary_identifier, self.mxid, mxid=event_id)
+
+    @property
+    def _takeout_options(self) -> Dict[str, Union[bool, int]]:
+        return {
+            "files": True,
+            "megagroups": self.megagroup,
+            "chats": self.peer_type == "chat",
+            "users": self.peer_type == "user",
+            "channels": (self.peer_type == "channel" and not self.megagroup),
+            "max_file_size": min(config["bridge.max_document_size"], 2000) * 1024 * 1024
+        }
+
+    async def backfill(self, source: 'u.User', is_initial: bool = False,
+                       limit: Optional[int] = None, last_id: Optional[int] = None) -> None:
+        async with self.backfill_method_lock:
+            await self._locked_backfill(source, is_initial, limit, last_id)
+
+    async def _locked_backfill(self, source: 'u.User', is_initial: bool = False,
+                               limit: Optional[int] = None, last_id: Optional[int] = None) -> None:
+        limit = limit or (config["bridge.backfill.initial_limit"] if is_initial
+                          else config["bridge.backfill.missed_limit"])
+        if limit == 0:
+            return
+        if not config["bridge.backfill.normal_groups"] and self.peer_type == "chat":
+            return
+        last = DBMessage.find_last(self.mxid, (source.tgid if self.peer_type != "channel"
+                                               else self.tgid))
+        min_id = last.tgid if last else 0
+        if last_id is None:
+            messages = await source.client.get_messages(self.peer, limit=1)
+            if not messages:
+                # The chat seems empty
+                return
+            last_id = messages[0].id
+        if last_id <= min_id:
+            # Nothing to backfill
+            return
+        if limit < 0:
+            limit = last_id - min_id
+            self.log.debug(f"Backfilling approximately {last_id - min_id} messages "
+                           f"through {source.mxid}")
+        elif self.peer_type == "channel":
+            # This is a channel or supergroup, so we'll backfill messages based on the ID.
+            # There are some cases, such as deleted messages, where this may backfill less
+            # messages than the limit.
+            min_id = max(last_id - limit, min_id)
+            self.log.debug(f"Backfilling messages after ID {min_id} (last message: {last_id}) "
+                           f"through {source.mxid}")
+        else:
+            # Private chats and normal groups don't have their own message ID namespace,
+            # which means we'll have to fetch messages a different way.
+            # The _backfill_messages method will detect min_id=None and not use reverse=True
+            min_id = None
+            self.log.debug(f"Backfilling up to {limit} messages through {source.mxid}")
+        with self.backfill_lock:
+            await self._backfill(source, min_id, limit)
+
+    async def _backfill(self, source: 'u.User', min_id: Optional[int], limit: int) -> None:
+        self.backfill_leave = set()
+        if ((self.peer_type == "user" and self.tgid != source.tgid
+             and config["bridge.backfill.invite_own_puppet"])):
+            self.log.debug("Adding %s's default puppet to room for backfilling", source.mxid)
+            sender = p.Puppet.get(source.tgid)
+            await self.main_intent.invite_user(self.mxid, sender.default_mxid)
+            await sender.default_mxid_intent.join_room_by_id(self.mxid)
+            self.backfill_leave.add(sender.default_mxid_intent)
+
+        client = source.client
+        async with NotificationDisabler(self.mxid, source):
+            if limit > config["bridge.backfill.takeout_limit"]:
+                self.log.debug(f"Opening takeout client for {source.tgid}")
+                async with client.takeout(**self._takeout_options) as takeout:
+                    count = await self._backfill_messages(source, min_id, limit, takeout)
+            else:
+                count = await self._backfill_messages(source, min_id, limit, client)
+
+        for intent in self.backfill_leave:
+            self.log.trace("Leaving room with %s post-backfill", intent.mxid)
+            await intent.leave_room(self.mxid)
+        self.backfill_leave = None
+        self.log.info("Backfilled %d messages through %s", count, source.mxid)
+
+    async def _backfill_messages(self, source: 'AbstractUser', min_id: Optional[int], limit: int,
+                                 client: TelegramClient) -> int:
+        count = 0
+        entity = await self.get_input_entity(source)
+        if min_id is not None:
+            self.log.debug(f"Iterating all messages starting with {min_id} (approx: {limit})")
+            messages = client.iter_messages(entity, reverse=True, min_id=min_id)
+            async for message in messages:
+                sender = (p.Puppet.get(message.from_id.user_id)
+                          if isinstance(message.from_id, PeerUser) else None)
+                # TODO handle service messages?
+                await self.handle_telegram_message(source, sender, message)
+                count += 1
+        else:
+            self.log.debug(f"Fetching up to {limit} most recent messages")
+            messages = await client.get_messages(entity, limit=limit)
+            for message in reversed(messages):
+                sender = (p.Puppet.get(TelegramID(message.from_id.user_id))
+                          if isinstance(message.from_id, PeerUser) else None)
+                await self.handle_telegram_message(source, sender, message)
+                count += 1
+        return count
+
+    async def handle_telegram_message(self, source: 'AbstractUser', sender: p.Puppet,
+                                      evt: Message) -> None:
+        if not self.mxid:
+            self.log.trace("Got telegram message %d, but no room exists, creating...", evt.id)
+            await self.create_matrix_room(source, invites=[source.mxid], update_if_exists=False)
+
+        if (self.peer_type == "user" and sender and sender.tgid == self.tg_receiver
+            and not sender.is_real_user and not await self.az.state_store.is_joined(self.mxid,
+                                                                                    sender.mxid)):
+            self.log.debug(f"Ignoring private chat message {evt.id}@{source.tgid} as receiver does"
+                           " not have matrix puppeting and their default puppet isn't in the room")
+            return
+
+        async with self.send_lock(sender.tgid if sender else None, required=False):
+            tg_space = self.tgid if self.peer_type == "channel" else source.tgid
+
+            temporary_identifier = EventID(
+                f"${random.randint(1000000000000, 9999999999999)}TGBRIDGETEMP")
+            duplicate_found = self.dedup.check(evt, (temporary_identifier, tg_space))
+            if duplicate_found:
+                mxid, other_tg_space = duplicate_found
+                self.log.debug(f"Ignoring message {evt.id}@{tg_space} (src {source.tgid}) "
+                               f"as it was already handled (in space {other_tg_space})")
+                if tg_space != other_tg_space:
+                    DBMessage(tgid=TelegramID(evt.id), mx_room=self.mxid, mxid=mxid,
+                              tg_space=tg_space, edit_index=0).insert()
+                return
+
+        if self.backfill_lock.locked or (self.dedup.pre_db_check and self.peer_type == "channel"):
+            msg = DBMessage.get_one_by_tgid(TelegramID(evt.id), tg_space)
+            if msg:
+                self.log.debug(f"Ignoring message {evt.id} (src {source.tgid}) as it was already "
+                               f"handled into {msg.mxid}. This duplicate was catched in the db "
+                               "check. If you get this message often, consider increasing "
+                               "bridge.deduplication.cache_queue_length in the config.")
+                return
+
+        self.log.trace("Handling Telegram message %s", evt)
+
+        if sender and not sender.displayname:
+            self.log.debug(f"Telegram user {sender.tgid} sent a message, but doesn't have a "
+                           "displayname, updating info...")
+            entity = await source.client.get_entity(PeerUser(sender.tgid))
+            await sender.update_info(source, entity)
+            if not sender.displayname:
+                self.log.debug(f"Telegram user {sender.tgid} doesn't have a displayname even after"
+                               f" updating with data {entity!s}")
+
+        allowed_media = (MessageMediaPhoto, MessageMediaDocument, MessageMediaGeo,
+                         MessageMediaGame, MessageMediaDice, MessageMediaPoll,
+                         MessageMediaUnsupported)
+        media = evt.media if hasattr(evt, "media") and isinstance(evt.media,
+                                                                  allowed_media) else None
+        if sender:
+            intent = sender.intent_for(self)
+            if ((self.backfill_lock.locked and intent != sender.default_mxid_intent
+                 and config["bridge.backfill.invite_own_puppet"])):
+                intent = sender.default_mxid_intent
+                self.backfill_leave.add(intent)
+        else:
+            intent = self.main_intent
+        if not media and evt.message:
+            is_bot = sender.is_bot if sender else False
+            event_id = await self.handle_telegram_text(source, intent, is_bot, evt)
+        elif media:
+            event_id = await {
+                MessageMediaPhoto: self.handle_telegram_photo,
+                MessageMediaDocument: self.handle_telegram_document,
+                MessageMediaGeo: self.handle_telegram_location,
+                MessageMediaPoll: self.handle_telegram_poll,
+                MessageMediaDice: self.handle_telegram_dice,
+                MessageMediaUnsupported: self.handle_telegram_unsupported,
+                MessageMediaGame: self.handle_telegram_game,
+            }[type(media)](source, intent, evt,
+                           relates_to=formatter.telegram_reply_to_matrix(evt, source))
+        else:
+            self.log.debug("Unhandled Telegram message %d", evt.id)
+            return
+
+        if not event_id:
+            return
+
+        prev_id = self.dedup.update(evt, (event_id, tg_space), (temporary_identifier, tg_space))
+        if prev_id:
+            self.log.debug(f"Sent message {evt.id}@{tg_space} to Matrix as {event_id}. "
+                           f"Temporary dedup identifier was {temporary_identifier}, "
+                           f"but dedup map contained {prev_id[1]} instead! -- "
+                           "This was probably a race condition caused by Telegram sending updates"
+                           "to other clients before responding to the sender. I'll just redact "
+                           "the likely duplicate message now.")
+            await intent.redact(self.mxid, event_id)
+            return
+
+        self.log.debug("Handled telegram message %d -> %s", evt.id, event_id)
+        try:
+            DBMessage(tgid=TelegramID(evt.id), mx_room=self.mxid, mxid=event_id,
+                      tg_space=tg_space, edit_index=0).insert()
+            DBMessage.update_by_mxid(temporary_identifier, self.mxid, mxid=event_id)
+        except IntegrityError as e:
+            self.log.exception(f"{e.__class__.__name__} while saving message mapping. "
+                               "This might mean that an update was handled after it left the "
+                               "dedup cache queue. You can try enabling bridge.deduplication."
+                               "pre_db_check in the config.")
+            await intent.redact(self.mxid, event_id)
+        await self._send_delivery_receipt(event_id)
+
+    async def _create_room_on_action(self, source: 'AbstractUser',
+                                     action: TypeMessageAction) -> bool:
+        if source.is_relaybot and config["bridge.ignore_unbridged_group_chat"]:
+            return False
+        create_and_exit = (MessageActionChatCreate, MessageActionChannelCreate)
+        create_and_continue = (MessageActionChatAddUser, MessageActionChatJoinedByLink)
+        if isinstance(action, create_and_exit) or isinstance(action, create_and_continue):
+            await self.create_matrix_room(source, invites=[source.mxid],
+                                          update_if_exists=isinstance(action, create_and_exit))
+        if not isinstance(action, create_and_continue):
+            return False
+        return True
+
+    async def handle_telegram_action(self, source: 'AbstractUser', sender: p.Puppet,
+                                     update: MessageService) -> None:
+        action = update.action
+        should_ignore = ((not self.mxid and not await self._create_room_on_action(source, action))
+                         or self.dedup.check_action(update))
+        if should_ignore or not self.mxid:
+            return
+        if isinstance(action, MessageActionChatEditTitle):
+            await self._update_title(action.title, sender=sender, save=True)
+            await self.update_bridge_info()
+        elif isinstance(action, MessageActionChatEditPhoto):
+            await self._update_avatar(source, action.photo, sender=sender, save=True)
+            await self.update_bridge_info()
+        elif isinstance(action, MessageActionChatDeletePhoto):
+            await self._update_avatar(source, ChatPhotoEmpty(), sender=sender, save=True)
+            await self.update_bridge_info()
+        elif isinstance(action, MessageActionChatAddUser):
+            for user_id in action.users:
+                await self._add_telegram_user(TelegramID(user_id), source)
+        elif isinstance(action, MessageActionChatJoinedByLink):
+            await self._add_telegram_user(sender.id, source)
+        elif isinstance(action, MessageActionChatDeleteUser):
+            await self._delete_telegram_user(TelegramID(action.user_id), sender)
+        elif isinstance(action, MessageActionChatMigrateTo):
+            self.peer_type = "channel"
+            self._migrate_and_save_telegram(TelegramID(action.channel_id))
+            # TODO encrypt
+            await sender.intent_for(self).send_emote(self.mxid,
+                                                     "upgraded this group to a supergroup.")
+            await self.update_bridge_info()
+        elif isinstance(action, MessageActionGameScore):
+            # TODO handle game score
+            pass
+        else:
+            self.log.trace("Unhandled Telegram action in %s: %s", self.title, action)
+
+    async def set_telegram_admin(self, user_id: TelegramID) -> None:
+        puppet = p.Puppet.get(user_id)
+        user = u.User.get_by_tgid(user_id)
+
+        levels = await self.main_intent.get_power_levels(self.mxid)
+        if user:
+            levels.users[user.mxid] = 50
+        if puppet:
+            levels.users[puppet.mxid] = 50
+        await self.main_intent.set_power_levels(self.mxid, levels)
+
+    async def receive_telegram_pin_ids(self, msg_ids: List[TelegramID], receiver: TelegramID,
+                                       remove: bool) -> None:
+        async with self._pin_lock:
+            tg_space = receiver if self.peer_type != "channel" else self.tgid
+            previously_pinned = await self.main_intent.get_pinned_messages(self.mxid)
+            currently_pinned_dict = {event_id: True for event_id in previously_pinned}
+            for message in DBMessage.get_first_by_tgids(msg_ids, tg_space):
+                if remove:
+                    currently_pinned_dict.pop(message.mxid, None)
+                else:
+                    currently_pinned_dict[message.mxid] = True
+            currently_pinned = list(currently_pinned_dict.keys())
+            if currently_pinned != previously_pinned:
+                await self.main_intent.set_pinned_messages(self.mxid, currently_pinned)
+
+    async def set_telegram_admins_enabled(self, enabled: bool) -> None:
+        level = 50 if enabled else 10
+        levels = await self.main_intent.get_power_levels(self.mxid)
+        levels.invite = level
+        levels.events[EventType.ROOM_NAME] = level
+        levels.events[EventType.ROOM_AVATAR] = level
+        await self.main_intent.set_power_levels(self.mxid, levels)
+
+
+def init(context: Context) -> None:
+    global config
+    config = context.config
+    NotificationDisabler.puppet_cls = p.Puppet
+    NotificationDisabler.config_enabled = config["bridge.backfill.disable_notifications"]

mautrix_telegram/puppet.py

@@ -1,6 +1,5 @@
-# -*- coding: future_fstrings -*-
 # mautrix-telegram - A Matrix-Telegram puppeting bridge
-# Copyright (C) 2018 Tulir Asokan
+# Copyright (C) 2020 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
@@ -14,23 +13,26 @@
 #
 # 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 (Awaitable, Coroutine, Dict, List, Iterable, Optional, Pattern, Union,
-                    TYPE_CHECKING)
+from typing import Awaitable, Any, Dict, Iterable, Optional, Union, Tuple, TYPE_CHECKING
 from difflib import SequenceMatcher
-from enum import Enum
-from aiohttp import ServerDisconnectedError
+import unicodedata
 import asyncio
 import logging
-import re
 
-from sqlalchemy import orm
+from telethon.tl.types import (UserProfilePhoto, User, UpdateUserName, PeerUser, TypeInputPeer,
+                               InputPeerPhotoFileLocation, UserProfilePhotoEmpty, TypeInputUser)
+from yarl import URL
 
-from telethon.tl.types import UserProfilePhoto, User, FileLocation, UpdateUserName, PeerUser
-from mautrix_appservice import AppService, IntentAPI, IntentError, MatrixRequestError
+from mautrix.appservice import AppService, IntentAPI
+from mautrix.errors import MatrixRequestError, MatrixError
+from mautrix.bridge import BasePuppet
+from mautrix.types import UserID, SyncToken, RoomID, ContentURI
+from mautrix.util.simple_template import SimpleTemplate
+from mautrix.util.logging import TraceLogger
 
-from .types import MatrixUserID, TelegramID
+from .types import TelegramID
 from .db import Puppet as DBPuppet
-from . import util
+from . import util, portal as p
 
 if TYPE_CHECKING:
     from .matrix import MatrixHandler
@@ -38,67 +40,105 @@ if TYPE_CHECKING:
     from .context import Context
     from .abstract_user import AbstractUser
 
-PuppetError = Enum('PuppetError', 'Success OnlyLoginSelf InvalidAccessToken')
-
-config = None  # type: Config
+config: Optional['Config'] = None
 
 
-class Puppet:
-    log = logging.getLogger("mau.puppet")  # type: logging.Logger
-    db = None  # type: orm.Session
-    az = None  # type: AppService
-    mx = None  # type: MatrixHandler
-    loop = None  # type: asyncio.AbstractEventLoop
-    mxid_regex = None  # type: Pattern
-    username_template = None  # type: str
-    hs_domain = None  # type: str
-    cache = {}  # type: Dict[TelegramID, Puppet]
-    by_custom_mxid = {}  # type: Dict[str, Puppet]
+class Puppet(BasePuppet):
+    log: TraceLogger = logging.getLogger("mau.puppet")
+    az: AppService
+    mx: 'MatrixHandler'
+    loop: asyncio.AbstractEventLoop
+    hs_domain: str
+    mxid_template: SimpleTemplate[TelegramID]
+    displayname_template: SimpleTemplate[str]
+
+    cache: Dict[TelegramID, 'Puppet'] = {}
+    by_custom_mxid: Dict[UserID, 'Puppet'] = {}
+
+    id: TelegramID
+    access_token: Optional[str]
+    custom_mxid: Optional[UserID]
+    _next_batch: Optional[SyncToken]
+    base_url: Optional[URL]
+    default_mxid: UserID
+
+    username: Optional[str]
+    displayname: Optional[str]
+    displayname_source: Optional[TelegramID]
+    displayname_contact: bool
+    displayname_quality: int
+    photo_id: Optional[str]
+    is_bot: bool
+    is_registered: bool
+    disable_updates: bool
+
+    default_mxid_intent: IntentAPI
+    intent: IntentAPI
+
+    sync_task: Optional[asyncio.Future]
+
+    _db_instance: Optional[DBPuppet]
 
     def __init__(self,
                  id: TelegramID,
                  access_token: Optional[str] = None,
-                 custom_mxid: Optional[MatrixUserID] = None,
+                 custom_mxid: Optional[UserID] = None,
+                 next_batch: Optional[SyncToken] = None,
+                 base_url: Optional[str] = None,
                  username: Optional[str] = None,
                  displayname: Optional[str] = None,
                  displayname_source: Optional[TelegramID] = None,
+                 displayname_contact: bool = True,
+                 displayname_quality: int = 0,
                  photo_id: Optional[str] = None,
                  is_bot: bool = False,
                  is_registered: bool = False,
+                 disable_updates: bool = False,
                  db_instance: Optional[DBPuppet] = None) -> None:
-        self.id = id  # type: TelegramID
-        self.access_token = access_token  # type: Optional[str]
-        self.custom_mxid = custom_mxid  # type: Optional[MatrixUserID]
-        self.default_mxid = self.get_mxid_from_id(self.id)  # type: MatrixUserID
+        self.id = id
+        self.access_token = access_token
+        self.custom_mxid = custom_mxid
+        self._next_batch = next_batch
+        self.base_url = URL(base_url) if base_url else None
+        self.default_mxid = self.get_mxid_from_id(self.id)
 
-        self.username = username  # type: Optional[str]
-        self.displayname = displayname  # type: Optional[str]
-        self.displayname_source = displayname_source  # type: Optional[TelegramID]
-        self.photo_id = photo_id  # type: Optional[str]
-        self.is_bot = is_bot  # type: bool
-        self.is_registered = is_registered  # type: bool
-        self._db_instance = db_instance  # type: Optional[DBPuppet]
+        self.username = username
+        self.displayname = displayname
+        self.displayname_source = displayname_source
+        self.displayname_contact = displayname_contact
+        self.displayname_quality = displayname_quality
+        self.photo_id = photo_id
+        self.is_bot = is_bot
+        self.is_registered = is_registered
+        self.disable_updates = disable_updates
+        self._db_instance = db_instance
 
         self.default_mxid_intent = self.az.intent.user(self.default_mxid)
-        self.intent = self._fresh_intent()  # type: IntentAPI
-        self.sync_task = None  # type: Optional[asyncio.Future]
+        self.intent = self._fresh_intent()
+        self.sync_task = None
 
         self.cache[id] = self
         if self.custom_mxid:
             self.by_custom_mxid[self.custom_mxid] = self
 
-    @property
-    def mxid(self) -> MatrixUserID:
-        return self.custom_mxid or self.default_mxid
+        self.log = self.log.getChild(str(self.id))
 
     @property
     def tgid(self) -> TelegramID:
         return self.id
 
     @property
-    def is_real_user(self) -> bool:
-        """ Is True when the puppet is a real Matrix user. """
-        return bool(self.custom_mxid and self.access_token)
+    def peer(self) -> PeerUser:
+        return PeerUser(user_id=self.tgid)
+
+    @property
+    def next_batch(self) -> SyncToken:
+        return self._next_batch
+
+    @next_batch.setter
+    def next_batch(self, value: SyncToken) -> None:
+        self._next_batch = value
+        self.db_instance.edit(next_batch=self._next_batch)
 
     @staticmethod
     async def is_logged_in() -> bool:
@@ -107,172 +147,17 @@ class Puppet:
 
     @property
     def plain_displayname(self) -> str:
-        tpl = config["bridge.displayname_template"]
-        if tpl == "{displayname}":
-            # Template has no extra stuff, no need to parse.
-            return self.displayname
-        regex = re.compile("^" + re.escape(tpl).replace(re.escape("{displayname}"), "(.+?)") + "$")
-        match = regex.match(self.displayname)
-        return match.group(1) or self.displayname
+        return self.displayname_template.parse(self.displayname) or self.displayname
 
-    # region Custom puppet management
-    def _fresh_intent(self) -> IntentAPI:
-        return (self.az.intent.user(self.custom_mxid, self.access_token)
-                if self.is_real_user else self.default_mxid_intent)
+    def get_input_entity(self, user: 'AbstractUser'
+                         ) -> Awaitable[Union[TypeInputPeer, TypeInputUser]]:
+        return user.client.get_input_entity(self.peer)
 
-    async def switch_mxid(self, access_token: Optional[str],
-                          mxid: Optional[MatrixUserID]) -> PuppetError:
-        prev_mxid = self.custom_mxid
-        self.custom_mxid = mxid
-        self.access_token = access_token
-        self.intent = self._fresh_intent()
+    def intent_for(self, portal: 'p.Portal') -> IntentAPI:
+        if portal.tgid == self.tgid:
+            return self.default_mxid_intent
+        return self.intent
 
-        err = await self.init_custom_mxid()
-        if err != PuppetError.Success:
-            return err
-
-        try:
-            del self.by_custom_mxid[prev_mxid]  # type: ignore
-        except KeyError:
-            pass
-        if self.mxid != self.default_mxid:
-            self.by_custom_mxid[self.mxid] = self
-            await self.leave_rooms_with_default_user()
-        self.save()
-        return PuppetError.Success
-
-    async def init_custom_mxid(self) -> PuppetError:
-        if not self.is_real_user:
-            return PuppetError.Success
-
-        mxid = await self.intent.whoami()
-        if not mxid or mxid != self.custom_mxid:
-            self.custom_mxid = None
-            self.access_token = None
-            self.intent = self._fresh_intent()
-            if mxid != self.custom_mxid:
-                return PuppetError.OnlyLoginSelf
-            return PuppetError.InvalidAccessToken
-        if config["bridge.sync_with_custom_puppets"]:
-            self.sync_task = asyncio.ensure_future(self.sync(), loop=self.loop)
-        return PuppetError.Success
-
-    async def leave_rooms_with_default_user(self) -> None:
-        for room_id in await self.default_mxid_intent.get_joined_rooms():
-            try:
-                await self.default_mxid_intent.leave_room(room_id)
-                await self.intent.ensure_joined(room_id)
-            except (IntentError, MatrixRequestError):
-                pass
-
-    def create_sync_filter(self) -> Awaitable[str]:
-        return self.intent.client.create_filter(self.custom_mxid, {
-            "room": {
-                "include_leave": False,
-                "state": {
-                    "types": []
-                },
-                "timeline": {
-                    "types": [],
-                },
-                "ephemeral": {
-                    "types": ["m.typing", "m.receipt"],
-                },
-                "account_data": {
-                    "types": []
-                }
-            },
-            "account_data": {
-                "types": [],
-            },
-            "presence": {
-                "types": ["m.presence"],
-                "senders": [self.custom_mxid],
-            },
-        })
-
-    def filter_events(self, events: List[Dict]) -> List:
-        new_events = []
-        for event in events:
-            evt_type = event.get("type", None)
-            event.setdefault("content", {})
-            if evt_type == "m.typing":
-                is_typing = self.custom_mxid in event["content"].get("user_ids", [])
-                event["content"]["user_ids"] = [self.custom_mxid] if is_typing else []
-            elif evt_type == "m.receipt":
-                val = None
-                evt = None
-                for event_id in event["content"]:
-                    try:
-                        val = event["content"][event_id]["m.read"][self.custom_mxid]
-                        evt = event_id
-                        break
-                    except KeyError:
-                        pass
-                if val and evt:
-                    event["content"] = {evt: {"m.read": {
-                        self.custom_mxid: val
-                    }}}
-                else:
-                    continue
-            new_events.append(event)
-        return new_events
-
-    def handle_sync(self, presence: List, ephemeral: Dict) -> None:
-        presence_events = [self.mx.try_handle_event(event) for event in presence]
-
-        for room_id, events in ephemeral.items():
-            for event in events:
-                event["room_id"] = room_id
-
-        ephemeral_events = [self.mx.try_handle_event(event)
-                            for events in ephemeral.values()
-                            for event in self.filter_events(events)]
-
-        events = ephemeral_events + presence_events  # List[Callable[[int], Awaitable[None]]]
-        coro = asyncio.gather(*events, loop=self.loop)
-        asyncio.ensure_future(coro, loop=self.loop)
-
-    async def sync(self) -> None:
-        try:
-            await self._sync()
-        except asyncio.CancelledError:
-            self.log.info("Syncing cancelled")
-        except Exception:
-            self.log.exception("Fatal error syncing")
-
-    async def _sync(self) -> None:
-        if not self.is_real_user:
-            self.log.warning("Called sync() for non-custom puppet.")
-            return
-        custom_mxid = self.custom_mxid
-        access_token_at_start = self.access_token
-        errors = 0
-        next_batch = None
-        filter_id = await self.create_sync_filter()
-        self.log.debug(f"Starting syncer for {custom_mxid} with sync filter {filter_id}.")
-        while access_token_at_start == self.access_token:
-            try:
-                sync_resp = await self.intent.client.sync(filter=filter_id, since=next_batch,
-                                                          set_presence="offline")  # type: Dict
-                errors = 0
-                if next_batch is not None:
-                    presence = sync_resp.get("presence", {}).get("events", [])  # type: List
-                    ephemeral = {room: data.get("ephemeral", {}).get("events", [])
-                                 for room, data
-                                 in sync_resp.get("rooms", {}).get("join", {}).items()
-                                 }  # type: Dict
-                    self.handle_sync(presence, ephemeral)
-                next_batch = sync_resp.get("next_batch", None)
-            except (MatrixRequestError, ServerDisconnectedError) as e:
-                wait = min(errors, 11) ** 2
-                self.log.warning(f"Syncer for {custom_mxid} errored: {e}. "
-                                 f"Waiting for {wait} seconds...")
-                errors += 1
-                await asyncio.sleep(wait)
-        self.log.debug(f"Syncer for custom puppet {custom_mxid} stopped.")
-
-    # endregion
     # region DB conversion
 
     @property
@@ -281,27 +166,34 @@ class Puppet:
             self._db_instance = self.new_db_instance()
         return self._db_instance
 
+    @property
+    def _fields(self) -> Dict[str, Any]:
+        return dict(access_token=self.access_token, next_batch=self._next_batch,
+                    custom_mxid=self.custom_mxid, username=self.username, is_bot=self.is_bot,
+                    displayname=self.displayname, displayname_source=self.displayname_source,
+                    displayname_contact=self.displayname_contact,
+                    displayname_quality=self.displayname_quality, photo_id=self.photo_id,
+                    matrix_registered=self.is_registered, disable_updates=self.disable_updates,
+                    base_url=str(self.base_url) if self.base_url else None)
+
     def new_db_instance(self) -> DBPuppet:
-        return DBPuppet(id=self.id, access_token=self.access_token, custom_mxid=self.custom_mxid,
-                        username=self.username, displayname=self.displayname,
-                        displayname_source=self.displayname_source, photo_id=self.photo_id,
-                        is_bot=self.is_bot, matrix_registered=self.is_registered)
+        return DBPuppet(id=self.id, **self._fields)
+
+    async def save(self) -> None:
+        self.db_instance.edit(**self._fields)
 
     @classmethod
     def from_db(cls, db_puppet: DBPuppet) -> 'Puppet':
         return Puppet(db_puppet.id, db_puppet.access_token, db_puppet.custom_mxid,
-                      db_puppet.username, db_puppet.displayname, db_puppet.displayname_source,
+                      db_puppet.next_batch, db_puppet.base_url, db_puppet.username,
+                      db_puppet.displayname, db_puppet.displayname_source,
+                      db_puppet.displayname_contact, db_puppet.displayname_quality,
                       db_puppet.photo_id, db_puppet.is_bot, db_puppet.matrix_registered,
-                      db_instance=db_puppet)
-
-    def save(self) -> None:
-        self.db_instance.update(access_token=self.access_token, custom_mxid=self.custom_mxid,
-                                username=self.username, displayname=self.displayname,
-                                displayname_source=self.displayname_source, photo_id=self.photo_id,
-                                is_bot=self.is_bot, matrix_registered=self.is_registered)
+                      db_puppet.disable_updates, db_instance=db_puppet)
 
     # endregion
     # region Info updating
+
     def similarity(self, query: str) -> int:
         username_similarity = (SequenceMatcher(None, self.username, query).ratio()
                                if self.username else 0)
@@ -311,31 +203,50 @@ class Puppet:
         return int(round(similarity * 100))
 
     @staticmethod
-    def get_displayname(info: User, enable_format: bool = True) -> str:
+    def _filter_name(name: str) -> str:
+        if not name:
+            return ""
+        whitespace = ("\t\n\r\v\f \u00a0\u034f\u180e\u2063\u202f\u205f\u2800\u3000\u3164\ufeff"
+                      "\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b"
+                      "\u200c\u200d\u200e\u200f\ufe0f")
+        name = "".join(c for c in name.strip(whitespace) if unicodedata.category(c) != 'Cf')
+        return name
+
+    @classmethod
+    def get_displayname(cls, info: User, enable_format: bool = True) -> Tuple[str, int]:
+        fn = cls._filter_name(info.first_name)
+        ln = cls._filter_name(info.last_name)
         data = {
             "phone number": info.phone if hasattr(info, "phone") else None,
             "username": info.username,
-            "full name": " ".join([info.first_name or "", info.last_name or ""]).strip(),
-            "full name reversed": " ".join([info.first_name or "", info.last_name or ""]).strip(),
-            "first name": info.first_name,
-            "last name": info.last_name,
+            "full name": " ".join([fn, ln]).strip(),
+            "full name reversed": " ".join([ln, fn]).strip(),
+            "first name": fn,
+            "last name": ln,
         }
         preferences = config["bridge.displayname_preference"]
         name = None
+        quality = 99
         for preference in preferences:
             name = data[preference]
             if name:
                 break
+            quality -= 1
 
         if isinstance(info, User) and info.deleted:
             name = f"Deleted account {info.id}"
+            quality = 99
         elif not name:
-            name = info.id
+            name = str(info.id)
+            quality = 0
 
-        if not enable_format:
-            return name
-        return config["bridge.displayname_template"].format(
-            displayname=name)
+        return (cls.displayname_template.format_full(name) if enable_format else name), quality
+
+    async def try_update_info(self, source: 'AbstractUser', info: User) -> None:
+        try:
+            await self.update_info(source, info)
+        except Exception:
+            source.log.exception(f"Failed to update info of {self.tgid}")
 
     async def update_info(self, source: 'AbstractUser', info: User) -> None:
         changed = False
@@ -343,47 +254,113 @@ class Puppet:
             self.username = info.username
             changed = True
 
-        changed = await self.update_displayname(source, info) or changed
-        if isinstance(info.photo, UserProfilePhoto):
-            changed = await self.update_avatar(source, info.photo.photo_big) or changed
+        if not self.disable_updates:
+            try:
+                changed = await self.update_displayname(source, info) or changed
+                changed = await self.update_avatar(source, info.photo) or changed
+            except Exception:
+                self.log.exception(f"Failed to update info from source {source.tgid}")
 
         self.is_bot = info.bot
 
         if changed:
-            self.save()
+            await self.save()
 
     async def update_displayname(self, source: 'AbstractUser', info: Union[User, UpdateUserName]
                                  ) -> bool:
-        ignore_source = (not source.is_relaybot
-                         and self.displayname_source is not None
-                         and self.displayname_source != source.tgid)
-        if ignore_source:
+        if self.disable_updates:
             return False
+        if source.is_relaybot or source.is_bot:
+            allow_because = "user is bot"
+        elif self.displayname_source == source.tgid:
+            allow_because = "user is the primary source"
+        elif not isinstance(info, UpdateUserName) and not info.contact:
+            allow_because = "user is not a contact"
+        elif not self.displayname_source:
+            allow_because = "no primary source set"
+        elif not self.displayname:
+            allow_because = "user has no name"
+        else:
+            return False
+
         if isinstance(info, UpdateUserName):
             info = await source.client.get_entity(PeerUser(self.tgid))
+        if not info.contact:
+            self.displayname_contact = False
+        elif not self.displayname_contact:
+            if not self.displayname:
+                self.displayname_contact = True
+            else:
+                return False
 
-        displayname = self.get_displayname(info)
-        if displayname != self.displayname:
-            await self.default_mxid_intent.set_display_name(displayname)
+        displayname, quality = self.get_displayname(info)
+        if displayname != self.displayname and quality >= self.displayname_quality:
+            allow_because = f"{allow_because} and quality {quality} >= {self.displayname_quality}"
+            self.log.debug(f"Updating displayname of {self.id} (src: {source.tgid}, allowed "
+                           f"because {allow_because}) from {self.displayname} to {displayname}")
+            self.log.trace("Displayname source data: %s", info)
             self.displayname = displayname
             self.displayname_source = source.tgid
+            self.displayname_quality = quality
+            try:
+                await self.default_mxid_intent.set_displayname(
+                    displayname[:config["bridge.displayname_max_length"]])
+            except MatrixError:
+                self.log.exception("Failed to set displayname")
+                self.displayname = ""
+                self.displayname_source = None
+                self.displayname_quality = 0
             return True
         elif source.is_relaybot or self.displayname_source is None:
             self.displayname_source = source.tgid
             return True
         return False
 
-    async def update_avatar(self, source: 'AbstractUser', photo: FileLocation) -> bool:
-        photo_id = f"{photo.volume_id}-{photo.local_id}"
+    async def update_avatar(self, source: 'AbstractUser',
+                            photo: Union[UserProfilePhoto, UserProfilePhotoEmpty]) -> bool:
+        if self.disable_updates:
+            return False
+
+        if photo is None or isinstance(photo, UserProfilePhotoEmpty):
+            photo_id = ""
+        elif isinstance(photo, UserProfilePhoto):
+            photo_id = str(photo.photo_id)
+        else:
+            self.log.warning(f"Unknown user profile photo type: {type(photo)}")
+            return False
+        if not photo_id and not config["bridge.allow_avatar_remove"]:
+            return False
         if self.photo_id != photo_id:
-            file = await util.transfer_file_to_matrix(source.client, self.default_mxid_intent,
-                                                      photo)
+            if not photo_id:
+                self.photo_id = ""
+                try:
+                    await self.default_mxid_intent.set_avatar_url(ContentURI(""))
+                except MatrixError:
+                    self.log.exception("Failed to set avatar")
+                    self.photo_id = ""
+                return True
+
+            loc = InputPeerPhotoFileLocation(
+                peer=await self.get_input_entity(source),
+                local_id=photo.photo_big.local_id,
+                volume_id=photo.photo_big.volume_id,
+                big=True
+            )
+            file = await util.transfer_file_to_matrix(source.client, self.default_mxid_intent, loc)
             if file:
-                await self.default_mxid_intent.set_avatar(file.mxc)
                 self.photo_id = photo_id
+                try:
+                    await self.default_mxid_intent.set_avatar_url(file.mxc)
+                except MatrixError:
+                    self.log.exception("Failed to set avatar")
+                    self.photo_id = ""
                 return True
         return False
 
+    async def default_puppet_should_leave_room(self, room_id: RoomID) -> bool:
+        portal: p.Portal = p.Portal.get_by_mxid(room_id)
+        return portal and not portal.backfill_lock.locked and portal.peer_type != "user"
+
     # endregion
     # region Getters
 
@@ -400,14 +377,13 @@ class Puppet:
 
         if create:
             puppet = cls(tgid)
-            cls.db.add(puppet.db_instance)
-            cls.db.commit()
+            puppet.db_instance.insert()
             return puppet
 
         return None
 
     @classmethod
-    def get_by_mxid(cls, mxid: MatrixUserID, create: bool = True) -> Optional['Puppet']:
+    def deprecated_sync_get_by_mxid(cls, mxid: UserID, create: bool = True) -> Optional['Puppet']:
         tgid = cls.get_id_from_mxid(mxid)
         if tgid:
             return cls.get(tgid, create)
@@ -415,7 +391,11 @@ class Puppet:
         return None
 
     @classmethod
-    def get_by_custom_mxid(cls, mxid: MatrixUserID) -> Optional['Puppet']:
+    async def get_by_mxid(cls, mxid: UserID, create: bool = True) -> Optional['Puppet']:
+        return cls.deprecated_sync_get_by_mxid(mxid, create)
+
+    @classmethod
+    def deprecated_sync_get_by_custom_mxid(cls, mxid: UserID) -> Optional['Puppet']:
         if not mxid:
             raise ValueError("Matrix ID can't be empty")
 
@@ -431,31 +411,34 @@ class Puppet:
 
         return None
 
+    @classmethod
+    async def get_by_custom_mxid(cls, mxid: UserID) -> Optional['Puppet']:
+        return cls.deprecated_sync_get_by_custom_mxid(mxid)
+
     @classmethod
     def all_with_custom_mxid(cls) -> Iterable['Puppet']:
-        return (cls.by_custom_mxid[puppet.mxid]
+        return (cls.by_custom_mxid[puppet.custom_mxid]
                 if puppet.custom_mxid in cls.by_custom_mxid
                 else cls.from_db(puppet)
                 for puppet in DBPuppet.all_with_custom_mxid())
 
     @classmethod
-    def get_id_from_mxid(cls, mxid: MatrixUserID) -> Optional[TelegramID]:
-        match = cls.mxid_regex.match(mxid)
-        if match:
-            return TelegramID(int(match.group(1)))
-        return None
+    def get_id_from_mxid(cls, mxid: UserID) -> Optional[TelegramID]:
+        return cls.mxid_template.parse(mxid)
 
     @classmethod
-    def get_mxid_from_id(cls, tgid: TelegramID) -> MatrixUserID:
-        return MatrixUserID(f"@{cls.username_template.format(userid=tgid)}:{cls.hs_domain}")
+    def get_mxid_from_id(cls, tgid: TelegramID) -> UserID:
+        return UserID(cls.mxid_template.format_full(tgid))
 
     @classmethod
     def find_by_username(cls, username: str) -> Optional['Puppet']:
         if not username:
             return None
 
+        username = username.lower()
+
         for _, puppet in cls.cache.items():
-            if puppet.username and puppet.username.lower() == username.lower():
+            if puppet.username and puppet.username.lower() == username:
                 return puppet
 
         dbpuppet = DBPuppet.get_by_username(username)
@@ -481,12 +464,23 @@ class Puppet:
     # endregion
 
 
-def init(context: 'Context') -> List[Coroutine]:  # [None, None, PuppetError]
+def init(context: 'Context') -> Iterable[Awaitable[Any]]:
     global config
-    Puppet.az, Puppet.db, config, Puppet.loop, _ = context.core
+    Puppet.az, config, Puppet.loop, _ = context.core
     Puppet.mx = context.mx
-    Puppet.username_template = config.get("bridge.username_template", "telegram_{userid}")
     Puppet.hs_domain = config["homeserver"]["domain"]
-    Puppet.mxid_regex = re.compile(
-        f"@{Puppet.username_template.format(userid='([0-9]+)')}:{Puppet.hs_domain}")
-    return [puppet.init_custom_mxid() for puppet in Puppet.all_with_custom_mxid()]
+
+    Puppet.mxid_template = SimpleTemplate(config["bridge.username_template"], "userid",
+                                          prefix="@", suffix=f":{Puppet.hs_domain}", type=int)
+    Puppet.displayname_template = SimpleTemplate(config["bridge.displayname_template"],
+                                                 "displayname")
+
+    Puppet.sync_with_custom_puppets = config["bridge.sync_with_custom_puppets"]
+    Puppet.homeserver_url_map = {server: URL(url) for server, url
+                                 in config["bridge.double_puppet_server_map"].items()}
+    Puppet.allow_discover_url = config["bridge.double_puppet_allow_discovery"]
+    Puppet.login_shared_secret_map = {server: secret.encode("utf-8") for server, secret
+                                      in config["bridge.login_shared_secret_map"].items()}
+    Puppet.login_device_name = "Telegram Bridge"
+
+    return (puppet.try_start() for puppet in Puppet.all_with_custom_mxid())