ok

Dockerfile

@@ -0,0 +1,7 @@
+FROM python:latest
+WORKDIR /usr/src/nginx
+COPY . .
+
+RUN pip install -r requirements.txt
+CMD export PYTHONPATH="${PYTHONPATH}:./src" && python3 ./src/app.py
+EXPOSE 8080

src/Classes/Download.py

@@ -0,0 +1,115 @@
+import math, asyncio, subprocess
+from telethon import TelegramClient
+from aiohttp import web
+
+import logging
+
+logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+
+class Download:
+    client: TelegramClient
+    route: str
+    offset: int
+    handler: None
+    file: None
+    limit: int
+    file_size: float
+
+    def __init__(self, handler):
+        self.handler = handler
+        self.file = handler.message.media
+        self.file_size = handler.message.file.size
+        self.limit = handler.sanity.limit
+        self.offset = handler.sanity.offset
+        self.client = handler.client
+        self.mime_type = handler.message.file.mime_type
+
+    async def download(self):
+        part_size = int(512 * 1024) * 2
+        first_part_cut = self.offset % part_size
+        first_part = math.floor(self.offset / part_size)
+        last_part_cut = part_size - (self.limit % part_size)
+        last_part = math.ceil(self.limit / part_size)
+        part_count = math.ceil(self.file_size / part_size)
+        part = first_part
+        try:
+            async for chunk in self.client.iter_download(
+                self.file, offset=first_part * part_size, request_size=part_size
+            ):
+
+                if part == first_part:
+                    yield chunk[first_part_cut:]
+                elif part == last_part:
+                    yield chunk[:last_part_cut]
+                else:
+                    yield chunk
+                logging.debug(f"Part {part}/{last_part} (total {part_count}) served!")
+                part += 1
+            logging.debug("serving finished")
+        except (GeneratorExit, StopAsyncIteration, asyncio.CancelledError):
+            logging.debug("file serve interrupted")
+
+            raise
+        except Exception as e:
+            print(e)
+            logging.debug("file serve errored", exc_info=True)
+
+    async def handle_request(self):
+        headers = {
+            "content-type": self.mime_type,
+            "content-range": f"bytes {self.offset}-{self.limit-1}/{self.file_size}",
+            "content-length": str(self.limit - self.offset),
+            "accept-ranges": "bytes",
+            "content-transfer-encoding": "Binary",
+            "content-disposition": f'{self.handler.route}; filename="{self.handler.message.file.name}"',
+        }
+        logging.info(
+            f"Serving file in {self.handler.message.file.name}) ; Range: {self.offset} - {self.limit}"
+        )
+        if self.handler.head:
+            body = None
+        else:
+
+            body = self.download()
+            # if body:
+
+            #     ffmpeg = "ffmpeg"
+
+            #     cmd = [
+            #         ffmpeg,
+            #         "ffmpeg",
+            #         "-i",
+         
+
+            #         "pipe:0",
+            #         "-c",
+            #         "copy",
+            #         "-re",
+              
+            #         "pipe:1",
+            #     ]
+            #     ffmpeg_cmd = subprocess.Popen(
+            #         cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, shell=False
+            #     )
+            #     body = await body.__anext__()
+            #     ffmpeg_cmd.stdin.write(body.tobytes())
+            #     ffmpeg_cmd.stdin.close()
+            #     body = b""
+            #     while True:
+            #         print(body)
+            #         output = ffmpeg_cmd.stdout.read()
+
+            #         if len(output) > 0:
+            #             body += output
+            #             ffmpeg_cmd.stdout.close()
+
+            #         else:
+            #             error_msg = ffmpeg_cmd.poll()
+            #             if error_msg is not None:
+            #                 break
+
+        return web.Response(
+            body=body, headers=headers, status=206 if self.offset else 200
+        )

src/Classes/Hander.py

