Add check for large files and comments

I like it better now, but I still dislike it; We need to rewrite the entire function

README.md

@@ -8,7 +8,7 @@ Pluggable [``asyncio``](https://docs.python.org/3/library/asyncio.html)
 
 Simply clone the repository and run the main file:
 ```sh
-git clone https://github.com/uniborg/uniborg.git
+git clone https://github.com/udf/uniborg.git
 cd uniborg
 python stdborg.py
 ```
@@ -16,11 +16,11 @@ python stdborg.py
 ## design
 
 The modular design of the project enhances your Telegram experience
-through [plugins](https://github.com/uniborg/uniborg/tree/master/stdplugins)
+through [plugins](https://github.com/udf/uniborg/tree/master/stdplugins)
 which you can enable or disable on demand.
 
 Each plugin gets the `borg`, `logger` and `storage` magical
-[variables](https://github.com/uniborg/uniborg/blob/4805f2f6de7d734c341bb978318f44323ad525f1/uniborg/uniborg.py#L66-L68)
+[variables](https://github.com/udf/uniborg/blob/4805f2f6de7d734c341bb978318f44323ad525f1/uniborg/uniborg.py#L66-L68)
 to ease their use. Thus creating a plugin as easy as adding
 a new file under the plugin directory to do the job:
 
@@ -36,12 +36,12 @@ async def handler(event):
 ## internals
 
 The core features offered by the custom `TelegramClient` live under the
-[`uniborg/`](https://github.com/uniborg/uniborg/tree/master/uniborg)
+[`uniborg/`](https://github.com/udf/uniborg/tree/master/uniborg)
 directory, with some utilities, enhancements and the core plugin.
 
 ## learning
 
 Check out the already-mentioned
-[plugins](https://github.com/uniborg/uniborg/tree/master/stdplugins)
+[plugins](https://github.com/udf/uniborg/tree/master/stdplugins)
 directory to learn how to write your own, and consider reading
 [Telethon's documentation](http://telethon.readthedocs.io/).

disabledplugins/sp_h.py

@@ -0,0 +1,37 @@
+import asyncio
+from telethon import events
+from telethon.tl import types
+
+EPIC_MEME = (
+"""
+⢠⠤⢠⢄⠠⡤⢀⠤⠀⠀⠀⠀⢀⣔⢔⢔⢕⢔⢕⢔⢐⢀⠀⠀⠀⠀⠀⠀
+⠸⠥⠸⠁⠠⠧⠘⠤⠀⠀⠀⣐⢗⢕⢗⢕⢕⢕⢕⢔⢑⢐⢀⠀⠀⠀⠀⠀
+⢰⠑⢱⢸⠭⢰⠑⢱⢸⠭⢐⣟⣗⣕⢗⣗⢑⢕⢑⢕⢑⠐⢑⢐⢐⢐⢀⠀
+⢨⢄⢨⢨⢩⢌⢠⠬⢨⠉⢐⣟⢗⢕⢑⣿⣷⣕⣑⠕⢑⢐⣗⠐⢐⢐⢐⢐
+⠸⠜⠘⠜⠸⠜⠸⠥⠨⢀⢐⢑⢕⢕⢑⢛⣿⣿⣷⣔⣴⡟⠓⠀⢀⢔⢑⠑
+⠀⠀⠀⠀⠀⠀⠀⠀⢐⢗⢑⠐⠐⢷⣷⣷⣿⣿⣿⣿⣿⢕⢐⢔⢑⢔⠁⠀
+⠀⠀⠀⠀⠀⠀⠀⠰⢗⢕⢗⢕⢕⢔⠙⢟⢿⣕⣷⣟⣗⣔⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠘⢶⠄⠀⠐⠁⠐⠁⠀⠀⢀⣐⣖⢷⣟⣷⣿⣷⣔⣀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⢘⣗⣴⣴⠀⠀⠀⢀⣴⣿⣿⢟⢗⢛⣿⣟⣟⣟⣿⣟⣗⠀
+⠀⠀⠀⠀⠀⠀⢐⣿⣿⣿⡇⠀⢐⣿⣿⣟⣗⢐⢐⣔⣿⣗⣷⣟⣿⣟⣿⣗
+⠀⠀⠀⠀⠀⠀⢰⣿⣿⣟⣁⢐⢿⣟⣿⣿⣗⠐⢐⣟⣿⣟⣟⣟⣷⣟⣿⣗
+⠀⠀⠀⠀⠀⠀⢙⣟⣿⣿⣷⣗⣖⣿⣿⣟⢑⠐⢐⣟⣗⣟⣗⣗⢗⠟⢓⣑
+⠀⠀⠀⠀⠀⠀⠐⠑⠛⠛⠛⠑⠓⠙⠛⠓⠁⠐⠐⠛⠓⠛⠓⠓⠑⠒⠓⠛
+"""
+)
+
+@borg.on(events.NewMessage(pattern=r"^h$"))
+async def on_h(event):
+    await borg.reply(file="CAADAQADpgIAAna32gVJ62JcFcDnqwI")
+
+    async def del_filter(del_event):
+        if del_event.chat_id and del_event.chat_id != event.chat_id:
+            return False
+        return del_event.deleted_id == message.id
+    fut = borg.await_event(events.MessageDeleted, del_filter)
+
+    try:
+        await asyncio.wait_for(fut, timeout=5)
+        await event.reply(EPIC_MEME)
+    except asyncio.TimeoutError:
+        pass

disabledplugins/sp_kick_invite.py

@@ -0,0 +1,26 @@
+# kicks people who join a group by invite
+
+import asyncio
+from telethon import events
+
+from telethon.tl.functions.channels import EditBannedRequest
+from telethon.tl.types import ChannelBannedRights
+
+import time
+
+channel_id = 1252035294
+
+
+@borg.on(events.ChatAction(chats=channel_id))
+async def on_join(event):
+    if event.user_joined:
+        await borg(
+            EditBannedRequest(
+                channel=channel_id,
+                user_id=await event.get_user(),
+                banned_rights=ChannelBannedRights(
+                   time.time() + 60,
+                   True, True, True, True, True, True, True, True
+                )
+            )
+        )

stdplugins/all.py

@@ -1,18 +0,0 @@
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-from telethon import events
-
-
-@borg.on(events.NewMessage(pattern=r"\.all", outgoing=True))
-async def _(event):
-    if event.fwd_from:
-        return
-    await event.delete()
-    mentions = "@all"
-    chat = await event.get_input_chat()
-    async for x in borg.iter_participants(chat, 100):
-        mentions += f"[\u2063](tg://user?id={x.id})"
-    await borg.send_message(
-        chat, mentions, reply_to=event.message.reply_to_msg_id)

stdplugins/info.py

@@ -0,0 +1,98 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import string
+
+from telethon import events
+from telethon.utils import add_surrogate
+from telethon.tl.types import MessageEntityPre
+from telethon.tl.tlobject import TLObject
+import datetime
+
+PRINTABLE_SET = set(string.printable.encode())
+STR_LEN_MAX = 256
+BYTE_LEN_MAX = 64
+
+
+def parse_pre(text):
+    text = text.strip()
+    return (
+        text,
+        [MessageEntityPre(offset=0, length=len(add_surrogate(text)), language='')]
+    )
+
+
+def yaml_format(obj, indent=0):
+    """
+    Pretty formats the given object as a YAML string which is returned.
+    (based on TLObject.pretty_format)
+    """
+    result = []
+    if isinstance(obj, TLObject):
+        obj = obj.to_dict()
+
+    if isinstance(obj, dict):
+        if not obj:
+            return 'dict:'
+        result.append(obj.get('_', 'dict') + ':')
+        items = obj.items()
+        has_multiple_items = len(items) > 2
+        if has_multiple_items:
+            result.append('\n')
+        indent += 2
+        for k, v in items:
+            if k == '_' or v is None:
+                continue
+            formatted = yaml_format(v, indent)
+            if not formatted.strip():
+                continue
+            result.append(' ' * (indent if has_multiple_items else 1))
+            result.append(f'{k}: {formatted}')
+            result.append('\n')
+        result.pop()
+        indent -= 2
+        result.append(' ' * indent)
+    elif isinstance(obj, str):
+        # truncate long strings and display elipsis
+        result = repr(obj[:STR_LEN_MAX])
+        if len(obj) > STR_LEN_MAX:
+            result += '…'
+        return result
+    elif isinstance(obj, bytes):
+        # repr() bytes if it's printable, hex like "FF EE BB" otherwise
+        if all(c in PRINTABLE_SET for c in obj):
+            return repr(obj)
+        else:
+            return ('<…>' if len(obj) > BYTE_LEN_MAX else
+                    ' '.join(f'{b:02X}' for b in obj))
+    elif isinstance(obj, datetime.datetime):
+        # ISO-8601 without timezone offset (telethon dates are always UTC)
+        return obj.strftime('%Y-%m-%d %H:%M:%S')
+    elif hasattr(obj, '__iter__'):
+        # display iterables one after another at the base indentation level
+        result.append('\n')
+        indent += 2
+        for x in obj:
+
+            result.append(f"{' ' * indent}- {yaml_format(x, indent + 2)}")
+            result.append('\n')
+        result.pop()
+        indent -= 2
+        result.append(' ' * indent)
+    else:
+        return repr(obj)
+
+    return ''.join(result)
+
+
+@borg.on(events.NewMessage(pattern=r"\.info", outgoing=True))
+async def _(event):
+    if not event.message.is_reply:
+        return
+    msg = await event.message.get_reply_message()
+    yaml_text = yaml_format(msg)
+    await event.edit(
+        yaml_text,
+        parse_mode=parse_pre
+    )

stdplugins/kbass_core.py

@@ -0,0 +1,46 @@
+"""
+Contains code used by other kbass_* plugins
+"""
+from uniborg import util
+
+
+def self_reply_cmd(borg, pattern):
+    def wrapper(function):
+        @borg.on(util.admin_cmd(pattern))
+        async def wrapped(event, *args, **kwargs):
+            await event.delete()
+            target = await util.get_target_message(borg, event)
+            if not target:
+                return
+            return await function(event, target, *args, **kwargs)
+        return wrapped
+    return wrapper
+
+
+def self_reply_selector(borg, cmd):
+    def wrapper(function):
+        @borg.on(util.admin_cmd(cmd + r"( [+-]?\d+)?$"))
+        async def wrapped(event, *args, **kwargs):
+            await event.delete()
+            reply = await event.get_reply_message()
+            if not reply:
+                return
+            num_offset = int(event.pattern_match.group(1) or 0)
+            reverse = num_offset > 0
+
+            targets = [reply] if reverse else []
+            targets.extend(await borg.get_messages(
+                await event.get_input_chat(),
+                limit=abs(num_offset),
+                offset_id=reply.id,
+                reverse=reverse
+            ))
+            if not reverse:
+                # reverse the list because we want things to always be in
+                # history order
+                targets.reverse()
+                targets.append(reply)
+
+            return await function(event, targets, num_offset, *args, **kwargs)
+        return wrapped
+    return wrapper

stdplugins/kbass_edit.py

@@ -0,0 +1,43 @@
+"""
+Reply to a message with .e to make a draft of it (with '\n.e' appended)
+Reply to your own message with <text>.e to edit the message to <text>
+if <text> is ".", the message is edited to empty/deleted
+"""
+import asyncio
+
+from telethon.errors import MessageEmptyError
+from telethon.tl.functions.messages import SaveDraftRequest
+from telethon.tl.functions.messages import EditMessageRequest
+
+from stdplugins.kbass_core import self_reply_cmd
+
+
+@self_reply_cmd(borg, r"^\.e$")
+async def on_edit_start(event, target):
+    await asyncio.sleep(3)  # tdesktop doesn't sync drafts when the window is active
+    await borg(SaveDraftRequest(
+        peer=await event.get_input_chat(),
+        message=(target.message or '.') + '\n.e',
+        entities=target.entities,
+        no_webpage=not target.media,
+        reply_to_msg_id=target.id
+    ))
+
+
+@self_reply_cmd(borg, r'(?ms)^(.+)\.e$')
+async def on_edit_end(event, target):
+    text = event.pattern_match.group(1)
+    message = event.message.message[:-2]
+    if message.strip() == '.':
+        message = ''
+    try:
+        await borg(EditMessageRequest(
+            peer=await event.get_input_chat(),
+            id=target.id,
+            no_webpage=not target.media,
+            message=message,
+            entities=event.message.entities
+        ))
+    except MessageEmptyError:
+        # Can't make text message empty, so delete it
+        await borg.delete_messages(chat, target)

stdplugins/kbass_file_to_photo.py

@@ -0,0 +1,34 @@
+"""
+Reply to a file with .f to send it as a photo
+"""
+from io import BytesIO
+
+from stdplugins.kbass_core import self_reply_cmd
+from telethon import types
+from telethon.errors import PhotoInvalidDimensionsError
+
+
+@self_reply_cmd(borg, r"^\.f$")
+async def on_file_to_photo(event, target):
+    try:
+        image = target.media.document
+    except AttributeError:
+        return
+    if not image.mime_type.startswith('image/'):
+        return  # This isn't an image
+    if image.mime_type == 'image/webp':
+        return  # Telegram doesn't let you directly send stickers as photos
+    if image.size > 10 * 1024 * 1024:
+        return  # We'd get PhotoSaveFileInvalidError otherwise
+
+    file = await borg.download_media(target, file=BytesIO())
+    file.seek(0)
+    img = await borg.upload_file(file)
+
+    try:
+        await event.respond(
+            reply_to=target,
+            file=types.InputMediaUploadedPhoto(img)
+        )
+    except PhotoInvalidDimensionsError:
+        return

stdplugins/kbass_save.py

@@ -0,0 +1,15 @@
+"""
+Reply to a message with .s <n> to forward <n> messages from that point to your
+saved messages (negative values of <n> go backwards in history)
+"""
+import asyncio
+
+from stdplugins.kbass_core import self_reply_selector
+
+
+@self_reply_selector(borg, r'\.s')
+async def on_save(event, targets, num_offset):
+    await borg.forward_messages('me', targets)
+    msg = await event.respond(f'Saved {abs(num_offset) + 1} messages!')
+    await asyncio.sleep(3)
+    await borg.delete_messages(msg.to_id, msg)

stdplugins/kbass_toggle_preview.py

@@ -0,0 +1,25 @@
+"""
+Reply to a message with .p <y/n> to toggle the webpage preview of a message
+"""
+from telethon.errors import MessageNotModifiedError
+from telethon.tl.functions.messages import EditMessageRequest
+
+from stdplugins.kbass_core import self_reply_cmd
+
+
+@self_reply_cmd(borg, r"^\.p(?: ?)([yn])?$")
+async def on_edit_preview(event, target):
+    preview = event.pattern_match.group(1) == 'y'
+    if not event.pattern_match.group(1):
+        preview = not bool(target.media)
+    try:
+        await borg(EditMessageRequest(
+            peer=await event.get_input_chat(),
+            id=target.id,
+            no_webpage=not preview,
+            message=target.message,
+            entities=target.entities
+        ))
+    except MessageNotModifiedError:
+        # There was no preview to modify
+        pass

stdplugins/kbass_yank.py

@@ -0,0 +1,28 @@
+"""
+Like save but makes a draft in your chat of all the messages concatenated with
+two newlines
+"""
+import html
+
+from telethon.tl.functions.messages import SaveDraftRequest
+from telethon.extensions import html as thtml
+
+from stdplugins.kbass_core import self_reply_selector
+
+
+def get_message_html(message):
+    if message.action:
+        return html.escape(str(message.action))
+    return thtml.unparse(message.message, message.entities)
+
+
+@self_reply_selector(borg, r'\.y')
+async def on_yank(event, targets, num_offset):
+    message = '\n\n'.join(get_message_html(target) for target in targets)
+    message, entities = thtml.parse(message)
+    await borg(SaveDraftRequest(
+        peer='me',
+        message=message,
+        entities=entities,
+        no_webpage=True,
+    ))

stdplugins/markdown.py

@@ -8,10 +8,7 @@ from telethon import events
 from telethon.tl.functions.messages import EditMessageRequest
 from telethon.extensions.markdown import DEFAULT_URL_RE
 from telethon.utils import add_surrogate, del_surrogate
-from telethon.tl.types import (
-    MessageEntityBold, MessageEntityItalic, MessageEntityCode,
-    MessageEntityPre, MessageEntityTextUrl
-)
+from telethon.tl.types import MessageEntityTextUrl
 
 
 def parse_url_match(m):
@@ -23,14 +20,6 @@ def parse_url_match(m):
     return m.group(1), entity
 
 
-def get_tag_parser(tag, entity):
-    # TODO unescape escaped tags?
-    def tag_parser(m):
-        return m.group(1), entity(offset=m.start(), length=len(m.group(1)))
-    tag = re.escape(tag)
-    return re.compile(tag + r'(.+?)' + tag, re.DOTALL), tag_parser
-
-
 PRINTABLE_ASCII = range(0x21, 0x7f)
 def parse_aesthetics(m):
     def aesthetify(string):
@@ -65,18 +54,10 @@ def parse_snip(m):
     return m.group(1), None
 
 
-PARSED_ENTITIES = (
-    MessageEntityBold, MessageEntityItalic, MessageEntityCode,
-    MessageEntityPre, MessageEntityTextUrl
-)
 # A matcher is a tuple of (regex pattern, parse function)
 # where the parse function takes the match and returns (text, entity)
 MATCHERS = [
     (DEFAULT_URL_RE, parse_url_match),
-    (get_tag_parser('**', MessageEntityBold)),
-    (get_tag_parser('__', MessageEntityItalic)),
-    (get_tag_parser('```', partial(MessageEntityPre, language=''))),
-    (get_tag_parser('`', MessageEntityCode)),
     (re.compile(r'\+\+(.+?)\+\+'), parse_aesthetics),
     (re.compile(r'([^/\w]|^)(/?(r/\w+))'), parse_subreddit),
     (re.compile(r'(!\w+)'), parse_snip)

stdplugins/ninja.py

@@ -11,15 +11,6 @@ import telethon.utils
 from uniborg import util
 
 
-async def get_target_message(event):
-    if event.is_reply and (await event.get_reply_message()).from_id == borg.uid:
-        return await event.get_reply_message()
-    async for message in borg.iter_messages(
-            await event.get_input_chat(), limit=20):
-        if message.out:
-            return message
-
-
 async def await_read(chat, message):
     if isinstance(chat, InputPeerSelf):
         return
@@ -46,7 +37,7 @@ async def delete(event):
         text = event.pattern_match.group(2)
         if not text:
             return
-    target = await get_target_message(event)
+    target = await util.get_target_message(borg, event)
     if target:
         chat = await event.get_input_chat()
         await await_read(chat, target)

stdplugins/sed.py

@@ -1,109 +0,0 @@
-from collections import defaultdict, deque
-import re
-
-import regex
-from telethon import events, utils
-from telethon.tl import types, functions
-
-HEADER = "「sed」\n"
-KNOWN_RE_BOTS = re.compile(
-    r'(regex|moku|BananaButler_|rgx|l4mR)bot',
-    flags=re.IGNORECASE
-)
-
-# Heavily based on
-# https://github.com/SijmenSchoon/regexbot/blob/master/regexbot.py
-
-last_msgs = defaultdict(lambda: deque(maxlen=10))
-
-
-def doit(chat_id, match, original):
-    fr = match.group(1)
-    to = match.group(2)
-    to = to.replace('\\/', '/')
-    try:
-        fl = match.group(3)
-        if fl is None:
-            fl = ''
-        fl = fl[1:]
-    except IndexError:
-        fl = ''
-
-    # Build Python regex flags
-    count = 1
-    flags = 0
-    for f in fl:
-        if f == 'i':
-            flags |= regex.IGNORECASE
-        elif f == 'g':
-            count = 0
-        else:
-            return None, f"Unknown flag: {f}"
-
-    def actually_doit(original):
-        try:
-            s = original.message
-            if s.startswith(HEADER):
-                s = s[len(HEADER):]
-            s, i = regex.subn(fr, to, s, count=count, flags=flags)
-            if i > 0:
-                return original, s
-        except Exception as e:
-            return None, f"u dun goofed m8: {str(e)}"
-        return None, None
-
-    if original is not None:
-        return actually_doit(original)
-    # Try matching the last few messages
-    for original in last_msgs[chat_id]:
-        m, s = actually_doit(original)
-        if s is not None:
-            return m, s
-    return None, None
-
-
-async def group_has_sedbot(group):
-    if isinstance(group, types.InputPeerChannel):
-        full = await borg(functions.channels.GetFullChannelRequest(group))
-    elif isinstance(group, types.InputPeerChat):
-        full = await borg(functions.messages.GetFullChatRequest(group.chat_id))
-    else:
-        return False
-
-    return any(KNOWN_RE_BOTS.match(x.username or '') for x in full.users)
-
-
-@borg.on(events.NewMessage)
-async def on_message(event):
-    last_msgs[event.chat_id].appendleft(event.message)
-
-@borg.on(events.MessageEdited)
-async def on_edit(event):
-    for m in last_msgs[event.chat_id]:
-        if m.id == event.id:
-            m.raw_text = event.raw_text
-            break
-
-@borg.on(events.NewMessage(
-    pattern=re.compile(r"^s/((?:\\/|[^/])+)/((?:\\/|[^/])*)(/.*)?")))
-async def on_regex(event):
-    if event.fwd_from:
-        return
-    if not event.is_private and\
-            await group_has_sedbot(await event.get_input_chat()):
-        return
-
-    chat_id = utils.get_peer_id(await event.get_input_chat())
-
-    m, s = doit(chat_id, event.pattern_match, await event.get_reply_message())
-
-    if m is not None:
-        s = f"{HEADER}{s}"
-        out = await borg.send_message(
-            await event.get_input_chat(), s, reply_to=m.id
-        )
-        last_msgs[chat_id].appendleft(out)
-    elif s is not None:
-        await event.reply(s)
-
-    raise events.StopPropagation

stdplugins/sp_bar.py

@@ -0,0 +1,10 @@
+import asyncio
+from telethon import events
+from telethon.tl import types
+import re
+
+@borg.on(events.NewMessage(pattern=re.compile(r"^bar$"), chats=1040270887))
+async def on_bar(event):
+    if event.from_id == 151462131:
+        return
+    await event.reply("foo")

stdplugins/sp_prog_rename.py

@@ -0,0 +1,71 @@
+import asyncio
+import re
+
+from telethon import events
+from telethon.tl.functions.channels import EditTitleRequest
+from telethon.errors.rpcerrorlist import ChatNotModifiedError
+
+MULTI_EDIT_TIMEOUT = 80
+REVERT_TIMEOUT = 2 * 60 * 60
+CHANNEL_ID = 1040270887
+DEFAULT_TITLE = "Programming & Tech"
+prog_tech_channel = None
+lock = asyncio.Lock()
+
+
+def fix_title(s):
+    # Ideally this would be a state machine, but ¯\_(ツ)_/¯
+    def replace(m):
+        token = m.group(1)
+        if token.lower() == 'and':
+            token = '&'
+        return token[0].upper() + token[1:] + (' ' if m.group(2) else '')
+    return re.sub(r'(\S+)(\s+)?', replace, s)
+
+
+async def edit_title(title):
+    global prog_tech_channel
+    if prog_tech_channel is None:
+        prog_tech_channel = await borg.get_entity(CHANNEL_ID)
+    try:
+        await borg(EditTitleRequest(
+            channel=prog_tech_channel, title=title
+        ))
+    except ChatNotModifiedError:
+        pass  # Everything is ok
+
+
+async def wait_for_delete(deleted_fut, timeout):
+    try:
+        await asyncio.wait_for(deleted_fut, timeout)
+        await edit_title(DEFAULT_TITLE)
+        return True
+    except asyncio.TimeoutError:
+        pass
+    return False
+
+
+@borg.on(events.NewMessage(
+    pattern=re.compile(r"(?i)programming (?:&|and) (.+)"), chats=CHANNEL_ID))
+async def on_name(event):
+    new_topic = fix_title(event.pattern_match.group(1))
+    new_title = f"Programming & {new_topic}"
+    if "Tech" not in new_title:
+        new_title += " & Tech"
+
+    if len(new_title) > 255 or lock.locked():
+        return
+
+    with (await lock):
+        await edit_title(new_title)
+        deleted_fut = borg.await_event(events.MessageDeleted(
+            chats=CHANNEL_ID,
+            func=lambda e: e.deleted_id == event.message.id
+        ))
+        if await wait_for_delete(asyncio.shield(deleted_fut), MULTI_EDIT_TIMEOUT):
+            await asyncio.sleep(MULTI_EDIT_TIMEOUT)
+            return
+    if await wait_for_delete(deleted_fut, REVERT_TIMEOUT) or lock.locked():
+        return
+    with (await lock):
+        await edit_title(DEFAULT_TITLE)

stdplugins/superblock.py

@@ -0,0 +1,58 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import asyncio
+
+from telethon import events
+import telethon.tl.functions as tlf
+from telethon.tl.types import InputPeerChannel, UpdateUserBlocked
+from telethon.tl.functions.contacts import GetBlockedRequest
+
+
+# How often to fetch the full list of blocked users
+REFETCH_TIME = 60
+
+blocked_user_ids = set()
+
+
+@borg.on(events.NewMessage(incoming=True, func=lambda e: e.message.mentioned))
+async def on_mentioned(event):
+    if not event.message.from_id:  # Channel messages don't have a from_id
+        return
+    if event.from_id not in blocked_user_ids:
+        return
+
+    peer = await borg.get_input_entity(event.chat_id)
+    if isinstance(peer, InputPeerChannel):
+        o = tlf.channels.ReadMessageContentsRequest(peer, [event.message.id])
+    else:
+        o = tlf.messages.ReadMessageContentsRequest([event.message.id])
+    await borg(o)
+
+
+@borg.on(events.Raw(types=UpdateUserBlocked))
+async def on_blocked(event):
+    if event.blocked:
+        blocked_user_ids.add(event.user_id)
+    else:
+        blocked_user_ids.discard(event.user_id)
+
+
+async def fetch_blocked_users():
+    global blocked_user_ids
+    while 1:
+        offset = 0
+        blocked_ids = set()
+        while 1:
+            blocked = await borg(GetBlockedRequest(offset=offset, limit=100))
+            offset += 100
+            for contact in blocked.blocked:
+                blocked_ids.add(contact.user_id)
+            if not blocked.blocked:
+                break
+        blocked_user_ids = blocked_ids
+        await asyncio.sleep(REFETCH_TIME)
+
+
+asyncio.ensure_future(fetch_blocked_users())

uniborg/util.py

@@ -28,3 +28,12 @@ async def is_read(borg, entity, message, is_out=None):
     dialog = (await borg(GetPeerDialogsRequest([entity]))).dialogs[0]
     max_id = dialog.read_outbox_max_id if is_out else dialog.read_inbox_max_id
     return message_id <= max_id
+
+
+async def get_target_message(borg, event):
+    if event.is_reply and (await event.get_reply_message()).from_id == borg.uid:
+        return await event.get_reply_message()
+    async for message in borg.iter_messages(
+            await event.get_input_chat(), limit=20):
+        if message.out:
+            return message