Slight Edit

FileStream/Exceptions/__init__.py

@@ -1,2 +1 @@
-
 from .exceptions import FIleNotFound, InvalidHash

FileStream/server/API/__init__.py

@@ -2,14 +2,14 @@ import aiohttp_cors
 from aiohttp import web
 
 #---------------------- Local Imports --------------------#
-from .listings import (
-    list_all_files_db,
-    list_all_files,
-    list_all_files_tmdb,
-    list_10_all_files_db,
-    list_all_tmdb_tv_from_db,
-    list_all_tmdb_movies_from_db,
-)
+#from .listings import (
+#    list_all_files_db,
+#    list_all_files,
+#    list_all_files_tmdb,
+#    list_10_all_files_db,
+#    list_all_tmdb_tv_from_db,
+#    list_all_tmdb_movies_from_db,
+#)
 from .downloads import stream_handler
 from .uploads import upload_file
 
@@ -37,12 +37,12 @@ cors = aiohttp_cors.setup(api, defaults={"*": aiohttp_cors.ResourceOptions(
 
 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('/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)

FileStream/server/Functions/downloader copy.py

@@ -0,0 +1,121 @@
+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.bot import req_client, FileStream
+from FileStream import utils, StartTime, __version__
+from FileStream.Tools import mime_identifier, Time_ISTKolNow
+from FileStream.bot import MULTI_CLIENTS, WORK_LOADS, ACTIVE_CLIENTS
+from FileStream.Exceptions import FIleNotFound, InvalidHash
+from FileStream.utils.FileProcessors.custom_ul import  TeleUploader
+
+
+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", 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:
+        tg_connect.update_last_activity()
+        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 (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}"},
+            )
+
+        # Set chunk size based on speed
+        chunk_size =  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 = 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:
+        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 =  0
+            until_bytes =  file_size - 1
+            #request :web.Request ,
+            #from_bytes = request.http_range.start or 0
+            #until_bytes = (request.http_range.stop or 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/Functions/downloader.py

@@ -22,23 +22,22 @@ from FileStream.utils.FileProcessors.custom_ul import  TeleUploader
 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", 0)
-    client = await req_client()
+
+    index = min(WORK_LOADS, key=WORK_LOADS.get)
+    faster_client = MULTI_CLIENTS[index]
     # 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
+    if Telegram.MULTI_CLIENT:
+        logging.info(f"Client {index} is now serving {request.headers.get('X-FORWARDED-FOR', request.remote)}")
 
+    if faster_client in ACTIVE_CLIENTS:
+        tg_connect = ACTIVE_CLIENTS[faster_client]
+        logging.debug(f"Using cached ByteStreamer object for client {index}")
     else:
-        tg_connect.update_last_activity()
-        logging.debug(f"Using cached ByteStreamer object for client {client['index']}")
-
+        logging.debug(f"Creating new ByteStreamer object forclient {index}")
+        tg_connect = utils.ByteStreamer(faster_client)
+        ACTIVE_CLIENTS[faster_client] = tg_connect
     try:
         # Fetch file properties once and use it throughout
         logging.debug("Fetching file properties")
@@ -68,7 +67,7 @@ async def media_streamer(request: web.Request, db_id: str, speed: str):
 
         # Request the file chunks
         body = tg_connect.yield_file(
-            file_id, client['index'], offset, first_part_cut, last_part_cut, part_count, chunk_size
+            file_id, index, offset, first_part_cut, last_part_cut, part_count, chunk_size
         )
 
         # Determine MIME type and filename
@@ -108,6 +107,7 @@ def parse_range(range_header: str, file_size: int):
             #from_bytes = request.http_range.start or 0
             #until_bytes = (request.http_range.stop or file_size) - 1
         return from_bytes, until_bytes
+
     except ValueError:
         return None, None
 

FileStream/server/Middlewares/__init__.py

@@ -1,7 +0,0 @@
-from .app_token_middleware import app_token_middleware
-from .jwt_middleware import jwt_middleware,create_jwt
-from .logging_middleware import logging_middleware
-
-#from .rate_limit_middleware import rate_limit_middleware
-
-from .security_headers_middleware import security_headers_middleware

FileStream/server/Middlewares/app_token_middleware.py

@@ -1,12 +0,0 @@
-from aiohttp import web
-
-DEFAULT_APP_TOKEN = "supersecureapptoken"
-
-@web.middleware
-async def app_token_middleware(request, handler):
-    """Middleware to enforce token authentication for /app."""
-    if request.path.startswith("/app"):
-        token = request.headers.get("App-Token")
-        if token != DEFAULT_APP_TOKEN:
-            raise web.HTTPUnauthorized(reason="Invalid or missing App-Token")
-    return await handler(request)

FileStream/server/Middlewares/jwt_middleware.py

@@ -1,26 +0,0 @@
-import jwt
-from aiohttp import web
-
-SECRET_KEY = "your_secret_key"  # Use a strong, randomly generated secret key
-
-def create_jwt(user_id: str):
-    """Create a JWT token."""
-    payload = {"sub": user_id, "role": "api_user"}
-    return jwt.encode(payload, SECRET_KEY, algorithm="HS256")
-
-@web.middleware
-async def jwt_middleware(request, handler):
-    """JWT Middleware for /api endpoints."""
-    if request.path.startswith("/api"):
-        token = request.headers.get("Authorization")
-        if not token or not token.startswith("Bearer "):
-            raise web.HTTPUnauthorized(reason="Authorization header missing or malformed")
-        token = token.split("Bearer ")[1]
-        try:
-            decoded = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
-            request["user"] = decoded  # Attach user info to the request
-        except jwt.ExpiredSignatureError:
-            raise web.HTTPUnauthorized(reason="Token has expired")
-        except jwt.InvalidTokenError:
-            raise web.HTTPUnauthorized(reason="Invalid token")
-    return await handler(request)

FileStream/server/Middlewares/logging_middleware.py

@@ -1,8 +0,0 @@
-import logging
-from aiohttp import web
-
-@web.middleware
-async def logging_middleware(request, handler):
-    """Log each request."""
-    logging.info(f"Incoming request: {request.method} {request.path}")
-    return await handler(request)

FileStream/server/Middlewares/rate_limit_middleware.py

@@ -1,10 +0,0 @@
-"""
-from aiohttp_rate_limiter import RateLimiter
-
-rate_limiter = RateLimiter(per_minute=60)
-
-@rate_limiter.limit("60/minute")
-async def rate_limit_middleware(request, handler):
-    Rate limiter middleware.
-    return await handler(request)
-"""

FileStream/server/Middlewares/security_headers_middleware.py

@@ -1,14 +0,0 @@
-from aiohttp import web
-
-@web.middleware
-async def security_headers_middleware(request, handler):
-    """Add security headers."""
-    response = await handler(request)
-    response.headers.update({
-        "Content-Security-Policy": "default-src 'self'",
-        "X-Content-Type-Options": "nosniff",
-        "X-Frame-Options": "DENY",
-        "Referrer-Policy": "no-referrer",
-        "Strict-Transport-Security": "max-age=31536000; includeSubDomains"
-    })
-    return response

FileStream/server/__init__.py

@@ -9,29 +9,6 @@ from .Authentication import auth
 from .routes_main import routes
 from FileStream.bot import MULTI_CLIENTS, WORK_LOADS, ACTIVE_CLIENTS
 
-"""
-from .Middlewares.jwt_middleware import jwt_middleware
-from .Middlewares.app_token_middleware import app_token_middleware
-from .Middlewares.logging_middleware import logging_middleware
-#from .Middlewares.rate_limit_middleware import rate_limit_middleware
-"""
-# Set time to consider a client inactive (e.g., 10 minutes)
-INACTIVITY_TIMEOUT = 180  # 3 minutes
-
-async def clear_inactive_clients():
-    """Clear inactive clients from ACTIVE_CLIENTS."""
-    await asyncio.sleep(INACTIVITY_TIMEOUT)  # Check every INACTIVITY_TIMEOUT seconds
-    now = asyncio.get_event_loop().time()  # Get current time 
-    inactive_clients = [
-        client_id for client_id, tg_connect in ACTIVE_CLIENTS.items()
-        if now - tg_connect.last_activity > INACTIVITY_TIMEOUT  # Compare with last_activity timestamp
-    ]
-    for client in inactive_clients:
-        # Log and clear the inactive client
-        logging.info(f"** Clearing inactive client: {client.name}")
-        del ACTIVE_CLIENTS[client]  # Remove inactive client from ACTIVE_CLIENTS
-
-
 async def root_route_handler(request):
     return web.json_response({"status": "alive", "message": "Server is running","active_clients":[{"client_name": tg_connect.client.name} for client_id, tg_connect in ACTIVE_CLIENTS.items()],"public_ip":request.remote})
 

Unused Codes/downloader_old.py

@@ -25,22 +25,22 @@ 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]
+  index = min(WORK_LOADS, key=WORK_LOADS.get)
+  faster_client = MULTI_CLIENTS[index]
 
-  client = await req_client()
+  #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']]
+  if faster_client in ACTIVE_CLIENTS:
+    tg_connect = ACTIVE_CLIENTS[faster_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
+    tg_connect = utils.ByteStreamer(faster_client)
+    ACTIVE_CLIENTS[faster_client] = tg_connect
 
   logging.debug("before calling get_file_properties")
   file_id = await tg_connect.get_file_properties(db_id, MULTI_CLIENTS)
@@ -75,7 +75,7 @@ async def media_streamer(request: web.Request, db_id: str, speed:str):
   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)
+  body = tg_connect.yield_file(file_id, 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)