Remove custom send_message() function

mautrix_telegram/bot.py

@@ -201,8 +201,7 @@ class Bot(AbstractUser):
 
     async def handle_command(self, message: Message):
         def reply(reply_text):
-            return self.client.send_message(message.to_id, reply_text, markdown=True,
+            return self.client.send_message(message.to_id, reply_text, reply_to=message.id)
-                                            reply_to=message.id)
 
         text = message.message
 

mautrix_telegram/formatter/from_matrix.py

@@ -22,11 +22,10 @@ import math
 import re
 import logging
 
-from telethon.tl.types import (MessageEntityMention,
+from telethon.tl.types import (MessageEntityMention, MessageEntityMentionName, MessageEntityEmail,
-                               InputMessageEntityMentionName, MessageEntityEmail,
                                MessageEntityUrl, MessageEntityTextUrl, MessageEntityBold,
                                MessageEntityItalic, MessageEntityCode, MessageEntityPre,
-                               MessageEntityBotCommand, InputUser, TypeMessageEntity)
+                               MessageEntityBotCommand, TypeMessageEntity)
 
 from ..context import Context
 from .. import user as u, puppet as pu, portal as po
@@ -69,8 +68,8 @@ class MatrixParser(HTMLParser):
             if user.username:
                 return MessageEntityMention, f"@{user.username}"
             elif user.tgid:
-                args["user_id"] = InputUser(user.tgid, 0)
+                args["user_id"] = user.tgid
-                return InputMessageEntityMentionName, user.displayname or None
+                return MessageEntityMentionName, user.displayname or None
             else:
                 return None, None
 
@@ -260,6 +259,22 @@ def plain_mention_to_html(match):
     return "".join(match.groups())
 
 
+def cut_long_message(message: str, entities: List[TypeMessageEntity]
+                     ) -> Tuple[str, List[TypeMessageEntity]]:
+    if len(message) > 4096:
+        message = message[0:4082] + " [message cut]"
+        new_entities = []
+        for entity in entities:
+            if entity.offset > 4082:
+                continue
+            if entity.offset + entity.length > 4082:
+                entity.length = 4082 - entity.offset
+            new_entities.append(entity)
+        new_entities.append(MessageEntityItalic(4082, len(" [message cut]")))
+        entities = new_entities
+    return message, entities
+
+
 def matrix_to_telegram(html: str) -> Tuple[str, List[TypeMessageEntity]]:
     try:
         parser = MatrixParser()
@@ -269,7 +284,13 @@ def matrix_to_telegram(html: str) -> Tuple[str, List[TypeMessageEntity]]:
         if should_bridge_plaintext_highlights:
             html = plain_mention_regex.sub(plain_mention_to_html, html)
         parser.feed(add_surrogates(html))
-        return remove_surrogates(parser.text.strip()), parser.entities
+
+        message_text = remove_surrogates(parser.text.strip())
+        message_entities = parser.entities
+
+        message_text, message_entities = cut_long_message(message_text, message_entities)
+
+        return message_text, message_entities
     except Exception:
         log.exception("Failed to convert Matrix format:\nhtml=%s", html)
 
@@ -322,8 +343,7 @@ def plain_mention_to_text() -> Tuple[List[TypeMessageEntity], Callable[[str], st
                 entity = MessageEntityMention(offset, length)
                 text = f"@{puppet.username}"
             else:
-                entity = InputMessageEntityMentionName(offset, length,
+                entity = MessageEntityMentionName(offset, length, user_id=puppet.tgid)
-                                                       user_id=InputUser(puppet.tgid, 0))
                 text = puppet.displayname
             entities.append(entity)
             return text

mautrix_telegram/portal.py

@@ -622,7 +622,7 @@ class Portal:
         if await user.needs_relaybot(self):
             async with self.require_send_lock(self.bot.tgid):
                 response = await self.bot.client.send_message(
-                    self.peer, f"__{user.displayname} left the room.__", markdown=True)
+                    self.peer, f"__{user.displayname} left the room.__")
                 space = self.tgid if self.peer_type == "channel" else self.bot.tgid
                 self.is_duplicate(response, (event_id, space))
             return
@@ -654,7 +654,7 @@ class Portal:
         if await user.needs_relaybot(self):
             async with self.require_send_lock(self.bot.tgid):
                 response = await self.bot.client.send_message(
-                    self.peer, f"__{user.displayname} joined the room.__", markdown=True)
+                    self.peer, f"__{user.displayname} joined the room.__")
                 space = self.tgid if self.peer_type == "channel" else self.bot.tgid
                 self.is_duplicate(response, (event_id, space))
             return
