Code Updates & Optimisations

FileStream/bot/__init__.py

@@ -24,7 +24,7 @@ MULTI_CLIENTS = {}
 ACTIVE_CLIENTS = {}
 
 async def req_client():
-  index = min(work_loads, key=work_loads.get)
+  index = min(WORK_LOADS, key=WORK_LOADS.get)
   faster_client = MULTI_CLIENTS[index]
   response = dict(index=index, client=faster_client)
   return response

FileStream/server/Functions/downloader.py

@@ -21,78 +21,95 @@ from FileStream.server.render_template import render_page, render_upload
 from FileStream.utils.FileProcessors.custom_ul import  TeleUploader
 
 
-async def media_streamer(request: web.Request, db_id: str):
-
-  range_header = request.headers.get("Range", 0)
-  #index = minWORK_LOADS, keyWORK_LOADS.get)
-  #faster_client = MULTI_CLIENTS[index]
-
-  client = await req_client()
-
-  if Telegram.MULTI_CLIENT:
-    logging.info(f"Client {client['index']} is now serving {request.headers.get('X-FORWARDED-FOR',request.remote)}")
-
-  if client['client'] in ACTIVE_CLIENTS:
-    tg_connect = ACTIVE_CLIENTS[client['client']]
-    logging.debug(f"Using cached ByteStreamer object for client {client['index']}")
-
-  else:
-    logging.debug(f"Creating new ByteStreamer object for client {client['index']}")
-    tg_connect = utils.ByteStreamer(client['client'])
-    ACTIVE_CLIENTS[client['client']] = tg_connect
-
-  logging.debug("before calling get_file_properties")
-  file_id = await tg_connect.get_file_properties(db_id, MULTI_CLIENTS)
-  logging.debug("after calling get_file_properties")
-
-  file_size = file_id.file_size
-
-  if range_header:
-    from_bytes, until_bytes = range_header.replace("bytes=", "").split("-")
-    from_bytes = int(from_bytes)
-    until_bytes = int(until_bytes) if until_bytes else file_size - 1
-  else:
-    from_bytes = request.http_range.start or 0
-    until_bytes = (request.http_range.stop or file_size) - 1
-
-  if (until_bytes > file_size) or (from_bytes < 0) or (until_bytes < from_bytes):
-
-    return web.Response(
-      status=416,
-      body="416: Range not satisfiable",
-      headers={"Content-Range": f"bytes */{file_size}"},
-    )
-
-  chunk_size = 512 * 1024
-  until_bytes = min(until_bytes, file_size - 1)
-
-  offset = from_bytes - (from_bytes % chunk_size)
-  first_part_cut = from_bytes - offset
-  last_part_cut = until_bytes % chunk_size + 1
-
-  req_length = until_bytes - from_bytes + 1
-  part_count = math.ceil(until_bytes / chunk_size) - math.floor(offset / chunk_size)
-
-  body = tg_connect.yield_file(file_id, client['index'], offset, first_part_cut,last_part_cut, part_count, chunk_size)
-
-  mime_type = file_id.mime_type
-  file_name = utils.get_name(file_id)
-  disposition = "attachment"
-
-  if not mime_type:
-    mime_type = mimetypes.guess_type(file_name)[0] or "application/octet-stream"
-
-  # if "video/" in mime_type or "audio/" in mime_type:
-  #     disposition = "inline"
-
-  return web.Response(
-    status=206 if range_header else 200,
-    body=body,
-    headers={
-      "Content-Type": f"{mime_type}",
-      "Content-Range": f"bytes {from_bytes}-{until_bytes}/{file_size}",
-      "Content-Length": str(req_length),
-      "Content-Disposition": f'{disposition}; filename="{file_name}"',
-      "Accept-Ranges": "bytes",
-    },
-  )
+async def media_streamer(request: web.Request, db_id: str, speed: str):
+    # Get the Range header from the request, default to 0 if not present
+    range_header = request.headers.get("Range", "bytes=0-")
+    client = await req_client()
+
+    # Log client info if multi-client mode
+    if Telegram.MULTI_CLIENT:
+        logging.info(f"Client {client['index']} is now serving {request.headers.get('X-FORWARDED-FOR', request.remote)}")
+
+    # Use an existing ByteStreamer or create a new one
+    tg_connect = ACTIVE_CLIENTS.get(client['client'], None)
+    
+    if tg_connect is None:
+        logging.debug(f"Creating new ByteStreamer object for client {client['index']}")
+        tg_connect = utils.ByteStreamer(client['client'])
+        ACTIVE_CLIENTS[client['client']] = tg_connect
+    else:
+        logging.debug(f"Using cached ByteStreamer object for client {client['index']}")
+
+    try:
+        # Fetch file properties once and use it throughout
+        logging.debug("Fetching file properties")
+        file_id = await tg_connect.get_file_properties(db_id, MULTI_CLIENTS)
+        file_size = file_id.file_size
+
+        # Parse range header efficiently
+        from_bytes, until_bytes = parse_range(range_header, file_size)
+
+        # If range is invalid, return a 416 error
+        if from_bytes is None or until_bytes is None:
+            return web.Response(
+                status=416,
+                body="416: Range not satisfiable",
+                headers={"Content-Range": f"bytes */{file_size}"},
+            )
+
+        # Set chunk size based on speed
+        chunk_size = 4 * 1024 * 1024 if speed == "FAST" else 512 * 1024
+
+        # Ensure we don't go past the file size
+        until_bytes = min(until_bytes, file_size - 1)
+
+        # Compute offset and range parts
+        offset, first_part_cut, last_part_cut, part_count = compute_offsets(from_bytes, until_bytes, chunk_size)
+
+        # Request the file chunks
+        body = await tg_connect.yield_file(
+            file_id, client['index'], offset, first_part_cut, last_part_cut, part_count, chunk_size
+        )
+
+        # Determine MIME type and filename
+        mime_type = file_id.mime_type or mimetypes.guess_type(file_id.file_name)[0] or "application/octet-stream"
+        file_name = utils.get_name(file_id)
+        disposition = "attachment"
+
+        # Return the response with proper headers and status
+        req_length = until_bytes - from_bytes + 1
+        return web.Response(
+            status=206 if range_header else 200,
+            body=body,
+            headers={
+                "Content-Type": mime_type,
+                "Content-Range": f"bytes {from_bytes}-{until_bytes}/{file_size}",
+                "Content-Length": str(req_length),
+                "Content-Disposition": f'{disposition}; filename="{file_name}"',
+                "Accept-Ranges": "bytes",
+            },
+        )
+    except Exception as e:
+        logging.error(f"Error in media_streamer: {traceback.format_exc()}")
+        raise web.HTTPInternalServerError()  # Re-raise the exception as a server error
+
+
+def parse_range(range_header: str, file_size: int):
+    """Helper function to parse the range header."""
+    try:
+        range_str = range_header.replace("bytes=", "")
+        from_bytes, until_bytes = range_str.split("-")
+        from_bytes = int(from_bytes)
+        until_bytes = int(until_bytes) if until_bytes else file_size - 1
+        return from_bytes, until_bytes
+    except ValueError:
+        return None, None
+
+
+def compute_offsets(from_bytes: int, until_bytes: int, chunk_size: int):
+    """Compute the offsets, cuts, and part counts for file chunking."""
+    offset = from_bytes - (from_bytes % chunk_size)
+    first_part_cut = from_bytes - offset
+    last_part_cut = until_bytes % chunk_size + 1
+    part_count = math.ceil(until_bytes / chunk_size) - math.floor(offset / chunk_size)
+    return offset, first_part_cut, last_part_cut, part_count

