Upload 5 files

Dockerfile

@@ -0,0 +1,31 @@
+FROM ubuntu
+
+RUN apt-get update && \
+    apt-get install -y sudo && \
+    apt-get clean
+RUN apt-get update && apt-get install -y python3 python3-pip python3.12-venv
+RUN apt-get update && apt-get install -y \
+    curl \
+    ca-certificates \
+    megatools \
+    gnupg && \
+    curl -fsSL https://deb.nodesource.com/setup_16.x | bash -
+RUN rm -rf /var/lib/apt/lists/*
+
+# Añadir un usuario llamado 'appuser'
+RUN useradd -ms /bin/bash appuser
+RUN usermod -aG sudo appuser
+RUN echo "appuser ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers
+
+USER appuser
+
+WORKDIR /app
+
+COPY . /app
+
+RUN sudo chmod -R 777 /app
+
+RUN python3 -m venv venv
+RUN /bin/bash -c "source venv/bin/activate && pip3 install -r requirements.txt"
+
+CMD ["venv/bin/gunicorn", "--worker-class", "eventlet", "-w", "1", "-b", "0.0.0.0:7860", "app:app"]

FastTelethon.py

@@ -0,0 +1,308 @@
+# copied from https://github.com/tulir/mautrix-telegram/blob/master/mautrix_telegram/util/parallel_file_transfer.py
+# Copyright (C) 2021 Tulir Asokan
+import asyncio
+import hashlib
+import inspect
+import logging
+import math
+import os
+from collections import defaultdict
+from typing import Optional, List, AsyncGenerator, Union, Awaitable, DefaultDict, Tuple, BinaryIO
+
+from telethon import utils, helpers, TelegramClient
+from telethon.crypto import AuthKey
+from telethon.network import MTProtoSender
+from telethon.tl.alltlobjects import LAYER
+from telethon.tl.functions import InvokeWithLayerRequest
+from telethon.tl.functions.auth import ExportAuthorizationRequest, ImportAuthorizationRequest
+from telethon.tl.functions.upload import (GetFileRequest, SaveFilePartRequest,
+                                          SaveBigFilePartRequest)
+from telethon.tl.types import (Document, InputFileLocation, InputDocumentFileLocation,
+                               InputPhotoFileLocation, InputPeerPhotoFileLocation, TypeInputFile,
+                               InputFileBig, InputFile)
+
+try:
+    from mautrix.crypto.attachments import async_encrypt_attachment
+except ImportError:
+    async_encrypt_attachment = None
+
+log: logging.Logger = logging.getLogger("telethon")
+
+TypeLocation = Union[Document, InputDocumentFileLocation, InputPeerPhotoFileLocation,
+                     InputFileLocation, InputPhotoFileLocation]
+
+
+class DownloadSender:
+    client: TelegramClient
+    sender: MTProtoSender
+    request: GetFileRequest
+    remaining: int
+    stride: int
+
+    def __init__(self, client: TelegramClient, sender: MTProtoSender, file: TypeLocation, offset: int, limit: int,
+                 stride: int, count: int) -> None:
+        self.sender = sender
+        self.client = client
+        self.request = GetFileRequest(file, offset=offset, limit=limit)
+        self.stride = stride
+        self.remaining = count
+
+    async def next(self) -> Optional[bytes]:
+        if not self.remaining:
+            return None
+        result = await self.client._call(self.sender, self.request)
+        self.remaining -= 1
+        self.request.offset += self.stride
+        return result.bytes
+
+    def disconnect(self) -> Awaitable[None]:
+        return self.sender.disconnect()
+
+
+class UploadSender:
+    client: TelegramClient
+    sender: MTProtoSender
+    request: Union[SaveFilePartRequest, SaveBigFilePartRequest]
+    part_count: int
+    stride: int
+    previous: Optional[asyncio.Task]
+    loop: asyncio.AbstractEventLoop
+
+    def __init__(self, client: TelegramClient, sender: MTProtoSender, file_id: int, part_count: int, big: bool,
+                 index: int,
+                 stride: int, loop: asyncio.AbstractEventLoop) -> None:
+        self.client = client
+        self.sender = sender
+        self.part_count = part_count
+        if big:
+            self.request = SaveBigFilePartRequest(file_id, index, part_count, b"")
+        else:
+            self.request = SaveFilePartRequest(file_id, index, b"")
+        self.stride = stride
+        self.previous = None
+        self.loop = loop
+
+    async def next(self, data: bytes) -> None:
+        if self.previous:
+            await self.previous
+        self.previous = self.loop.create_task(self._next(data))
+
+    async def _next(self, data: bytes) -> None:
+        self.request.bytes = data
+        log.debug(f"Sending file part {self.request.file_part}/{self.part_count}"
+                  f" with {len(data)} bytes")
+        await self.client._call(self.sender, self.request)
+        self.request.file_part += self.stride
+
+    async def disconnect(self) -> None:
+        if self.previous:
+            await self.previous
+        return await self.sender.disconnect()
+
+
+class ParallelTransferrer:
+    client: TelegramClient
+    loop: asyncio.AbstractEventLoop
+    dc_id: int
+    senders: Optional[List[Union[DownloadSender, UploadSender]]]
+    auth_key: AuthKey
+    upload_ticker: int
+
+    def __init__(self, client: TelegramClient, dc_id: Optional[int] = None) -> None:
+        self.client = client
+        self.loop = self.client.loop
+        self.dc_id = dc_id or self.client.session.dc_id
+        self.auth_key = (None if dc_id and self.client.session.dc_id != dc_id
+                         else self.client.session.auth_key)
+        self.senders = None
+        self.upload_ticker = 0
+
+    async def _cleanup(self) -> None:
+        await asyncio.gather(*[sender.disconnect() for sender in self.senders])
+        self.senders = None
+
+    @staticmethod
+    def _get_connection_count(file_size: int, max_count: int = 20,
+                              full_size: int = 100 * 1024 * 1024) -> int:
+        if file_size > full_size:
+            return max_count
+        return math.ceil((file_size / full_size) * max_count)
+
+    async def _init_download(self, connections: int, file: TypeLocation, part_count: int,
+                             part_size: int) -> None:
+        minimum, remainder = divmod(part_count, connections)
+
+        def get_part_count() -> int:
+            nonlocal remainder
+            if remainder > 0:
+                remainder -= 1
+                return minimum + 1
+            return minimum
+
+        # The first cross-DC sender will export+import the authorization, so we always create it
+        # before creating any other senders.
+        self.senders = [
+            await self._create_download_sender(file, 0, part_size, connections * part_size,
+                                               get_part_count()),
+            *await asyncio.gather(
+                *[self._create_download_sender(file, i, part_size, connections * part_size,
+                                               get_part_count())
+                  for i in range(1, connections)])
+        ]
+
+    async def _create_download_sender(self, file: TypeLocation, index: int, part_size: int,
+                                      stride: int,
+                                      part_count: int) -> DownloadSender:
+        return DownloadSender(self.client, await self._create_sender(), file, index * part_size, part_size,
+                              stride, part_count)
+
+    async def _init_upload(self, connections: int, file_id: int, part_count: int, big: bool
+                           ) -> None:
+        self.senders = [
+            await self._create_upload_sender(file_id, part_count, big, 0, connections),
+            *await asyncio.gather(
+                *[self._create_upload_sender(file_id, part_count, big, i, connections)
+                  for i in range(1, connections)])
+        ]
+
+    async def _create_upload_sender(self, file_id: int, part_count: int, big: bool, index: int,
+                                    stride: int) -> UploadSender:
+        return UploadSender(self.client, await self._create_sender(), file_id, part_count, big, index, stride,
+                            loop=self.loop)
+
+    async def _create_sender(self) -> MTProtoSender:
+        dc = await self.client._get_dc(self.dc_id)
+        sender = MTProtoSender(self.auth_key, loggers=self.client._log)
+        await sender.connect(self.client._connection(dc.ip_address, dc.port, dc.id,
+                                                     loggers=self.client._log,
+                                                     proxy=self.client._proxy))
+        if not self.auth_key:
+            log.debug(f"Exporting auth to DC {self.dc_id}")
+            auth = await self.client(ExportAuthorizationRequest(self.dc_id))
+            self.client._init_request.query = ImportAuthorizationRequest(id=auth.id,
+                                                                         bytes=auth.bytes)
+            req = InvokeWithLayerRequest(LAYER, self.client._init_request)
+            await sender.send(req)
+            self.auth_key = sender.auth_key
+        return sender
+
+    async def init_upload(self, file_id: int, file_size: int, part_size_kb: Optional[float] = None,
+                          connection_count: Optional[int] = None) -> Tuple[int, int, bool]:
+        connection_count = connection_count or self._get_connection_count(file_size)
+        part_size = (part_size_kb or utils.get_appropriated_part_size(file_size)) * 1024
+        part_count = (file_size + part_size - 1) // part_size
+        is_large = file_size > 10 * 1024 * 1024
+        await self._init_upload(connection_count, file_id, part_count, is_large)
+        return part_size, part_count, is_large
+
+    async def upload(self, part: bytes) -> None:
+        await self.senders[self.upload_ticker].next(part)
+        self.upload_ticker = (self.upload_ticker + 1) % len(self.senders)
+
+    async def finish_upload(self) -> None:
+        await self._cleanup()
+
+    async def download(self, file: TypeLocation, file_size: int,
+                       part_size_kb: Optional[float] = None,
+                       connection_count: Optional[int] = None) -> AsyncGenerator[bytes, None]:
+        connection_count = connection_count or self._get_connection_count(file_size)
+        part_size = (part_size_kb or utils.get_appropriated_part_size(file_size)) * 1024
+        part_count = math.ceil(file_size / part_size)
+        log.debug("Starting parallel download: "
+                  f"{connection_count} {part_size} {part_count} {file!s}")
+        await self._init_download(connection_count, file, part_count, part_size)
+
+        part = 0
+        while part < part_count:
+            tasks = []
+            for sender in self.senders:
+                tasks.append(self.loop.create_task(sender.next()))
+            for task in tasks:
+                data = await task
+                if not data:
+                    break
+                yield data
+                part += 1
+                log.debug(f"Part {part} downloaded")
+
+        log.debug("Parallel download finished, cleaning up connections")
+        await self._cleanup()
+
+
+parallel_transfer_locks: DefaultDict[int, asyncio.Lock] = defaultdict(lambda: asyncio.Lock())
+
+
+def stream_file(file_to_stream: BinaryIO, chunk_size=1024):
+    while True:
+        data_read = file_to_stream.read(chunk_size)
+        if not data_read:
+            break
+        yield data_read
+
+
+async def _internal_transfer_to_telegram(client: TelegramClient,
+                                         response: BinaryIO,
+                                         progress_callback: callable
+                                         ) -> Tuple[TypeInputFile, int]:
+    file_id = helpers.generate_random_long()
+    file_size = os.path.getsize(response.name)
+
+    hash_md5 = hashlib.md5()
+    uploader = ParallelTransferrer(client)
+    part_size, part_count, is_large = await uploader.init_upload(file_id, file_size)
+    buffer = bytearray()
+    for data in stream_file(response):
+        if progress_callback:
+            r = progress_callback(response.tell(), file_size)
+            if inspect.isawaitable(r):
+                await r
+        if not is_large:
+            hash_md5.update(data)
+        if len(buffer) == 0 and len(data) == part_size:
+            await uploader.upload(data)
+            continue
+        new_len = len(buffer) + len(data)
+        if new_len >= part_size:
+            cutoff = part_size - len(buffer)
+            buffer.extend(data[:cutoff])
+            await uploader.upload(bytes(buffer))
+            buffer.clear()
+            buffer.extend(data[cutoff:])
+        else:
+            buffer.extend(data)
+    if len(buffer) > 0:
+        await uploader.upload(bytes(buffer))
+    await uploader.finish_upload()
+    if is_large:
+        return InputFileBig(file_id, part_count, "upload"), file_size
+    else:
+        return InputFile(file_id, part_count, "upload", hash_md5.hexdigest()), file_size
+
+
+async def download_file(client: TelegramClient,
+                        location: TypeLocation,
+                        out: BinaryIO,
+                        progress_callback: callable = None
+                        ) -> BinaryIO:
+    size = location.size
+    dc_id, location = utils.get_input_location(location)
+    # We lock the transfers because telegram has connection count limits
+    downloader = ParallelTransferrer(client, dc_id)
+    downloaded = downloader.download(location, size)
+    async for x in downloaded:
+        out.write(x)
+        if progress_callback:
+            r = progress_callback(out.tell(), size)
+            if inspect.isawaitable(r):
+                await r
+
+    return out
+
+
+async def upload_file(client: TelegramClient,
+                      file: BinaryIO,
+                      progress_callback: callable = None,
+
+                      ) -> TypeInputFile:
+    res = (await _internal_transfer_to_telegram(client, file, progress_callback))[0]
+    return res

app.py

@@ -0,0 +1,41 @@
+import os
+from flask import Flask, send_file
+from flask_socketio import SocketIO
+import threading
+
+app = Flask(__name__)
+socketio = SocketIO(app, async_mode='eventlet')
+base_dir = os.path.abspath('files')
+
+@socketio.on('request_dir_structure')
+def send_dir_structure():
+    structure = {}
+    for root, dirs, files in os.walk(base_dir):
+        rel_path = os.path.relpath(root, base_dir)
+        structure[rel_path] = {
+            'dirs': dirs,
+            'files': [{'name': f, 'size': os.path.getsize(os.path.join(root, f))} for f in files]
+        }
+    socketio.emit('dir_structure', structure)
+
+@socketio.on('download_file')
+def send_file_chunk(data):
+    file_path = os.path.join(base_dir, data['path'])
+    offset = data.get('offset', 0)
+    chunk_size = 1024 * 64  # 64KB chunks
+    
+    with open(file_path, 'rb') as f:
+        f.seek(offset)
+        while True:
+            chunk = f.read(chunk_size)
+            if not chunk:
+                break
+            socketio.emit('file_chunk', {
+                'path': data['path'],
+                'offset': f.tell(),
+                'data': chunk
+            })
+            socketio.sleep(0.01)  # Evita bloquear el hilo del servidor
+
+if __name__ == '__main__':
+    socketio.run(app, port=5000)

main.py

@@ -0,0 +1,255 @@
+from telethon import events, utils, Button, TelegramClient
+import asyncio, os, time, re, sys, threading, random, subprocess, json, base64, requests, shutil, zipfile
+from bs4 import BeautifulSoup
+from FastTelethon import download_file, upload_file
+import subprocess
+
+api_id = 9024532
+api_hash = "131b576240be107210aace99a5f5c5b0"
+token = "7829277186:AAGZKtL06JxT5yp0FVNMjFy9yBKJiRpM-Y0"
+
+client = TelegramClient("AutoD", api_id, api_hash)
+
+class Timer:
+    def __init__(self, time_between=2):
+        self.start_time = time.time()
+        self.time_between = time_between
+
+    def can_send(self):
+        if time.time() > (self.start_time + self.time_between):
+            self.start_time = time.time()
+            return True
+        return False
+
+def execute_command(command):
+    try:
+        result = subprocess.run(command, shell=True, capture_output=True, text=True)
+        if result.stdout:
+            return str(result.stdout)
+        if result.stderr:
+            return str(result.stderr)
+    except Exception as e:
+        return str(f"Error: {e}")
+
+def folder_size(folder_path):
+    total_size = 0
+    for dirpath, dirnames, filenames in os.walk(folder_path):
+        for f in filenames:
+            fp = os.path.join(dirpath, f)
+            total_size += os.path.getsize(fp)
+    return total_size
+
+def split_ext(file=None, dir="./",size=3):
+        size = size * 1024 * 1024
+        files = []
+        tamano_archivo = os.path.getsize(file)
+        if tamano_archivo < size:
+            files.append(file)
+        else:
+            with open(file, 'rb') as archivo_original:
+                parte = 1
+                totalparte = (tamano_archivo//size)+1
+                while True:
+                    contenido_parte = archivo_original.read(size)
+                    if not contenido_parte:
+                        break
+                    nombre_parte = f"{file.split('/')[-1].split('.')[0]}.7z.{str(parte).zfill(3)}"
+                    with open(dir+"/"+nombre_parte, 'wb') as archivo_parte:
+                        archivo_parte.write(contenido_parte)
+                        files.append(nombre_parte)
+                        parte += 1
+        os.unlink(file)
+        return files
+
+def sizeof_fmt(num, suffix='B'):
+    for unit in ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi']:
+        if abs(num) < 1024.0:
+            return "%3.2f%s%s" % (num, unit, suffix)
+        num /= 1024.0
+    return "%.2f%s%s" % (num, 'Yi', suffix)
+
+if not os.path.exists("./files"):
+    os.mkdir("./files")
+
+client.start(bot_token=token)
+
+users = []
+process = []
+basedata = {}
+cdpaths = []
+
+@client.on(events.NewMessage())
+async def mybot(event):
+    global basedata
+    global process
+    global cdpaths
+    if len(cdpaths) > 0:
+        cd = "/"+"/".join(cdpaths)
+    else:
+        cd = "/"
+    text = event.raw_text
+    user_id = event.message.chat.id
+    msg_id = event.message.id
+    user_name = event.message.chat.username
+    mode = "auto"
+    try:
+        mode = basedata[f"{user_id}_mode"]
+    except:
+        None
+    if len(users) == 0:
+        users.append(user_id)
+    if not user_id in users:
+        await event.reply("<b>¡Acceso no autorizado!</b>", parse_mode="HTML")
+        raise ValueError(f"({user_id}) No es un usuario autorizado")
+    if not os.path.exists(f"./files"):
+        os.mkdir(f"./files")
+    if not os.path.exists(f"./files_temp"):
+        os.mkdir(f"./files_temp")
+    directorio = f'./files'+cd
+    files = [(archivo, os.path.getmtime(os.path.join(directorio, archivo))) for archivo in os.listdir(directorio)]
+    file = sorted(files, key=lambda x: x, reverse=True)
+    files = []
+    for f in file:
+        x,y = f
+        files.append(x)
+    if "/start" == text:
+        basedata[f"{user_id}_username"] = user_name
+        await event.reply(f"<code>AUTOD • TechDev</code>", parse_mode="HTML", buttons=[[Button.inline('?', b'')]])
+    elif "/add " in text:
+        user = int(text.replace("/add", ""))
+        users.append(user)
+        await event.reply("Usuario añadido")
+    elif "/ban " in text:
+        user = int(text.replace("/ban", ""))
+        users.append(user)
+        await event.reply("Usuario borrado")
+    elif "/ls" in text:
+        msg = f"#LISTDIR #GOOD\n<code>{'/'.join(cdpaths)}</code>\n<b>LÍMITE - {sizeof_fmt(folder_size('./files'))}/100.0GiB</b>\n\n"
+        for f in files:
+            if os.path.isfile("./files"+cd+"/"+f):
+                msg += f" 📃 <code>{f}</code>\n"
+            else:
+                msg += f" 📁 <code>{f}</code>\n"
+        if len(files) == 0:
+            msg += "<i>No hay archivos</i>"
+        await event.reply(msg, parse_mode="HTML")
+    elif "/rm " in text:
+        path = text.replace("/rm ", "")
+        try:
+            if os.path.isfile("./files"+cd+"/"+path):
+                os.unlink("./files"+cd+"/"+path)
+            else:
+                shutil.rmtree("./files"+cd+"/"+path)
+            msg = "#REMOVE #GOOD\n\n<b>✓ ¡Directorio Eliminado!</b>"
+        except:
+            msg = "#REMOVE #ERROR\n\n<b>No existe el directorio</b>"
+        await event.reply(msg, parse_mode="HTML")
+    elif "/cd " in text:
+        path = text.replace("/cd ", "")
+        if not os.path.isdir("./files/"+cd+"/"+path):
+            cdpaths = []
+            msg = "#CHANGEDIR #ERROR\n\n<b>No existe el directorio</b>"
+        else:
+            cdpaths = path.split("/")
+            msg = "#CHANGEDIR #GOOD\n\n<b>✓ ¡Directorio abierto!</b>"
+        directorio = f'./files/'+"/".join(cdpaths)
+        files = [(archivo, os.path.getmtime(os.path.join(directorio, archivo))) for archivo in os.listdir(directorio)]
+        file = sorted(files, key=lambda x: x, reverse=True)
+        files = []
+        for f in file:
+            x,y = f
+            files.append(x)
+        msg = f"\n\n<code>{'/'.join(cdpaths)}</code>\n<b>LÍMITE - {sizeof_fmt(folder_size('./files'))}/100.0GiB</b>\n\n"
+        for f in files:
+            if os.path.isfile("./files"+cd+"/"+f):
+                msg += f" 📃 <code>{f}</code>\n"
+            else:
+                msg += f" 📁 <code>{f}</code>\n"
+        if len(files) == 0:
+            msg += "<i>No hay archivos</i>"
+        await event.reply(msg, parse_mode="HTML")
+    elif "/mkdir " in text:
+        dir = text.replace("/mkdir ", "")
+        os.mkdir("./files"+cd+"/"+dir)
+        msg = "#MAKEDIR #GOOD\n\n<b>✓ ¡DIRECTORIO CREADO!</b>"
+        cdpaths.append(dir)
+        directorio = f'./files/'+"/".join(cdpaths)
+        files = [(archivo, os.path.getmtime(os.path.join(directorio, archivo))) for archivo in os.listdir(directorio)]
+        file = sorted(files, key=lambda x: x, reverse=True)
+        files = []
+        for f in file:
+            x,y = f
+            files.append(x)
+        msg = f"\n\n<code>{'/'.join(cdpaths)}</code>\n<b>LÍMITE - {sizeof_fmt(folder_size('./files'))}/100.0GiB</b>\n\n"
+        for f in files:
+            if os.path.isfile("./files"+cd+"/"+f):
+                msg += f" 📃 <code>{f}</code>\n"
+            else:
+                msg += f" 📁 <code>{f}</code>\n"
+        if len(files) == 0:
+            msg += "<i>No hay archivos</i>"
+        await event.reply(msg, parse_mode="HTML")
+    elif event.document and user_id in users:
+        code = str(random.randint(100000,999999))
+        process.append(code)
+        while not code == process[0]:
+            await asyncio.sleep(3)
+        msging = "<b>PREPARANDO</b>"
+        msg = await event.reply(msging, parse_mode="HTML",buttons=[Button.inline("CANCELAR",b'del|'+code.encode('utf-8'))])
+        await msg.edit("<b>DESCARGANDO</b>", parse_mode="HTML",buttons=[Button.inline("CANCELAR",b'del|'+code.encode('utf-8'))])
+        basedata[code] = "down:0/0"+"|CARGANDO..."
+        basedata[code+"auto-act"] = True
+        caption = event.message.message
+        mime_type = str(event.media.document.mime_type)
+        extension = mime_type.split("/")[1]
+        if event.file.name:
+            name = event.file.name
+        else:
+            if caption:
+                name = str(caption).split("\n")[0]+"."+extension
+            else:
+                name = "document_"+str(time.strftime("%d_%H_%M_%S"))+"."+extension
+        if os.path.exists("./files/"+name):
+            name = name.replace(".", f"_{str(time.strftime('%d%H%M%S'))}.")
+        timer = Timer()
+        async def progress_bar(current, total):
+                        if not code in process:
+                            raise ValueError(f"Se detuvo el proceso {code}")
+                        basedata[code] = "down:"+str(current)+"/"+str(total)
+                        if basedata[code+"auto-act"]:
+                            text1 = "<b>DESCARGANDO</b>"
+                            bar = f"<i>{round((current/total)*100,1)}%</i> <b>[</b>"
+                            prog = round(int(15*(current/total)),0)
+                            deprog = 15-prog
+                            bar += ("-"*prog)+"|"
+                            bar += ("-"*deprog)+"<b>]</b>"
+                            if len(process) > 1:
+                                infopro = f"\n+{len(process)-1} procesos..."
+                            else:
+                                infopro = ""
+                            if timer.can_send():
+                                await msg.edit(f"{text1}\n\n<b>Nombre:</b> <code>{name}</code>\n<b>Progreso:</b> {bar}\n<b>Tamaño:</b> <code>{sizeof_fmt(total)}</code>\n\n{infopro}", parse_mode="HTML", buttons=[Button.inline("CANCELAR", b'del|'+code.encode("utf8"))])
+        with open("./files_temp/"+name, "wb") as out:
+            await download_file(event.client, event.document, out, progress_callback=progress_bar)
+        os.rename("./files_temp/"+name, "./files"+cd+"/"+name)
+        upmsg = await event.reply(f"#DOWNLOAD #GOOD\n\n<b>✓ ¡Proceso completado!</b>", parse_mode="HTML")
+        await client.delete_messages(user_id, msg.id)
+        basedata[code] = None
+        process.remove(code)
+@client.on(events.CallbackQuery)
+async def callback_query(event):
+    global basedata
+    global process
+    user_id = event.query.user_id
+    msg_id = event.query.msg_id
+    data = event.query.data.decode("utf-8")
+    orden = str(data).split("|")[0]
+    if orden == "del":
+        code = str(data).split("|")[1]
+        try:
+            process.remove(code)
+        except:
+            None
+        await client.delete_messages(user_id, msg_id)
+print("CONECTADO")
+client.run_until_disconnected()

requirements.txt

@@ -0,0 +1,8 @@
+flask-socketio>=5.3.4
+eventlet>=0.33.3
+gunicorn>=20.1.0
+requests
+bs4
+flask
+psutil
+telethon