@@ -689,16 +689,10 @@ class Portal:
         elif use_relaybot:
             cls._apply_msg_format(sender, msgtype, message)
 
-    async def _matrix_event_to_entities(self, client, event):
+    def _matrix_event_to_entities(self, event):
         try:
             if event.get("format", None) == "org.matrix.custom.html":
                 message, entities = formatter.matrix_to_telegram(event["formatted_body"])
-
-                # TODO remove this crap
-                for entity in entities:
-                    if isinstance(entity, InputMessageEntityMentionName):
-                        entity.user_id = await client.get_input_entity(
-                            PeerUser(entity.user_id.user_id))
             else:
                 message, entities = formatter.matrix_text_to_telegram(event["body"])
         except KeyError:
@@ -723,24 +717,10 @@ class Portal:
             return None
 
     async def _handle_matrix_text(self, sender_id, event_id, space, client, message, reply_to):
-        message, entities = await self._matrix_event_to_entities(client, message)
-
-        if len(message) > 4096:
-            message = message[0:4082] + " [message cut]"
-            new_entities = []
-            for entity in entities:
-                if entity.offset > 4082:
-                    continue
-                if entity.offset + entity.length > 4082:
-                    entity.length = 4082 - entity.offset
-                new_entities.append(entity)
-            new_entities.append(MessageEntityItalic(4082, len(" [message cut]")))
-            entities = new_entities
-
         lock = self.require_send_lock(sender_id)
         async with lock:
-            response = await client.send_message(self.peer, message, entities=entities,
+            response = await client.send_message(self.peer, message, reply_to=reply_to,
-                                                 reply_to=reply_to)
+                                                 parse_mode=self._matrix_event_to_entities)
             self._add_telegram_message_to_db(event_id, space, response)
 
     async def _handle_matrix_file(self, type, sender_id, event_id, space, client, message,
@@ -784,7 +764,7 @@ class Portal:
         except (KeyError, ValueError):
             self.log.exception("Failed to parse location")
             return None
-        message, entities = await self._matrix_event_to_entities(client, message)
+        message, entities = self._matrix_event_to_entities(message)
         media = MessageMediaGeo(geo=GeoPoint(lat, long))
 
         lock = self.require_send_lock(sender_id)

mautrix_telegram/tgclient.py

@@ -17,40 +17,11 @@
 from io import BytesIO
 
 from telethon import TelegramClient, utils
-from telethon.tl.functions.messages import SendMessageRequest, SendMediaRequest
+from telethon.tl.functions.messages import SendMediaRequest
 from telethon.tl.types import *
-from telethon.extensions.markdown import parse as parse_md
 
 
 class MautrixTelegramClient(TelegramClient):
-    async def send_message(self, entity, message, reply_to=None, entities=None, markdown=False,
-                           link_preview=True):
-        entity = await self.get_input_entity(entity)
-
-        if markdown:
-            message, entities = parse_md(message)
-
-        request = SendMessageRequest(
-            peer=entity,
-            message=message,
-            entities=entities,
-            no_webpage=not link_preview,
-            reply_to_msg_id=utils.get_message_id(reply_to)
-        )
-        result = await self(request)
-        if isinstance(result, UpdateShortSentMessage):
-            return Message(
-                id=result.id,
-                to_id=entity,
-                message=message,
-                date=result.date,
-                out=result.out,
-                media=result.media,
-                entities=result.entities
-            )
-
-        return self._get_response_message(request, result, entity)
-
     async def upload_file(self, file, mime_type=None, attributes=None, file_name=None):
         file_handle = await super().upload_file(file, file_name=file_name, use_cache=False)