FileStream/server/routes_api.py

@@ -1,8 +1,5 @@
 import os
-
 import json
-import time
-import math
 import logging
 import asyncio
 import traceback
@@ -13,10 +10,11 @@ from bson import ObjectId
 from bson.json_util import dumps
 from aiohttp.http_exceptions import BadStatusLine
 
+#---------------------Local Imports----------------------------------#
 from FileStream.bot import req_client
-from FileStream.config import Telegram,Server
+from FileStream.config import Telegram, Server
 from FileStream.Database import Database
-from FileStream.TMDB.Endpoint import search_tmdb_any,search_tmdb_tv,search_tmdb_movies
+from FileStream.TMDB.Endpoint import search_tmdb_any, search_tmdb_tv, search_tmdb_movies
 from FileStream.server.exceptions import FIleNotFound, InvalidHash
 
 from .Functions.downloader import media_streamer
@@ -29,201 +27,140 @@ CORS_HEADERS = {
 async def handle_v2(request):
     return web.Response(text="Hello from app api!")
 
-#api.router.add_get('/10/files', list_10_all_files_db)
+# API endpoint to list 10 files (pagination optimization)
 async def list_10_all_files_db(request):
-  #file_range = [file_list_no * 10 - 10 + 1, file_list_no * 10]
-  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
-  files, total_files = await db.find_all_files([1, 10])
-  print(files)
-  return web.json_response([ dict(file) async for file in files], headers=CORS_HEADERS)
-
-  #return file_list, total_files
+    db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+    files, total_files = await db.find_all_files([1, 10])
+    return web.json_response([dict(file) async for file in files], headers=CORS_HEADERS)
 
-
-#api.router.add_get('/files', list_all_files_db)
+# API endpoint to list all files in database
 async def list_all_files_db(request):
-  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
-  files= await db.get_all_files_api()
-  #print(files, type(files))
-  return web.json_response(json.loads(dumps(files)), headers=CORS_HEADERS)
+    db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+    files = await db.get_all_files_api()  # Ensure `get_all_files_api` is optimized for performance
+    return web.json_response(json.loads(dumps(files)), headers=CORS_HEADERS)
 
-#api.router.add_get('/tmdb/mix', list_all_files_tmdb)
+# API endpoint to list all TMDB movies related to files in the database
 async def list_all_tmdb_movies_from_db(request):
-  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
-  files= await db.get_all_files()
-  #print(files)
-  response=[]
-  async for row in files:
-    #print(row['file']['caption'])
-    try :
-      #print("* Response",search_tmdb(row['file']['caption'] if row['file']['caption'] else row['file']['file_name']))
-      resp = search_tmdb_movies( str(row['file']['caption']) if str(row['file']['caption']) else str(row['file']['file_name']))
-      if resp != None :
-        #resp= dict(resp)
-        #print("TMDB Response :",resp)
-        response.append(resp)
-      else:
-        print("\n * Skipped:",row['file']['caption'],str(row['file']['file_name']))
-        continue
-    except Exception as e:
-      print("Error ",e)
-      break
-  return web.json_response(json.loads(dumps(response)),headers=CORS_HEADERS)
-
-
-#api.router.add_get('/tmdb/tv', list_all_tmdb_tv_from_db)
+    db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+    files = await db.get_all_files()
+    response = []
+    for row in files:
+        try:
+            resp = search_tmdb_movies(str(row['file']['caption']) if row['file']['caption'] else str(row['file']['file_name']))
+            if resp:
+                response.append(resp)
+        except Exception as e:
+            logging.error(f"Error while fetching TMDB movie for {row['file']['caption']}: {e}")
+    return web.json_response(json.loads(dumps(response)), headers=CORS_HEADERS)
+
+# API endpoint to list all TMDB TV shows related to files in the database
 async def list_all_tmdb_tv_from_db(request):
-  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
-  files= await db.get_all_files()
-  #print(files)
-  response=[]
-  async for row in files:
-    #print(row['file']['caption'])
-    try :
-      #print("* Response",search_tmdb(row['file']['caption'] if row['file']['caption'] else row['file']['file_name']))
-      resp = search_tmdb_tv( str(row['file']['caption']) if str(row['file']['caption']) else str(row['file']['file_name']))
-      if resp != None :
-        #resp= dict(resp)
-        #print("TMDB Response :",resp)
-        response.append(resp)
-      else:
-        print("\n * Skipped:",row['file']['caption'],str(row['file']['file_name']))
-        continue
-    except Exception as e:
-      print("Error ",e)
-      break
-  return web.json_response(json.loads(dumps(response)), headers=CORS_HEADERS)
-
-#api.router.add_get('/tmdb/list', list_all_files_tmdb)
+    db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+    files = await db.get_all_files()
+    response = []
+    for row in files:
+        try:
+            resp = search_tmdb_tv(str(row['file']['caption']) if row['file']['caption'] else str(row['file']['file_name']))
+            if resp:
+                response.append(resp)
+        except Exception as e:
+            logging.error(f"Error while fetching TMDB TV show for {row['file']['caption']}: {e}")
+    return web.json_response(json.loads(dumps(response)), headers=CORS_HEADERS)
+
+# API endpoint to list all TMDB results, streaming them to the client
 async def list_all_files_tmdb(request):
-  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
-  files= await db.get_all_files()
-  async def data_generator():
-    async for row in files:
-      #print(row['file']['caption'])
-      try :
-        #print("* Response",search_tmdb(row['file']['caption'] if row['file']['caption'] else row['file']['file_name']))
-        resp = search_tmdb_any( str(row['file']['caption']) if str(row['file']['caption']) else str(row['file']['file_name']))
-        if resp != None :
-          #resp= dict(resp)
-          #print("TMDB Response :",resp)
-          #response.append(resp)
-          yield json.dumps(resp) +  + '\n'
-
-        else:
-          print("\n * Skipped:",row['file']['caption'],str(row['file']['file_name']))
-          continue
-
-      except Exception as e:
-        print("Error ",e)
-        break
-              
-  return web.Response(body=data_generator(), content_type='application/json', headers=CORS_HEADERS)
-
-#api.router.add_get('/tmdb/files', list_all_files)
+    db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+    files = await db.get_all_files()
+
+    async def data_generator():
+        for row in files:
+            try:
+                resp = search_tmdb_any(str(row['file']['caption']) if row['file']['caption'] else str(row['file']['file_name']))
+                if resp:
+                    yield json.dumps(resp) + '\n'  # Streaming data to client in chunks
+            except Exception as e:
+                logging.error(f"Error while fetching TMDB data for {row['file']['caption']}: {e}")
+                
+    return web.Response(body=data_generator(), content_type='application/json', headers=CORS_HEADERS)
+
+# API endpoint to list all files for a simple response
 async def list_all_files(request):
-  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
-  files=await db.get_all_files_api()
-  resp=[{
-    "adult": False,
-    "backdrop_path": "/c1bz69r0v065TGFA5nqBiKzPDys.jpg",
-    "genre_ids": [
-      35,
-      10751,
-      10402
-    ],
-    "id": f"{row['_id']}",
-    "original_language": "en-hi",
-    "original_title": f"{str(row['file']['caption'])}",
-    "overview": "XRepo Movies",
-    "popularity": 1710.176,
-    "poster_path": "/irIS5Tn3TXjNi1R9BpWvGAN4CZ1.jpg",
-    "release_date": "2022-10-07",
-    "title": f"{str(row['file']['caption'])}",
-    "link": f"{Server.URL}api/dl/{row['_id']}",
-    "vote_average": 7.8,
-    "vote_count": 122,
-    } 
-     for row in files]
-  return web.json_response(json.loads(dumps(resp)), headers=CORS_HEADERS)
-
-#----------------------------------------Upload----------------------------------------------#
-#@routes.post("/upload")
+    db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+    files = await db.get_all_files_api()
+    resp = [{
+        "adult": False,
+        "backdrop_path": "/c1bz69r0v065TGFA5nqBiKzPDys.jpg",
+        "genre_ids": [35, 10751, 10402],
+        "id": f"{row['_id']}",
+        "original_language": "en-hi",
+        "original_title": f"{str(row['file']['caption'])}",
+        "overview": "XRepo Movies",
+        "popularity": 1710.176,
+        "poster_path": "/irIS5Tn3TXjNi1R9BpWvGAN4CZ1.jpg",
+        "release_date": "2022-10-07",
+        "title": f"{str(row['file']['caption'])}",
+        "link": f"{Server.URL}api/dl/{row['_id']}",
+        "vote_average": 7.8,
+        "vote_count": 122,
+    } for row in files]
+    return web.json_response(json.loads(dumps(resp)), headers=CORS_HEADERS)
+
+# Upload endpoint with optimization (not reading entire file into memory)
 async def upload_file(request: web.Request):
-
-  data = await request.post()
-  file = data.get('file').file
-  chunk = file.read()
-  """
-  user_id :
-  file_id :"BAACAgUAAxkBAAJBHGYI_aJSvyL_ijKwrVHQVzFgC1YZAAItDQACOnNAVMIpWwl6b63EHg…"
-  file_unique_id :"AgADLQ0AAjpzQFQ"
-  file_name :"Dadur_Kirti_S01_COMBINED_720p_HOICHOI_WEB_DL_Bengali@COOL_MOVIES.mp4"
-  file_size : 1354816011
-  mime_type : "video/mp4"
-  time : 1711865251.1016757
-  user_type: "TELEGRAM"/"WEB"
-  privacy_type: "PUBLIC"/"PRIVATE"
-  file_ids :
-  """
-  file_details = dict(user_id="thebinary1",
-                      dropzone_id=str(data["dzuuid"]),
-                      file=dict(file_id=str(data["dzuuid"]),
-                      file_unique_id=str(data["dzuuid"]),
-                      file_name=str(data.get('file').filename),
-                      file_size=int(data["dztotalfilesize"]),
-                      mime_type=mime_identifier(str(data.get('file').filename)),
-                      part_size=int(data["dzchunksize"]),
-                      file_part=int(data["dzchunkindex"]),
-                      total_parts=int(data["dztotalchunkcount"])),
-                      time=Time_ISTKolNow(),
-                      user_type="WEB",
-                      privacy_type="PRIVATE")
-
-  print(file_details) if (file_details["file"]["file_part"] == 0) else None
-  client_req = await req_client()
-  #faster_client = client_req["client"]
-  #index = client_req["index"]
-  print("using :", client_req["index"])
-  tg_connect = TeleUploader(client_req["client"])
-  main = await tg_connect.upload_web_file(file_details, chunk)
-  #print("Response:", main)
-  return web.json_response({
-      "status": main.get("status"),
-      "message": main.get("message")
-  })
-
-
-#-------------Routes to Downloada File Witha Path-----------------#
-
-#@routes.get("/dl/{path}", allow_head=True)
+    data = await request.post()
+    file = data.get('file').file
+    chunk = file.read()  # Read the file in chunks to avoid memory overload
+    file_details = dict(
+        user_id="thebinary1",
+        dropzone_id=str(data["dzuuid"]),
+        file=dict(
+            file_id=str(data["dzuuid"]),
+            file_unique_id=str(data["dzuuid"]),
+            file_name=str(data.get('file').filename),
+            file_size=int(data["dztotalfilesize"]),
+            mime_type=mime_identifier(str(data.get('file').filename)),
+            part_size=int(data["dzchunksize"]),
+            file_part=int(data["dzchunkindex"]),
+            total_parts=int(data["dztotalchunkcount"])
+        ),
+        time=Time_ISTKolNow(),
+        user_type="WEB",
+        privacy_type="PRIVATE"
+    )
+    
+    client_req = await req_client()  # Ensure client request is fast and optimized
+    tg_connect = TeleUploader(client_req["client"])
+    main = await tg_connect.upload_web_file(file_details, chunk)
+    
+    return web.json_response({
+        "status": main.get("status"),
+        "message": main.get("message")
+    })
+
+# Stream file handler with optimized error handling
 async def stream_handler(request: web.Request):
-  try:
-    path = request.match_info["path"]
-    return await media_streamer(request, path)
-  except InvalidHash as e:
-    raise web.HTTPForbidden(text=e.message)
-  except FIleNotFound as e:
-    raise web.HTTPNotFound(text=e.message)
-  except (AttributeError, BadStatusLine, ConnectionResetError):
-    pass
-  except Exception as e:
-    traceback.print_exc()
-    logging.critical(e.with_traceback(None))
-    logging.debug(traceback.format_exc())
-    raise web.HTTPInternalServerError(text=str(e))
-
+    try:
+        path = request.match_info["path"]
+        return await media_streamer(request, path, "FAST")
+    except InvalidHash as e:
+        raise web.HTTPForbidden(text=e.message)
+    except FIleNotFound as e:
+        raise web.HTTPNotFound(text=e.message)
+    except (AttributeError, BadStatusLine, ConnectionResetError):
+        pass  # Handle expected errors silently
+    except Exception as e:
+        logging.error(f"Error while streaming file: {str(e)}")
+        traceback.print_exc()
+        raise web.HTTPInternalServerError(text=str(e))
 
+# Web server setup with optimized CORS handling
 api = web.Application()
-
-cors = aiohttp_cors.setup(api, defaults={
-    "*": aiohttp_cors.ResourceOptions(
-        allow_credentials=False,
-        expose_headers="*",
-        allow_headers="*",
-        allow_methods="*" #["GET"]  Allowing specific methods
-    )
-})
+cors = aiohttp_cors.setup(api, defaults={"*": aiohttp_cors.ResourceOptions(
+    allow_credentials=False,
+    expose_headers="*",
+    allow_headers="*",
+    allow_methods="*"
+)})
 
 cors.add(api.router.add_get('/', handle_v2))
 api.router.add_get('/files', list_all_files_db)
@@ -234,4 +171,4 @@ api.router.add_get('/tmdb/tv', list_all_tmdb_tv_from_db)
 api.router.add_get('/tmdb/movies', list_all_tmdb_movies_from_db)
 
 api.router.add_get('/upload', upload_file)
-api.router.add_get('/dl/{path}', stream_handler)
+api.router.add_get('/dl/{path}', stream_handler)

FileStream/utils/FileProcessors/custom_dl.py

@@ -1,208 +1,211 @@
 import asyncio
 import logging
 from typing import Dict, Union
-from FileStream.bot import WORK_LOADS
+from pyrogram.types import Message
 from pyrogram import Client, utils, raw
-from .file_properties import get_file_ids
 from pyrogram.session import Session, Auth
 from pyrogram.errors import AuthBytesInvalid
 from pyrogram.file_id import FileId, FileType, ThumbnailSource
-from pyrogram.types import Message
+
+#--------------------Local Imports -------------------------------#
+
+from .file_properties import get_file_ids
+from FileStream.bot import WORK_LOADS
 
 
 class ByteStreamer:
 
-  def __init__(self, client: Client):
-    self.clean_timer = 30 * 60
-    self.client: Client = client
-    self.cached_file_ids: Dict[str, FileId] = {}
-    asyncio.create_task(self.clean_cache())
-
-  async def get_file_properties(self, db_id: str, multi_clients) -> FileId:
-    """
-        Returns the properties of a media of a specific message in a FIleId class.
-        if the properties are cached, then it'll return the cached results.
-        or it'll generate the properties from the Message ID and cache them.
+    def __init__(self, client: Client):
+        self.clean_timer = 30 * 60  # Cache cleanup timer set to 30 minutes
+        self.client: Client = client
+        self.cached_file_ids: Dict[str, FileId] = {}  # Cache to store file properties by db_id
+        asyncio.create_task(self.clean_cache())  # Start the cache cleanup task
+
+    async def get_file_properties(self, db_id: str, MULTI_CLIENTS) -> FileId:
+        """
+        Returns the properties of a media of a specific message in a FileId class.
+        If the properties are cached, it'll return the cached results.
+        Otherwise, it'll generate the properties from the Message ID and cache them.
+        """
+        if db_id not in self.cached_file_ids:
+            logging.debug("File properties not cached. Generating properties.")
+            await self.generate_file_properties(db_id, MULTI_CLIENTS)  # Generate and cache the file properties
+            logging.debug(f"Cached file properties for file with ID {db_id}")
+        return self.cached_file_ids[db_id]
+
+    async def generate_file_properties(self, db_id: str, MULTI_CLIENTS) -> FileId:
         """
-    if not db_id in self.cached_file_ids:
-      logging.debug("Before Calling generate_file_properties")
-      await self.generate_file_properties(db_id, multi_clients)
-      logging.debug(f"Cached file properties for file with ID {db_id}")
-    return self.cached_file_ids[db_id]
-
-  async def generate_file_properties(self, db_id: str,
-                                     multi_clients) -> FileId:
-    """
         Generates the properties of a media file on a specific message.
-        returns ths properties in a FIleId class.
+        Returns the properties in a FileId class.
+        """
+        logging.debug("Generating file properties.")
+        file_id = await get_file_ids(self.client, db_id, Message)  # Call the method to get the file properties
+        logging.debug(f"Generated file ID and Unique ID for file with ID {db_id}")
+        self.cached_file_ids[db_id] = file_id  # Cache the file properties
+        logging.debug(f"Cached media file with ID {db_id}")
+        return file_id
+
+    async def generate_media_session(self, client: Client, file_id: FileId) -> Session:
         """
-    logging.debug("Before calling get_file_ids")
-    file_id = await get_file_ids(self.client, db_id, Message)
-    logging.debug(f"Generated file ID and Unique ID for file with ID {db_id}")
-    self.cached_file_ids[db_id] = file_id
-    logging.debug(f"Cached media file with ID {db_id}")
-    return self.cached_file_ids[db_id]
-
-  async def generate_media_session(self, client: Client,
-                                   file_id: FileId) -> Session:
-    """
         Generates the media session for the DC that contains the media file.
         This is required for getting the bytes from Telegram servers.
         """
-
-    media_session = client.media_sessions.get(file_id.dc_id, None)
-
-    if media_session is None:
-      if file_id.dc_id != await client.storage.dc_id():
-        media_session = Session(
-            client,
-            file_id.dc_id,
-            await Auth(client, file_id.dc_id, await
-                       client.storage.test_mode()).create(),
-            await client.storage.test_mode(),
-            is_media=True,
-        )
-        await media_session.start()
-
-        for _ in range(6):
-          exported_auth = await client.invoke(
-              raw.functions.auth.ExportAuthorization(dc_id=file_id.dc_id))
-
-          try:
-            await media_session.invoke(
-                raw.functions.auth.ImportAuthorization(
-                    id=exported_auth.id, bytes=exported_auth.bytes))
-            break
-          except AuthBytesInvalid:
-            logging.debug(
-                f"Invalid authorization bytes for DC {file_id.dc_id}")
-            continue
+        media_session = client.media_sessions.get(file_id.dc_id, None)
+
+        if media_session is None:
+            if file_id.dc_id != await client.storage.dc_id():
+                # Create a new media session if one doesn't exist for this DC ID
+                media_session = Session(
+                    client,
+                    file_id.dc_id,
+                    await Auth(client, file_id.dc_id, await client.storage.test_mode()).create(),
+                    await client.storage.test_mode(),
+                    is_media=True,
+                )
+                await media_session.start()
+
+                # Attempt to import authorization from Telegram's servers
+                for _ in range(6):
+                    exported_auth = await client.invoke(
+                        raw.functions.auth.ExportAuthorization(dc_id=file_id.dc_id))
+
+                    try:
+                        # Import the authorization bytes for the DC
+                        await media_session.invoke(
+                            raw.functions.auth.ImportAuthorization(
+                                id=exported_auth.id, bytes=exported_auth.bytes))
+                        break
+                    except AuthBytesInvalid:
+                        logging.debug(f"Invalid authorization bytes for DC {file_id.dc_id}")
+                        continue
+                else:
+                    await media_session.stop()
+                    raise AuthBytesInvalid
+            else:
+                # Reuse the stored auth key if we're already connected to the correct DC
+                media_session = Session(
+                    client,
+                    file_id.dc_id,
+                    await client.storage.auth_key(),
+                    await client.storage.test_mode(),
+                    is_media=True,
+                )
+                await media_session.start()
+
+            logging.debug(f"Created media session for DC {file_id.dc_id}")
+            client.media_sessions[file_id.dc_id] = media_session  # Cache the media session
         else:
-          await media_session.stop()
-          raise AuthBytesInvalid
-      else:
-        media_session = Session(
-            client,
-            file_id.dc_id,
-            await client.storage.auth_key(),
-            await client.storage.test_mode(),
-            is_media=True,
-        )
-        await media_session.start()
-      logging.debug(f"Created media session for DC {file_id.dc_id}")
-      client.media_sessions[file_id.dc_id] = media_session
-    else:
-      logging.debug(f"Using cached media session for DC {file_id.dc_id}")
-    return media_session
-
-  @staticmethod
-  async def get_location(
-      file_id: FileId
-  ) -> Union[
-      raw.types.InputPhotoFileLocation,
-      raw.types.InputDocumentFileLocation,
-      raw.types.InputPeerPhotoFileLocation,
-  ]:
-    """
-        Returns the file location for the media file.
+            logging.debug(f"Using cached media session for DC {file_id.dc_id}")
+        return media_session
+
+    @staticmethod
+    async def get_location(file_id: FileId) -> Union[
+            raw.types.InputPhotoFileLocation,
+            raw.types.InputDocumentFileLocation,
+            raw.types.InputPeerPhotoFileLocation,
+    ]:
+        """
+        Returns the file location for the media file based on its type (Photo or Document).
         """
-    file_type = file_id.file_type
-
-    if file_type == FileType.CHAT_PHOTO:
-      if file_id.chat_id > 0:
-        peer = raw.types.InputPeerUser(user_id=file_id.chat_id,
-                                       access_hash=file_id.chat_access_hash)
-      else:
-        if file_id.chat_access_hash == 0:
-          peer = raw.types.InputPeerChat(chat_id=-file_id.chat_id)
+        file_type = file_id.file_type
+
+        if file_type == FileType.CHAT_PHOTO:
+            # Handle the case for chat photos
+            if file_id.chat_id > 0:
+                peer = raw.types.InputPeerUser(user_id=file_id.chat_id, access_hash=file_id.chat_access_hash)
+            else:
+                peer = raw.types.InputPeerChannel(
+                    channel_id=utils.get_channel_id(file_id.chat_id),
+                    access_hash=file_id.chat_access_hash,
+                )
+
+            location = raw.types.InputPeerPhotoFileLocation(
+                peer=peer,
+                volume_id=file_id.volume_id,
+                local_id=file_id.local_id,
+                big=file_id.thumbnail_source == ThumbnailSource.CHAT_PHOTO_BIG,
+            )
+        elif file_type == FileType.PHOTO:
+            # Handle regular photos
+            location = raw.types.InputPhotoFileLocation(
+                id=file_id.media_id,
+                access_hash=file_id.access_hash,
+                file_reference=file_id.file_reference,
+                thumb_size=file_id.thumbnail_size,
+            )
         else:
-          peer = raw.types.InputPeerChannel(
-              channel_id=utils.get_channel_id(file_id.chat_id),
-              access_hash=file_id.chat_access_hash,
-          )
-
-      location = raw.types.InputPeerPhotoFileLocation(
-          peer=peer,
-          volume_id=file_id.volume_id,
-          local_id=file_id.local_id,
-          big=file_id.thumbnail_source == ThumbnailSource.CHAT_PHOTO_BIG,
-      )
-    elif file_type == FileType.PHOTO:
-      location = raw.types.InputPhotoFileLocation(
-          id=file_id.media_id,
-          access_hash=file_id.access_hash,
-          file_reference=file_id.file_reference,
-          thumb_size=file_id.thumbnail_size,
-      )
-    else:
-      location = raw.types.InputDocumentFileLocation(
-          id=file_id.media_id,
-          access_hash=file_id.access_hash,
-          file_reference=file_id.file_reference,
-          thumb_size=file_id.thumbnail_size,
-      )
-    return location
-
-  async def yield_file(
-      self,
-      file_id: FileId,
-      index: int,
-      offset: int,
-      first_part_cut: int,
-      last_part_cut: int,
-      part_count: int,
-      chunk_size: int,
-  ) -> Union[str, None]:
-
-    client = self.client
-    WORK_LOADS[index] += 1
-    logging.debug(f"Starting to yielding file with client {index}.")
-    media_session = await self.generate_media_session(client, file_id)
-
-    current_part = 1
-
-    location = await self.get_location(file_id)
-
-    try:
-      r = await media_session.invoke(
-          raw.functions.upload.GetFile(location=location,
-                                       offset=offset,
-                                       limit=chunk_size), )
-      if isinstance(r, raw.types.upload.File):
-        while True:
-          chunk = r.bytes
-          if not chunk:
-            break
-          elif part_count == 1:
-            yield chunk[first_part_cut:last_part_cut]
-          elif current_part == 1:
-            yield chunk[first_part_cut:]
-          elif current_part == part_count:
-            yield chunk[:last_part_cut]
-          else:
-            yield chunk
-
-          current_part += 1
-          offset += chunk_size
-
-          if current_part > part_count:
-            break
-
-          r = await media_session.invoke(
-              raw.functions.upload.GetFile(location=location,
-                                           offset=offset,
-                                           limit=chunk_size), )
-    except (TimeoutError, AttributeError):
-      pass
-    finally:
-      logging.debug(f"Finished yielding file with {current_part} parts.")
-      WORK_LOADS[index] -= 1
-
-  async def clean_cache(self) -> None:
-    """
-        function to clean the cache to reduce memory usage
+            # Handle document files
+            location = raw.types.InputDocumentFileLocation(
+                id=file_id.media_id,
+                access_hash=file_id.access_hash,
+                file_reference=file_id.file_reference,
+                thumb_size=file_id.thumbnail_size,
+            )
+        return location
+
+    async def yield_file(
+            self,
+            file_id: FileId,
+            index: int,
+            offset: int,
+            first_part_cut: int,
+            last_part_cut: int,
+            part_count: int,
+            chunk_size: int,
+    ) -> Union[str, None]:
+        """
+        Yields the file in chunks based on the specified range and chunk size.
+        This method streams the file from Telegram's server, breaking it into smaller parts.
+        """
+        client = self.client
+        WORK_LOADS[index] += 1  # Increase the workload for this client
+        logging.debug(f"Starting to yield file with client {index}.")
+        media_session = await self.generate_media_session(client, file_id)
+
+        current_part = 1
+        location = await self.get_location(file_id)
+
+        try:
+            # Fetch the file chunks
+            r = await media_session.invoke(
+                raw.functions.upload.GetFile(location=location, offset=offset, limit=chunk_size), )
+
+            if isinstance(r, raw.types.upload.File):
+                # Stream the file in chunks
+                while True:
+                    chunk = r.bytes
+                    if not chunk:
+                        break
+                    elif part_count == 1:
+                        yield chunk[first_part_cut:last_part_cut]
+                    elif current_part == 1:
+                        yield chunk[first_part_cut:]
+                    elif current_part == part_count:
+                        yield chunk[:last_part_cut]
+                    else:
+                        yield chunk
+
+                    current_part += 1
+                    offset += chunk_size
+
+                    if current_part > part_count:
+                        break
+
+                    r = await media_session.invoke(
+                        raw.functions.upload.GetFile(location=location, offset=offset, limit=chunk_size), )
+        except (TimeoutError, AttributeError):
+            pass
+        finally:
+            logging.debug(f"Finished yielding file with {current_part} parts.")
+            WORK_LOADS[index] -= 1  # Decrease the workload for this client
+
+    async def clean_cache(self) -> None:
         """
-    while True:
-      await asyncio.sleep(self.clean_timer)
-      self.cached_file_ids.clear()
-      logging.debug("Cleaned the cache")
+        Function to clean the cache to reduce memory usage.
+        This method will be called periodically to clear the cached file properties.
+        """
+        while True:
+            await asyncio.sleep(self.clean_timer)  # Wait for the cleanup interval
+            logging.debug("Cleaning cached file properties...")
+            self.cached_file_ids.clear()  # Clear the cache
+            logging.debug("Cache cleaned.")

FileStream/utils/FileProcessors/custom_mix.py

@@ -71,6 +71,7 @@ class TGFileController:
     """
     while True:
       await asyncio.sleep(self.clean_timer)
+      print("** Caches Cleared :", self.cached_file_ids)
       self.cached_file_ids.clear()
       print("Cleaned the cache")
       logging.debug("Cleaned the cache")

FileStream/utils/FileProcessors/custom_ul.py

@@ -37,10 +37,11 @@ class TeleUploader:
     #print("\n* Client :", client, "\n")
   async def clean_cache(self) -> None:
     """
-        function to clean the cache to reduce memory usage
-        """
+    function to clean the cache to reduce memory usage
+    """
     while True:
       await asyncio.sleep(self.clean_timer)
+      print("** Caches Cleared :", self.cached_file_ids)
       self.cached_file_ids.clear()
       print("Cleaned the cache")
       logging.debug("Cleaned the cache")

Unused Codes/__main__old.py

@@ -1,3 +1,5 @@
+#Filestream/__main__.py
+
 import sys
 import asyncio
 import logging

Unused Codes/custom_dl_old.py

@@ -0,0 +1,211 @@
+#FileStream/utils/FileProcessors/custom_dl.py
+
+import asyncio
+import logging
+from typing import Dict, Union
+from FileStream.bot import WORK_LOADS
+from pyrogram import Client, utils, raw
+from .file_properties import get_file_ids
+from pyrogram.session import Session, Auth
+from pyrogram.errors import AuthBytesInvalid
+from pyrogram.file_id import FileId, FileType, ThumbnailSource
+from pyrogram.types import Message
+
+
+class ByteStreamer:
+
+  def __init__(self, client: Client):
+    self.clean_timer = 30 * 60
+    self.client: Client = client
+    self.cached_file_ids: Dict[str, FileId] = {}
+    asyncio.create_task(self.clean_cache())
+
+  async def get_file_properties(self, db_id: str, MULTI_CLIENTS) -> FileId:
+    """
+        Returns the properties of a media of a specific message in a FIleId class.
+        if the properties are cached, then it'll return the cached results.
+        or it'll generate the properties from the Message ID and cache them.
+        """
+    if not db_id in self.cached_file_ids:
+      logging.debug("Before Calling generate_file_properties")
+      await self.generate_file_properties(db_id, MULTI_CLIENTS)
+      logging.debug(f"Cached file properties for file with ID {db_id}")
+    return self.cached_file_ids[db_id]
+
+  async def generate_file_properties(self, db_id: str,
+                                     MULTI_CLIENTS) -> FileId:
+    """
+        Generates the properties of a media file on a specific message.
+        returns ths properties in a FIleId class.
+        """
+    logging.debug("Before calling get_file_ids")
+    file_id = await get_file_ids(self.client, db_id, Message)
+    logging.debug(f"Generated file ID and Unique ID for file with ID {db_id}")
+    self.cached_file_ids[db_id] = file_id
+    logging.debug(f"Cached media file with ID {db_id}")
+    return self.cached_file_ids[db_id]
+
+  async def generate_media_session(self, client: Client,
+                                   file_id: FileId) -> Session:
+    """
+        Generates the media session for the DC that contains the media file.
+        This is required for getting the bytes from Telegram servers.
+        """
+
+    media_session = client.media_sessions.get(file_id.dc_id, None)
+
+    if media_session is None:
+      if file_id.dc_id != await client.storage.dc_id():
+        media_session = Session(
+            client,
+            file_id.dc_id,
+            await Auth(client, file_id.dc_id, await
+                       client.storage.test_mode()).create(),
+            await client.storage.test_mode(),
+            is_media=True,
+        )
+        await media_session.start()
+
+        for _ in range(6):
+          exported_auth = await client.invoke(
+              raw.functions.auth.ExportAuthorization(dc_id=file_id.dc_id))
+
+          try:
+            await media_session.invoke(
+                raw.functions.auth.ImportAuthorization(
+                    id=exported_auth.id, bytes=exported_auth.bytes))
+            break
+          except AuthBytesInvalid:
+            logging.debug(
+                f"Invalid authorization bytes for DC {file_id.dc_id}")
+            continue
+        else:
+          await media_session.stop()
+          raise AuthBytesInvalid
+      else:
+        media_session = Session(
+            client,
+            file_id.dc_id,
+            await client.storage.auth_key(),
+            await client.storage.test_mode(),
+            is_media=True,
+        )
+        await media_session.start()
+      logging.debug(f"Created media session for DC {file_id.dc_id}")
+      client.media_sessions[file_id.dc_id] = media_session
+    else:
+      logging.debug(f"Using cached media session for DC {file_id.dc_id}")
+    return media_session
+
+  @staticmethod
+  async def get_location(
+      file_id: FileId
+  ) -> Union[
+      raw.types.InputPhotoFileLocation,
+      raw.types.InputDocumentFileLocation,
+      raw.types.InputPeerPhotoFileLocation,
+  ]:
+    """
+        Returns the file location for the media file.
+        """
+    file_type = file_id.file_type
+
+    if file_type == FileType.CHAT_PHOTO:
+      if file_id.chat_id > 0:
+        peer = raw.types.InputPeerUser(user_id=file_id.chat_id,
+                                       access_hash=file_id.chat_access_hash)
+      else:
+        if file_id.chat_access_hash == 0:
+          peer = raw.types.InputPeerChat(chat_id=-file_id.chat_id)
+        else:
+          peer = raw.types.InputPeerChannel(
+              channel_id=utils.get_channel_id(file_id.chat_id),
+              access_hash=file_id.chat_access_hash,
+          )
+
+      location = raw.types.InputPeerPhotoFileLocation(
+          peer=peer,
+          volume_id=file_id.volume_id,
+          local_id=file_id.local_id,
+          big=file_id.thumbnail_source == ThumbnailSource.CHAT_PHOTO_BIG,
+      )
+    elif file_type == FileType.PHOTO:
+      location = raw.types.InputPhotoFileLocation(
+          id=file_id.media_id,
+          access_hash=file_id.access_hash,
+          file_reference=file_id.file_reference,
+          thumb_size=file_id.thumbnail_size,
+      )
+    else:
+      location = raw.types.InputDocumentFileLocation(
+          id=file_id.media_id,
+          access_hash=file_id.access_hash,
+          file_reference=file_id.file_reference,
+          thumb_size=file_id.thumbnail_size,
+      )
+    return location
+
+  async def yield_file(
+      self,
+      file_id: FileId,
+      index: int,
+      offset: int,
+      first_part_cut: int,
+      last_part_cut: int,
+      part_count: int,
+      chunk_size: int,
+  ) -> Union[str, None]:
+
+    client = self.client
+    WORK_LOADS[index] += 1
+    logging.debug(f"Starting to yielding file with client {index}.")
+    media_session = await self.generate_media_session(client, file_id)
+
+    current_part = 1
+
+    location = await self.get_location(file_id)
+
+    try:
+      r = await media_session.invoke(
+          raw.functions.upload.GetFile(location=location,
+                                       offset=offset,
+                                       limit=chunk_size), )
+      if isinstance(r, raw.types.upload.File):
+        while True:
+          chunk = r.bytes
+          if not chunk:
+            break
+          elif part_count == 1:
+            yield chunk[first_part_cut:last_part_cut]
+          elif current_part == 1:
+            yield chunk[first_part_cut:]
+          elif current_part == part_count:
+            yield chunk[:last_part_cut]
+          else:
+            yield chunk
+
+          current_part += 1
+          offset += chunk_size
+
+          if current_part > part_count:
+            break
+
+          r = await media_session.invoke(
+              raw.functions.upload.GetFile(location=location,
+                                           offset=offset,
+                                           limit=chunk_size), )
+    except (TimeoutError, AttributeError):
+      pass
+    finally:
+      logging.debug(f"Finished yielding file with {current_part} parts.")
+      WORK_LOADS[index] -= 1
+
+  async def clean_cache(self) -> None:
+    """
+        function to clean the cache to reduce memory usage
+        """
+    while True:
+      await asyncio.sleep(self.clean_timer)
+      print("** Caches Cleared :", self.cached_file_ids)
+      self.cached_file_ids.clear()
+      logging.debug("Cleaned the cache")

Unused Codes/downloader_old.py

@@ -0,0 +1,100 @@
+#Filestream/server/Functions/Downloader
+import os
+import time
+import math
+import logging
+import asyncio
+import traceback
+from aiohttp import web
+from pyrogram import raw
+
+from aiohttp.http_exceptions import BadStatusLine
+
+#---------------------Local Upload---------------------#
+
+from FileStream.config import Telegram
+from FileStream import utils, StartTime, __version__
+from FileStream.Tools import mime_identifier, Time_ISTKolNow
+from FileStream.bot import req_client, FileStream
+from FileStream.bot import MULTI_CLIENTS, WORK_LOADS, ACTIVE_CLIENTS
+from FileStream.server.exceptions import FIleNotFound, InvalidHash
+from FileStream.server.render_template import render_page, render_upload
+from FileStream.utils.FileProcessors.custom_ul import  TeleUploader
+
+
+async def media_streamer(request: web.Request, db_id: str, speed:str):
+
+  range_header = request.headers.get("Range", 0)
+  #index = minWORK_LOADS, keyWORK_LOADS.get)
+  #faster_client = MULTI_CLIENTS[index]
+
+  client = await req_client()
+
+  if Telegram.MULTI_CLIENT:
+    logging.info(f"Client {client['index']} is now serving {request.headers.get('X-FORWARDED-FOR',request.remote)}")
+
+  if client['client'] in ACTIVE_CLIENTS:
+    tg_connect = ACTIVE_CLIENTS[client['client']]
+    logging.debug(f"Using cached ByteStreamer object for client {client['index']}")
+
+  else:
+    logging.debug(f"Creating new ByteStreamer object for client {client['index']}")
+    tg_connect = utils.ByteStreamer(client['client'])
+    ACTIVE_CLIENTS[client['client']] = tg_connect
+
+  logging.debug("before calling get_file_properties")
+  file_id = await tg_connect.get_file_properties(db_id, MULTI_CLIENTS)
+  logging.debug("after calling get_file_properties")
+
+  file_size = file_id.file_size
+
+  if range_header:
+    from_bytes, until_bytes = range_header.replace("bytes=", "").split("-")
+    from_bytes = int(from_bytes)
+    until_bytes = int(until_bytes) if until_bytes else file_size - 1
+  else:
+    from_bytes = request.http_range.start or 0
+    until_bytes = (request.http_range.stop or file_size) - 1
+
+  if (until_bytes > file_size) or (from_bytes < 0) or (until_bytes < from_bytes):
+
+    return web.Response(
+      status=416,
+      body="416: Range not satisfiable",
+      headers={"Content-Range": f"bytes */{file_size}"},
+    )
+
+  chunk_size = 4 * 1024 * 1024 if speed == "FAST" else 512 * 1024
+
+  until_bytes = min(until_bytes, file_size - 1)
+
+  offset = from_bytes - (from_bytes % chunk_size)
+  first_part_cut = from_bytes - offset
+  last_part_cut = until_bytes % chunk_size + 1
+
+  req_length = until_bytes - from_bytes + 1
+  part_count = math.ceil(until_bytes / chunk_size) - math.floor(offset / chunk_size)
+
+  body = tg_connect.yield_file(file_id, client['index'], offset, first_part_cut,last_part_cut, part_count, chunk_size)
+
+  mime_type = file_id.mime_type
+  file_name = utils.get_name(file_id)
+  disposition = "attachment"
+
+  if not mime_type:
+    mime_type = mimetypes.guess_type(file_name)[0] or "application/octet-stream"
+
+  # if "video/" in mime_type or "audio/" in mime_type:
+  #     disposition = "inline"
+
+  return web.Response(
+    status=206 if range_header else 200,
+    body=body,
+    headers={
+      "Content-Type": f"{mime_type}",
+      "Content-Range": f"bytes {from_bytes}-{until_bytes}/{file_size}",
+      "Content-Length": str(req_length),
+      "Content-Disposition": f'{disposition}; filename="{file_name}"',
+      "Accept-Ranges": "bytes",
+    },
+  )

Unused Codes/routes_api_old.py

@@ -0,0 +1,240 @@
+#FileStream/server/routes_api
+
+import os
+
+import json
+import time
+import math
+import logging
+import asyncio
+import traceback
+import aiohttp_cors
+from aiohttp import web
+from pyrogram import raw
+from bson import ObjectId
+from bson.json_util import dumps
+from aiohttp.http_exceptions import BadStatusLine
+
+#---------------------Local Imports----------------------------------#
+from FileStream.bot import req_client
+from FileStream.config import Telegram,Server
+from FileStream.Database import Database
+from FileStream.TMDB.Endpoint import search_tmdb_any,search_tmdb_tv,search_tmdb_movies
+from FileStream.server.exceptions import FIleNotFound, InvalidHash
+
+from .Functions.downloader import media_streamer
+
+CORS_HEADERS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Headers": "*"
+}
+
+async def handle_v2(request):
+    return web.Response(text="Hello from app api!")
+
+#api.router.add_get('/10/files', list_10_all_files_db)
+async def list_10_all_files_db(request):
+  #file_range = [file_list_no * 10 - 10 + 1, file_list_no * 10]
+  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+  files, total_files = await db.find_all_files([1, 10])
+  print(files)
+  return web.json_response([ dict(file) async for file in files], headers=CORS_HEADERS)
+
+  #return file_list, total_files
+
+
+#api.router.add_get('/files', list_all_files_db)
+async def list_all_files_db(request):
+  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+  files= await db.get_all_files_api()
+  #print(files, type(files))
+  return web.json_response(json.loads(dumps(files)), headers=CORS_HEADERS)
+
+#api.router.add_get('/tmdb/mix', list_all_files_tmdb)
+async def list_all_tmdb_movies_from_db(request):
+  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+  files= await db.get_all_files()
+  #print(files)
+  response=[]
+  async for row in files:
+    #print(row['file']['caption'])
+    try :
+      #print("* Response",search_tmdb(row['file']['caption'] if row['file']['caption'] else row['file']['file_name']))
+      resp = search_tmdb_movies( str(row['file']['caption']) if str(row['file']['caption']) else str(row['file']['file_name']))
+      if resp != None :
+        #resp= dict(resp)
+        #print("TMDB Response :",resp)
+        response.append(resp)
+      else:
+        print("\n * Skipped:",row['file']['caption'],str(row['file']['file_name']))
+        continue
+    except Exception as e:
+      print("Error ",e)
+      break
+  return web.json_response(json.loads(dumps(response)),headers=CORS_HEADERS)
+
+
+#api.router.add_get('/tmdb/tv', list_all_tmdb_tv_from_db)
+async def list_all_tmdb_tv_from_db(request):
+  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+  files= await db.get_all_files()
+  #print(files)
+  response=[]
+  async for row in files:
+    #print(row['file']['caption'])
+    try :
+      #print("* Response",search_tmdb(row['file']['caption'] if row['file']['caption'] else row['file']['file_name']))
+      resp = search_tmdb_tv( str(row['file']['caption']) if str(row['file']['caption']) else str(row['file']['file_name']))
+      if resp != None :
+        #resp= dict(resp)
+        #print("TMDB Response :",resp)
+        response.append(resp)
+      else:
+        print("\n * Skipped:",row['file']['caption'],str(row['file']['file_name']))
+        continue
+    except Exception as e:
+      print("Error ",e)
+      break
+  return web.json_response(json.loads(dumps(response)), headers=CORS_HEADERS)
+
+#api.router.add_get('/tmdb/list', list_all_files_tmdb)
+async def list_all_files_tmdb(request):
+  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+  files= await db.get_all_files()
+  async def data_generator():
+    async for row in files:
+      #print(row['file']['caption'])
+      try :
+        #print("* Response",search_tmdb(row['file']['caption'] if row['file']['caption'] else row['file']['file_name']))
+        resp = search_tmdb_any( str(row['file']['caption']) if str(row['file']['caption']) else str(row['file']['file_name']))
+        if resp != None :
+          #resp= dict(resp)
+          #print("TMDB Response :",resp)
+          #response.append(resp)
+          yield json.dumps(resp) +  + '\n'
+
+        else:
+          print("\n * Skipped:",row['file']['caption'],str(row['file']['file_name']))
+          continue
+
+      except Exception as e:
+        print("Error ",e)
+        break
+              
+  return web.Response(body=data_generator(), content_type='application/json', headers=CORS_HEADERS)
+
+#api.router.add_get('/tmdb/files', list_all_files)
+async def list_all_files(request):
+  db = Database(Telegram.DATABASE_URL, Telegram.SESSION_NAME)
+  files=await db.get_all_files_api()
+  resp=[{
+    "adult": False,
+    "backdrop_path": "/c1bz69r0v065TGFA5nqBiKzPDys.jpg",
+    "genre_ids": [
+      35,
+      10751,
+      10402
+    ],
+    "id": f"{row['_id']}",
+    "original_language": "en-hi",
+    "original_title": f"{str(row['file']['caption'])}",
+    "overview": "XRepo Movies",
+    "popularity": 1710.176,
+    "poster_path": "/irIS5Tn3TXjNi1R9BpWvGAN4CZ1.jpg",
+    "release_date": "2022-10-07",
+    "title": f"{str(row['file']['caption'])}",
+    "link": f"{Server.URL}api/dl/{row['_id']}",
+    "vote_average": 7.8,
+    "vote_count": 122,
+    } 
+     for row in files]
+  return web.json_response(json.loads(dumps(resp)), headers=CORS_HEADERS)
+
+#----------------------------------------Upload----------------------------------------------#
+#@routes.post("/upload")
+async def upload_file(request: web.Request):
+
+  data = await request.post()
+  file = data.get('file').file
+  chunk = file.read()
+  """
+  user_id :
+  file_id :"BAACAgUAAxkBAAJBHGYI_aJSvyL_ijKwrVHQVzFgC1YZAAItDQACOnNAVMIpWwl6b63EHg…"
+  file_unique_id :"AgADLQ0AAjpzQFQ"
+  file_name :"Dadur_Kirti_S01_COMBINED_720p_HOICHOI_WEB_DL_Bengali@COOL_MOVIES.mp4"
+  file_size : 1354816011
+  mime_type : "video/mp4"
+  time : 1711865251.1016757
+  user_type: "TELEGRAM"/"WEB"
+  privacy_type: "PUBLIC"/"PRIVATE"
+  file_ids :
+  """
+  file_details = dict(user_id="thebinary1",
+                      dropzone_id=str(data["dzuuid"]),
+                      file=dict(file_id=str(data["dzuuid"]),
+                      file_unique_id=str(data["dzuuid"]),
+                      file_name=str(data.get('file').filename),
+                      file_size=int(data["dztotalfilesize"]),
+                      mime_type=mime_identifier(str(data.get('file').filename)),
+                      part_size=int(data["dzchunksize"]),
+                      file_part=int(data["dzchunkindex"]),
+                      total_parts=int(data["dztotalchunkcount"])),
+                      time=Time_ISTKolNow(),
+                      user_type="WEB",
+                      privacy_type="PRIVATE")
+
+  print(file_details) if (file_details["file"]["file_part"] == 0) else None
+  client_req = await req_client()
+  #faster_client = client_req["client"]
+  #index = client_req["index"]
+  print("using :", client_req["index"])
+  tg_connect = TeleUploader(client_req["client"])
+  main = await tg_connect.upload_web_file(file_details, chunk)
+  #print("Response:", main)
+  return web.json_response({
+      "status": main.get("status"),
+      "message": main.get("message")
+  })
+
+
+#-------------Routes to Downloada File Witha Path-----------------#
+
+#@routes.get("/dl/{path}", allow_head=True)
+async def stream_handler(request: web.Request):
+  try:
+    path = request.match_info["path"]
+    return await media_streamer(request, path, "FAST")
+  except InvalidHash as e:
+    raise web.HTTPForbidden(text=e.message)
+  except FIleNotFound as e:
+    raise web.HTTPNotFound(text=e.message)
+  except (AttributeError, BadStatusLine, ConnectionResetError):
+    pass
+  except Exception as e:
+    traceback.print_exc()
+    logging.critical(e.with_traceback(None))
+    logging.debug(traceback.format_exc())
+    raise web.HTTPInternalServerError(text=str(e))
+
+
+api = web.Application()
+
+cors = aiohttp_cors.setup(api, defaults={
+    "*": aiohttp_cors.ResourceOptions(
+        allow_credentials=False,
+        expose_headers="*",
+        allow_headers="*",
+        allow_methods="*" #["GET"]  Allowing specific methods
+    )
+})
+
+cors.add(api.router.add_get('/', handle_v2))
+api.router.add_get('/files', list_all_files_db)
+api.router.add_get('/files/mix', list_all_files)
+api.router.add_get('/tmdb/mix', list_all_files_tmdb)
+api.router.add_get('/10/files', list_10_all_files_db)
+api.router.add_get('/tmdb/tv', list_all_tmdb_tv_from_db)
+api.router.add_get('/tmdb/movies', list_all_tmdb_movies_from_db)
+
+api.router.add_get('/upload', upload_file)
+api.router.add_get('/dl/{path}', stream_handler)