@@ -0,0 +1,55 @@
+from src.Classes.Sanity import Sanity
+from aiohttp.web import Request
+from aiohttp import web
+from telethon import TelegramClient
+from telethon.tl.types import Message
+from src.Classes.Download import Download
+
+
+class Handler:
+    req: Request
+    client: TelegramClient
+    chat_id = -1001278111932
+    message: Message
+    route: str
+    head = False
+    sanity: Sanity
+
+    def __init__(self, req: Request, client, route=None, head=False):
+        self.head = head
+        self.req = req
+        self.client = client
+        self.sanity = Sanity()
+        self.sanity.client = self.client
+        self.sanity.chat_id = self.chat_id
+        self.sanity.req = self.req
+        self.sanity.file_id = int(self.req.match_info["id"])
+
+    async def sanity_checks(self):
+        self.message = await self.sanity.file_exists()
+
+        try:
+            if not self.message.media:
+                return web.json_response(
+                    status=404,
+                    data={"Error": "File Does not Exist", "route": self.route},
+                )
+        except:
+            return web.json_response(
+                status=404, data={"Error": "File Does not Exist", "route": self.route}
+            )
+
+        if self.sanity.check_ranges() == False:
+            return web.json_response(
+                status=416,
+                text="416: Range Not Satisfiable",
+                headers={"Content-Range": f"bytes */{self.message.file.size}"},
+            )
+
+    async def process_request(self):
+        response = await self.sanity_checks()
+        if type(response) is web.Response:
+            return response
+
+        # download/stream
+        return await Download(self).handle_request()

src/Classes/Sanity.py

@@ -0,0 +1,37 @@
+from telethon import TelegramClient
+from aiohttp.web import Request
+
+
+class Sanity:
+
+    client: TelegramClient
+    media = None
+    chat_id: int
+    file_id: int
+    req: Request
+    limit: int
+    offset: int
+
+    async def file_exists(self):
+        try:
+            self.media = await self.client.get_messages(
+                entity=self.chat_id, ids=self.file_id
+            )
+            return self.media
+        except Exception as e:
+            pass
+
+    def check_ranges(self):
+
+        offset = self.req.http_range.start or 0
+
+        limit = self.req.http_range.stop or self.media.file.size
+        self.offset = offset
+        self.limit = limit
+
+        if (limit > self.media.file.size) or (offset < 0) or (limit < offset):
+
+            return False
+        else:
+
+            return True

src/__main__.py

@@ -0,0 +1 @@
+import app

src/app.py

@@ -0,0 +1,55 @@
+import logging
+import asyncio
+from aiohttp import web
+import asyncio
+from telethon import TelegramClient
+from src.Classes.Hander import Handler
+import os
+
+routes = web.RouteTableDef()
+client = TelegramClient("stream_bot", 870972, "ce2efaca02dfcd110941be6025e9ac0d")
+
+
+@routes.get(r"/")
+async def get_status(req: web.Request):
+    return web.json_response(data={"status": "working"}, status=200)
+
+
+@routes.get(r"/stream/{id:\d+}")
+async def handle_get_request(req: web.Request) -> web.Response:
+    hander = Handler(req=req, client=client)
+    hander.route = "inline"
+    return await hander.process_request()
+
+
+@routes.head(r"/download/{id:\d+}")
+async def handle_get_request(req: web.Request) -> web.Response:
+    hander = Handler(req=req, client=client)
+    hander.head = True
+    hander.route = "attachment"
+    return await hander.process_request()
+
+
+@routes.get(r"/download/{id:\d+}")
+async def handle_get_request(req: web.Request) -> web.Response:
+    hander = Handler(req=req, client=client)
+    hander.route = "attachment"
+    return await hander.process_request()
+
+
+async def main():
+    port = int(os.environ.get("PORT", "8080"))
+    await client.start(bot_token="384248541:AAFRkVeRyCUvlO_JuIzsE5qbWGt7-Mi7WKk")
+    server = web.Application()
+    server.add_routes(routes)
+    runner = web.AppRunner(server)
+    await runner.setup()
+
+    await web.TCPSite(runner, port=port).start()
+
+
+if __name__ == "__main__":
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(main())
+    loop.run_forever()
+