SimpleGram 0.1.0__tar.gz

simplegram-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,25 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+      - name: Install build tools
+        run: |
+          pip install build twine
+      - name: Build package
+        run: python -m build
+      - name: Publish to PyPI
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+        run: twine upload dist/*

simplegram-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: SimpleGram
+Version: 0.1.0
+Summary: A simple Python library that prints 'Hola Mundo'
+Home-page: https://github.com/ale-techdev/SimpleGram
+Author: TechDev
+Author-email: TechDev <alejandro.techdev@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/ale-techdev/SimpleGram
+Project-URL: Repository, https://github.com/ale-techdev/SimpleGram
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: telethon
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+Para instalar la plantilla de SimpleGram en la carpeta actual usa:
+`simplegram install`
+
+Para iniciar el bot de telegram usa:
+`simplegram start`
+
+Con nombre personalizado:
+`simplegram -n "SimpleGram" start`

simplegram-0.1.0/README.md

@@ -0,0 +1,8 @@
+Para instalar la plantilla de SimpleGram en la carpeta actual usa:
+`simplegram install`
+
+Para iniciar el bot de telegram usa:
+`simplegram start`
+
+Con nombre personalizado:
+`simplegram -n "SimpleGram" start`

simplegram-0.1.0/SimpleGram.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: SimpleGram
+Version: 0.1.0
+Summary: A simple Python library that prints 'Hola Mundo'
+Home-page: https://github.com/ale-techdev/SimpleGram
+Author: TechDev
+Author-email: TechDev <alejandro.techdev@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/ale-techdev/SimpleGram
+Project-URL: Repository, https://github.com/ale-techdev/SimpleGram
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: telethon
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+Para instalar la plantilla de SimpleGram en la carpeta actual usa:
+`simplegram install`
+
+Para iniciar el bot de telegram usa:
+`simplegram start`
+
+Con nombre personalizado:
+`simplegram -n "SimpleGram" start`

simplegram-0.1.0/SimpleGram.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+setup.py
+.github/workflows/publish.yml
+SimpleGram.egg-info/PKG-INFO
+SimpleGram.egg-info/SOURCES.txt
+SimpleGram.egg-info/dependency_links.txt
+SimpleGram.egg-info/entry_points.txt
+SimpleGram.egg-info/requires.txt
+SimpleGram.egg-info/top_level.txt
+simplegram/__init__.py
+simplegram/template/config.py
+simplegram/template/commands/backup.py
+simplegram/template/commands/restore.py
+simplegram/template/commands/search.py
+simplegram/template/commands/start.py
+simplegram/utils/.none
+simplegram/utils/FastTelethon.py
+simplegram/utils/system.py

simplegram-0.1.0/SimpleGram.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

simplegram-0.1.0/SimpleGram.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+simplegram = simplegram.__init__:main

simplegram-0.1.0/SimpleGram.egg-info/requires.txt

@@ -0,0 +1 @@
+telethon

simplegram-0.1.0/SimpleGram.egg-info/top_level.txt

@@ -0,0 +1 @@
+simplegram

simplegram-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=45", "wheel", "setuptools_scm[toml]>=6.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "SimpleGram"
+version = "0.1.0"
+authors = [
+    {name = "TechDev", email = "alejandro.techdev@gmail.com"},
+]
+description = "A simple Python library that prints 'Hola Mundo'"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.7"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+]
+dependencies = [
+    "telethon"
+]
+
+[project.urls]
+Homepage = "https://github.com/ale-techdev/SimpleGram"
+Repository = "https://github.com/ale-techdev/SimpleGram"
+
+[project.scripts]
+simplegram = "simplegram.__init__:main"

simplegram-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

simplegram-0.1.0/setup.py

@@ -0,0 +1,34 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="SimpleGram",
+    version="0.1.0",
+    author="TechDev",
+    author_email="alejandro.techdev@gmail.com",
+    description="FrameWork basado en Telethon'",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/ale-techdev/SimpleGram",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+    ],
+    python_requires=">=3.7",
+    entry_points={
+        "console_scripts": [
+            "pylibtd=pylibtd.__init__:main",
+        ],
+    },
+)

simplegram-0.1.0/simplegram/__init__.py

@@ -0,0 +1,60 @@
+from telethon import TelegramClient
+import os, sys, shutil
+
+def main():
+    cmd = sys.argv[1:]
+    def start(vars):
+        current_working_dir = os.getcwd()
+        if current_working_dir not in sys.path:
+            sys.path.insert(0, current_working_dir)
+        try:
+            import commands
+        except:
+            print("\n    [ ERROR ] No hay comandos establecidos")
+            sys.exit()
+        try:
+            from config import SESSION_NAME, BOT_TOKEN, API_HASH, API_ID
+        except:
+            print("\n    [ ERROR ] No hay archivo de configuración o faltan variables")
+            sys.exit()
+        from .utils.system import System
+        client = TelegramClient(SESSION_NAME, api_id=API_ID, api_hash=API_HASH).start(bot_token=BOT_TOKEN)
+        system = System(vars["-n"], client)
+        system.setCommands(commands)
+        print(f"\n    [ INFO ] {vars['-n']} INICIADO")
+        client.run_until_disconnected()
+    def install(vars):
+        pathcurrent = os.path.dirname(os.path.abspath(__file__))
+        origen = pathcurrent+"/template"
+        destino = "."
+        for item in os.listdir(origen):
+            s = os.path.join(origen, item)
+            d = os.path.join(destino, item)
+            if os.path.isdir(s):
+                shutil.copytree(s, d, dirs_exist_ok=True)
+            else:
+                shutil.copy2(s, d)
+        print("\n    [ INFO ] PLANTILLA INSTALADA")
+    functions = {"start": start, "install": install, "s": start, "i": install}
+    skip = False
+    index = 0
+    vars = {"-n": "SimpleGram"}
+    toexecute = []
+    for c in cmd:
+        if skip:
+            index += 1
+            skip = False
+            continue
+        if "-" in c or "--" in c:
+            skip = True
+            vars[c] = cmd[index+1]
+            continue
+        for o in functions.keys():
+            if c == o:
+                toexecute.append(functions[o])
+        index += 1
+    for exe in toexecute:
+        exe(vars)
+
+if __name__ == "__main__":
+    main()

simplegram-0.1.0/simplegram/template/commands/backup.py

@@ -0,0 +1,12 @@
+import pickle
+
+data = {"label": "Crea un backup del sistema", "level": "admin"}
+
+async def newEvent(system, event, parameters):
+    system_backup = pickle.dumps({"name": system.name, "users": system.users, "operators": system.operators})
+    with open("./system.backup", "wb") as bu:
+        bu.write(system_backup)
+    await event.reply(
+        system.name,
+        file="./system.backup"
+    )

simplegram-0.1.0/simplegram/template/commands/restore.py

@@ -0,0 +1,12 @@
+import pickle
+
+data = {"label": "Restaura una copia de seguridad", "level": "admin"}
+
+async def newFile(system, event, file):
+    sender = event.sender
+    if file.split('/')[-1].endswith(".backup"):
+        system_backup = pickle.loads(open(file, "rb").read())
+        system.name = system_backup["name"]
+        system.operators = system_backup["operators"]
+        system.users = system_backup["users"]
+        await event.reply(f"`Backup restaurado`")

simplegram-0.1.0/simplegram/template/commands/search.py

@@ -0,0 +1,77 @@
+import os
+from telethon import Button
+
+data = {"label": "Buscar un usuario de telegram", "level": "operator"}
+
+async def change(system, event, parameters):
+    client = system.client
+    userID = int(parameters[0])
+    state = parameters[1]
+    if userID in system.users:
+        del system.users[userID]
+    elif userID in system.operators:
+        del system.operators[userID]
+    user = await client.get_entity(int(userID))
+    if state == "user":
+        system.users[userID] = {"username": user.username, "permission": "user"}
+    elif state == "operator":
+        system.operators[userID] = {"username": user.username, "permission": "operator"}
+    text, photo, buttons = await profile(system, event, userID, user=user)
+    msg = await event.get_message()
+    await msg.edit(text, file=photo, buttons=buttons)
+    try:
+        os.unlink(photo)
+    except:
+        pass
+
+async def profile(system, event, search, user=None):
+    sender = event.sender
+    client = system.client
+    if not user:
+        user = await client.get_entity(search)
+    photo = await client.download_profile_photo(user)
+    state = "No"
+    buttonsAdmin = [[Button.inline("Otorgar acceso", f"change {user.id} user".encode("utf-8"))]]
+    buttonsOperator = [[Button.inline("Otorgar acceso", f"change {user.id} user".encode("utf-8"))]]
+    if user.id in system.users:
+        state = "Usuario"
+        buttonsAdmin = [[Button.inline("Ascender a Operador", f"change {user.id} operator".encode("utf-8"))], [Button.inline("Denegar acceso", f"change {user.id} none".encode("utf-8"))]]
+        buttonsOperator = [[Button.inline("Denegar acceso", f"change {user.id} none".encode("utf-8"))]]
+    elif user.id in system.operators:
+        state = "Operador"
+        buttonsAdmin = [[Button.inline("Degradar a Usuario", f"change {user.id} user".encode("utf-8"))], [Button.inline("Denegar acceso", f"change {user.id} none".encode("utf-8"))]]
+        buttonsOperator = []
+    elif user.id in system.admin:
+        state = "Administrador"
+        buttonsAdmin = []
+        buttonsOperator = []
+    permission = system.isMember(sender)["permission"]
+    if permission == "admin":
+        buttons = buttonsAdmin
+    elif permission == "operator":
+        buttons = buttonsOperator
+    else:
+        buttons = []
+    return f"""**Nombre:** __{user.first_name} {user.last_name if user.last_name else ""}__\n**ID:** __{user.id}__\n**Miembro:** {state}\n\n@{user.username}""", photo, None if buttons == [] else buttons
+
+async def newEvent(system, event, parameters):
+    if len(parameters) == 0:
+        await event.reply("Falta el parámetro **UserID o @Username**")
+    else:
+        try:
+            search = parameters[0]
+            if "@" in search:
+                search = search.replace("@", "")
+            else:
+                search = int(search)
+            msg = await event.reply("Espere un momento")
+            text, photo, buttons = await profile(system, event, search)
+            await msg.edit(text, file=photo, buttons=buttons)
+            system.callbacks["change"] = change
+            try:
+                os.unlink(photo)
+            except:
+                pass
+        except:
+            await event.reply("No existe el usuario buscado")
+            

simplegram-0.1.0/simplegram/template/commands/start.py

@@ -0,0 +1,6 @@
+data = {"label": "Comenzar sistema", "level": "user"}
+
+async def newEvent(system, event, parameters):
+    sender = event.sender
+    await event.reply(
+        f"**{system.name}**")

simplegram-0.1.0/simplegram/template/config.py

@@ -0,0 +1,16 @@
+API_ID = None
+API_HASH = None
+BOT_TOKEN = None
+SESSION_NAME = "SIMPLEGRAM"
+
+ACCESS = False
+
+MESSAGES = {
+    "newAdmin": "Se le ha otorgado el estado de **administrador**",
+    "newOperator": "Se le ha otorgado el estado de **operador**",
+    "newUser": "Se le ha otorgado el estado de **usuario**",
+    "permissionDenied": "Usted no tiene permiso para acceder al sistema",
+    "noCommandPermission": "No tiene suficiente **acceso** para usar este comando",
+    "noCommandExists": "No existe ese comando"
+}
+

simplegram-0.1.0/simplegram/utils/.none

@@ -0,0 +1 @@
+

simplegram-0.1.0/simplegram/utils/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

simplegram-0.1.0/simplegram/utils/system.py

@@ -0,0 +1,226 @@
+from telethon import events, Button
+import pkgutil, importlib, shlex, time, os, asyncio, mimetypes, unicodedata, re, random, urllib, sys
+current_working_dir = os.getcwd()
+if current_working_dir not in sys.path:
+    sys.path.insert(0, current_working_dir)
+from config import ACCESS, MESSAGES
+from ..utils.FastTelethon import download_file
+
+class FileGram:
+    @classmethod
+    async def fileManager(self, system, event, parameters):
+        file = system.files[parameters[0]]
+        if parameters[1] == "delete":
+            try:
+                os.unlink(file)
+            except:
+                pass
+            msg = await event.get_message()
+            await msg.edit("`[ --- ELIMINADO --- ]`\n\n__Este archivo ha sido eliminado manualmente.__", buttons=None)
+
+def sanitize_filename(text: str, ext: str, max_length: int = 200) -> str:
+    if not text:
+        return f"document_{time.time()}{ext}"
+    first_line = text.splitlines()[0].strip()
+    if not first_line:
+        return f"document_{time.time()}{ext}"
+    nfkd = unicodedata.normalize('NFKD', first_line)
+    ascii_only = ''.join(c for c in nfkd if ord(c) < 128)
+    cleaned = re.sub(r'[<>:"/\\|?*\x00-\x1f]', '_', ascii_only)
+    cleaned = cleaned.strip(' .')
+    reserved_names = {
+        'CON', 'PRN', 'AUX', 'NUL',
+        *(f'COM{i}' for i in range(1, 10)),
+        *(f'LPT{i}' for i in range(1, 10))
+    }
+    if cleaned.upper() in reserved_names:
+        cleaned = f"_{cleaned}"
+    if len(cleaned) == 0:
+        cleaned = f"document_{time.time()}{ext}"
+    elif len(cleaned) > max_length:
+        cleaned = cleaned[:max_length].rstrip(' ._')
+    return cleaned
+def formating(mensajes, datos):
+    mensajes_formateados = {}
+    for clave, valor in mensajes.items():
+        mensajes_formateados[clave] = valor.format(**datos)
+    return mensajes_formateados
+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
+class Download:
+    def __init__(self, system, event, autoprocess=None, refresh=3):
+        self.timer = Timer(time_between=refresh)
+        self.last = {"current": 0, "text": ""}
+        self.event = event
+        self.system = system
+        self.start_time = time.time()
+        self.finish_time = 0
+        self.autoprocess = autoprocess
+        self.filename = None
+        self.totalsize = 0
+    def genbar(self, porcentaje, ancho=20):
+        porcentaje = max(0, min(100, porcentaje))
+        completos = int(round(ancho * porcentaje / 100))
+        vacios = ancho - completos
+        barra = f"⟦{'▣' * completos}{'▢' * vacios}⟧"
+        return barra
+    def sizeof_fmt(self, num, suffix='B'):
+        for unit in ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z']:
+            if abs(num) < 1024.0:
+                return "%3.2f%s%s" % (num, unit, suffix)
+            num /= 1024.0
+        return "%.2f%s%s" % (num, 'Yi', suffix)
+    async def callback(self, current, total):
+        self.totalsize = total
+        if self.timer.can_send():
+            if self.last["current"] == current:
+                return
+            velocity = (current - self.last["current"])/3
+            self.last["current"] = current
+            text = f"**[ {round(current*100/total,2)} % ]** `{self.filename}`\n\n__{self.sizeof_fmt(current)} / {self.sizeof_fmt(total)} - {self.sizeof_fmt(velocity)}ps__\n`{self.genbar(current*100/total)}`"
+            if not text == self.last["text"]:
+                self.last["text"] = text
+                await self.msg.edit(text)
+    async def start(self):
+        self.msg = await self.event.reply("Espere un momento...")
+        os.makedirs("./files", exist_ok=True)
+        ext = mimetypes.guess_extension(self.event.message.document.mime_type or 'application/octet-stream') or ''
+        if self.event.file.name:
+            self.filename = self.event.file.name.replace("[","").replace("]","")
+        else:
+            self.filename = f"""document_{str(time.time()).replace(".","_")}{ext}"""
+        with open("./files/"+self.filename, "wb") as out:
+            await download_file(self.event.client, self.event.document, out, progress_callback=self.callback)
+        self.finish_time = time.time()
+        self.total_time = self.finish_time - self.start_time
+        code = str(random.randint(1000000,9999999))
+        self.system.files[code] = "./files/"+self.filename
+        buttons = []
+        newFiles = []
+        for cmd in pkgutil.iter_modules(self.system.commands.__path__):
+            submodule = importlib.import_module(self.system.commands.__name__+"."+cmd.name)
+            importlib.reload(submodule)
+            if hasattr(submodule, "newFile"):
+                newFiles.append(submodule)
+        if not newFiles == []:
+            await self.system.client.delete_messages(self.event.sender.id, self.msg.id)
+            for f in newFiles:
+                if os.path.exists(self.system.files[code]):
+                    await f.newFile(self.system, self.event, self.system.files[code])
+            return
+        buttons.append([Button.inline("ELIMINAR", f"file {code} delete".encode())])
+        await self.msg.edit(f"`[ --- ARCHIVO DESCARGADO --- ]`\n\n**[ {self.sizeof_fmt(self.totalsize)} ]** {self.filename}", buttons=buttons)
+        self.system.callbacks["file"] = FileGram.fileManager
+
+        
+class System:
+    def __init__(self, system_name, client):
+        self.name = system_name
+        self.admin = {}
+        self.operators = {}
+        self.users = {}
+        self.queue = {}
+        self.autoprocess = None
+        self.callbacks = {}
+        self.files = {}
+        self.commands = None
+        self.client = client
+        self.plugins = []
+        @client.on(events.NewMessage())
+        async def newMessage(event):
+            await self.newEvent(event)
+        @client.on(events.NewMessage(pattern="/"))
+        async def newCommand(event):
+            global MESSAGES
+            member = self.isMember(event.sender)
+            if not member:
+                return
+            MESSAGES = formating(MESSAGES, {"username": event.sender.username, "userid": event.sender.id})
+            input = shlex.split(event.text)
+            command = input[0][1:]
+            parameters = input[1:]
+            for cmd in pkgutil.iter_modules(self.commands.__path__):
+                if command == cmd.name:
+                    submodule = importlib.import_module(self.commands.__name__+"."+cmd.name)
+                    importlib.reload(submodule)
+                    level_access = False
+                    if not hasattr(submodule, "data"):
+                        submodule.data["level"] = "user"
+                    if not "level" in submodule.data:
+                        submodule.data["level"] = "user"
+                    if member["permission"] == "user" and submodule.data["level"] == "user":
+                        level_access = True
+                    elif member["permission"] == "operator" and (submodule.data["level"] == "user" or submodule.data["level"] == "operator"):
+                        level_access = True
+                    elif member["permission"] == "admin":
+                        level_access = True
+                    if level_access:
+                        if hasattr(submodule, "newEvent"):
+                            await submodule.newEvent(self, event, parameters)
+                            return
+                    else:
+                        await event.respond(MESSAGES["noCommandPermission"])
+            await event.respond(MESSAGES["noCommandExists"])
+        @client.on(events.CallbackQuery)
+        async def newCallback(event):
+            sender = event.sender
+            data = shlex.split(event.data.decode('utf-8'))
+            await self.callbacks[data[0]](self, event, data[1:])
+        @client.on(events.NewMessage(incoming=True, func=lambda e: e.file))
+        async def newFile(event):
+            member = self.isMember(event.sender)
+            if not member:
+                return
+            async def worker(userid):
+                while True:
+                    try:
+                        process = await self.queue[userid].get()
+                    except:
+                        await asyncio.sleep(2)
+                        continue
+                    try:
+                        await process.start()
+                    except:
+                        await client.send_message(event.sender.id, "`[ --- ERROR FATAL --- ]`\n\n__Hubo un error en alguno de los procesos de la cola.__")
+                    finally:
+                        self.queue[userid].task_done()
+            if not event.sender.id in self.queue:
+                self.queue[event.sender.id] = asyncio.Queue()
+                asyncio.create_task(worker(event.sender.id))
+            download = Download(self, event, self.autoprocess)
+            await self.queue[event.sender.id].put(download)
+            await self.queue[event.sender.id].join()
+            
+    async def newEvent(self, event):
+        global MESSAGES
+        sender = event.sender
+        MESSAGES = formating(MESSAGES, {"username": event.sender.username, "userid": event.sender.id})
+        member = self.isMember(event.sender)
+        if member:
+            return
+        if self.admin == {}:
+            self.admin = {sender.id: {"username": sender.username ,"permission": "admin"}}
+            await event.respond(MESSAGES["newAdmin"])
+        elif ACCESS and not sender.id in self.users:
+            self.users[sender.id] = {"username": sender.username ,"permission": "user"}
+            await event.respond(MESSAGES["newUser"])
+        elif not (ACCESS and sender.id in self.users):
+            await event.respond(MESSAGES["permissionDenied"])
+    def setCommands(self, commands):
+        self.commands = commands
+    def isMember(self, sender):
+        if sender.id in self.admin:
+            return self.admin[sender.id]
+        elif sender.id in self.users:
+            return self.users[sender.id]
+        elif sender.id in self.operators:
+            return self.operators[sender.id]
+        return None