Code Updates

FileStream/__main__.py

@@ -12,18 +12,14 @@ from FileStream.Tools import Time_ISTKolNow
 from FileStream.server import web_server
 from FileStream.bot.clients import initialize_clients
 
+# Configure logging
 logging.basicConfig(
     level=logging.INFO,
     datefmt="%d/%m/%Y %H:%M:%S",
-    format=
-    '[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s',
+    format='[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s',
     handlers=[
         logging.StreamHandler(stream=sys.stdout),
-        handlers.RotatingFileHandler("streambot.log",
-                                     mode="a",
-                                     maxBytes=104857600,
-                                     backupCount=2,
-                                     encoding="utf-8")
+        handlers.RotatingFileHandler("streambot.log", mode="a", maxBytes=104857600, backupCount=2, encoding="utf-8")
     ],
 )
 
@@ -33,62 +29,60 @@ logging.getLogger("aiohttp.web").setLevel(logging.ERROR)
 
 server = web.AppRunner(web_server())
 
-loop = asyncio.get_event_loop()
+async def start_services():
+    print(
+        "****\n"
+        + (
+            "------------------ Starting as Secondary Server ------------------"
+            if Telegram.SECONDARY
+            else "------------------- Starting as Primary Server -------------------"
+        )
+        + "\n****\n-------------------- Initializing Telegram Bot --------------------"
+    )
+    await FileStream.start()
+    bot_info = await FileStream.get_me()
+    FileStream.id = bot_info.id
+    FileStream.username = bot_info.username
+    FileStream.fname = bot_info.first_name
+    print("------------------------------ DONE ------------------------------\n\n")
 
+    print("---------------------- Initializing Clients ----------------------")
+    await initialize_clients()
+    print("------------------------------ DONE ------------------------------\n\n")
 
-async def start_services():
-  print()
-  if Telegram.SECONDARY:
-    print("------------------ Starting as Secondary Server ------------------")
-  else:
-    print("------------------- Starting as Primary Server -------------------")
-  print()
-  print("-------------------- Initializing Telegram Bot --------------------")
+    print("--------------------- Initializing Web Server ---------------------")
+    await server.setup()
+    await web.TCPSite(server, Server.BIND_ADDRESS, Server.PORT).start()
+    print("------------------------------ DONE ------------------------------\n\n")
 
-  await FileStream.start()
-  bot_info = await FileStream.get_me()
-  FileStream.id = bot_info.id
-  FileStream.username = bot_info.username
-  FileStream.fname = bot_info.first_name
-  print("------------------------------ DONE ------------------------------")
-  print()
-  print("---------------------- Initializing Clients ----------------------")
-  await initialize_clients()
-  print("------------------------------ DONE ------------------------------")
-  print()
-  print("--------------------- Initializing Web Server ---------------------")
-  await server.setup()
-  await web.TCPSite(server, Server.BIND_ADDRESS, Server.PORT).start()
-  print("------------------------------ DONE ------------------------------")
-  print()
-  print("------------------------- Service Started -------------------------")
-  print("Bot =>> {}".format(bot_info.first_name))
-  if bot_info.dc_id:
-    print("DC ID =>> {}".format(str(bot_info.dc_id)))
-  print(" URL =>> {}".format(Server.URL))
-  print("------------------------------------------------------------------")
-  """
-  all_sources = [
-      Telegram.ULOG_GROUP, Telegram.FLOG_CHANNEL, Telegram.PFLOG_CHANNEL
-  ]
-  for source in all_sources:
-    await FileStream.send_message(chat_id=source,
-                                  text=f"Hi, I am Online @{ISTKolNow()}",
-                                  disable_web_page_preview=True)
-  """
-  await idle()
+    print(
+        f"------------------------- Service Started -------------------------\n"
+        f"Bot =>> {bot_info.first_name}\n"
+        + (f"DC ID =>> {bot_info.dc_id}\n" if bot_info.dc_id else "")
+        + f"URL =>> {Server.URL}\n"
+        "------------------------------------------------------------------"
+    )
 
+    # Uncomment the following section to send messages to specific sources
+    """
+    all_sources = [Telegram.ULOG_GROUP, Telegram.FLOG_CHANNEL, Telegram.PFLOG_CHANNEL]
+    for source in all_sources:
+        await FileStream.send_message(chat_id=source, text=f"Hi, I am Online @{Time_ISTKolNow()}", disable_web_page_preview=True)
+    """
+    await idle()
 
 async def cleanup():
-  await server.cleanup()
-  await FileStream.stop()
+    await server.cleanup()
 
+async def main():
+    try:
+        await start_services()
+    except KeyboardInterrupt:
+        print("\n------------------------ Stopped Services ------------------------")
+    except Exception as err:
+        logging.error("An error occurred:\n%s", traceback.format_exc())
+    finally:
+        await cleanup()
 
 if __name__ == "__main__":
-  try:
-    loop.run_until_complete(start_services())
-  except KeyboardInterrupt:
-    loop.stop()
-    print("------------------------ Stopped Services ------------------------")
-  except Exception as err:
-    logging.error(traceback.format_exc())
+    asyncio.run(main())

FileStream/bot/__init__.py

@@ -18,11 +18,13 @@ FileStream = Client(name="FileStream",
                     workers=Telegram.WORKERS,
                     no_updates=no_updates)
 
-multi_clients = {}
-work_loads = {}
+
+WORK_LOADS = {}
+MULTI_CLIENTS = {}
+ACTIVE_CLIENTS = {}
 
 async def req_client():
   index = min(work_loads, key=work_loads.get)
-  faster_client = multi_clients[index]
+  faster_client = MULTI_CLIENTS[index]
   response = dict(index=index, client=faster_client)
   return response

FileStream/bot/clients.py

@@ -1,9 +1,11 @@
 import asyncio
 import logging
 from os import environ
-from ..config import Telegram
 from pyrogram import Client
-from . import multi_clients, work_loads, FileStream
+
+from . import FileStream
+from ..config import Telegram
+from . import MULTI_CLIENTS, WORK_LOADS
 
 
 async def initialize_clients():
@@ -16,8 +18,8 @@ async def initialize_clients():
         )
     )
     if not all_tokens:
-        multi_clients[0] = FileStream
-        work_loads[0] = 0
+        MULTI_CLIENTS[0] = FileStream
+        WORK_LOADS[0] = 0
         print("No additional clients found, using default client")
         return
     
@@ -45,14 +47,14 @@ async def initialize_clients():
                 in_memory=True,
             ).start()
             client.id = (await client.get_me()).id
-            work_loads[client_id] = 0
+            WORK_LOADS[client_id] = 0
             return client_id, client
         except Exception:
             logging.error(f"Failed starting Client - {client_id} Error:", exc_info=True)
     
     clients = await asyncio.gather(*[start_client(i, token) for i, token in all_tokens.items()])
-    multi_clients.update(dict(clients))
-    if len(multi_clients) != 1:
+    MULTI_CLIENTS.update(dict(clients))
+    if len(MULTI_CLIENTS) != 1:
         Telegram.MULTI_CLIENT = True
         print("Multi-Client Mode Enabled")
     else:

FileStream/bot/plugins/FileHandlers/callback.py

@@ -12,7 +12,8 @@ from pyrogram.raw.types import KeyboardButtonSimpleWebView
 from FileStream import __version__
 from FileStream.Database import Database
 from FileStream.config import Telegram, Server
-from FileStream.bot import FileStream, multi_clients
+from FileStream.bot import FileStream
+from FileStream.bot import MULTI_CLIENTS
 from FileStream.server.exceptions import FIleNotFound
 from FileStream.utils.FileProcessors.translation import LANG, BUTTON
 from FileStream.utils.FileProcessors.human_readable import humanbytes

FileStream/bot/plugins/FileHandlers/stream.py

@@ -32,7 +32,8 @@ from FileStream.Database import Database
 from FileStream.config import Telegram, Server
 from FileStream.Tools.tool import TimeFormatter
 from FileStream.Tools.progress import progress
-from FileStream.bot import FileStream, multi_clients, work_loads, req_client
+from FileStream.bot import FileStream, req_client
+from FileStream.bot import MULTI_CLIENTS, WORK_LOADS
 from FileStream.utils.FileProcessors.bot_utils import is_user_banned, is_user_exist, is_user_joined, gen_link, is_channel_banned, is_channel_exist, is_user_authorized, upload_type_func
 from FileStream.utils.FileProcessors.custom_dl import ByteStreamer
 from FileStream.utils.FileProcessors.custom_ul import  TeleUploader
@@ -87,7 +88,7 @@ async def channel_receive_handler(bot: Client, message: Message):
 
     try:
         inserted_id = await db.add_file(get_file_info(message))
-        await get_file_ids(False, inserted_id, multi_clients, message)
+        await get_file_ids(False, inserted_id, MULTI_CLIENTS, message)
         reply_markup, stream_link = await gen_link(_id=inserted_id)
         await bot.edit_message_reply_markup(
             chat_id=message.chat.id,
@@ -155,15 +156,15 @@ async def reply_handler(
             ext = mimetypes.guess_extension(mime_type)
             file_info['file']['file_name'] = f"{message.text}{ext}"
 
-        #index = min(work_loads, key=work_loads.get)
-        #faster_client = multi_clients[index]
+        #index = min(WORK_LWORK_LOADS, key=WORK_LWORK_LOADS.get)
+        #faster_client = MULTI_CLIENTS[index]
         client=await req_client()
         print(f"Using {client['index']} for {file_info['file']['file_name']}")
         logging.info(f"Client {client['index']} is now serving {request.headers.get('X-FORWARDED-FOR',request.remote)}")
 
 
         tg_connect = TGFileController(client['client'])
-        req_file_id = await tg_connect.get_file_properties(file_info['_id'], multi_clients)
+        req_file_id = await tg_connect.get_file_properties(file_info['_id'], MULTI_CLIENTS)
 
         start_time = time.time()
         file = await tg_connect.upload_file(

FileStream/server/Functions/downloader.py

@@ -14,33 +14,35 @@ from aiohttp.http_exceptions import BadStatusLine
 from FileStream.config import Telegram
 from FileStream import utils, StartTime, __version__
 from FileStream.Tools import mime_identifier, Time_ISTKolNow
-from FileStream.bot import multi_clients, work_loads, req_client, FileStream
+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
 
-class_cache={}
-
 
 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]
 
-  #index = min(work_loads, key=work_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 class_cache:
-    tg_connect = class_cache[client['client']]
+  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'])
-    class_cache[client['client']] = tg_connect
+    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)
+  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
@@ -53,12 +55,12 @@ async def media_streamer(request: web.Request, db_id: str):
     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):
+  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}"},
+      status=416,
+      body="416: Range not satisfiable",
+      headers={"Content-Range": f"bytes */{file_size}"},
     )
 
   chunk_size = 512 * 1024
@@ -69,30 +71,28 @@ async def media_streamer(request: web.Request, db_id: str):
   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)
+  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"
+    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",
-      },
+    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",
+    },
   )

FileStream/server/render_template.py

@@ -21,20 +21,15 @@ async def render_page(db_id):
     async with aiohttp.ClientSession() as s:
       async with s.get(src) as u:
         file_size = humanbytes(int(u.headers.get('Content-Length')))
-
   with open(template_file) as f:
     template = jinja2.Template(f.read())
-
   return template.render(file_name=file_name,
                          file_url=src,
                          file_size=file_size)
 
 
 async def render_upload():
-
   template_file = "FileStream/server/template/upload.html"
-
   with open(template_file) as f:
     template = jinja2.Template(f.read())
-
   return template.render()

FileStream/server/routes_main.py

@@ -10,7 +10,8 @@ from aiohttp.http_exceptions import BadStatusLine
 
 #---------------------Local Upload---------------------#
 from FileStream.config import Telegram
-from FileStream.bot import multi_clients, work_loads, FileStream
+from FileStream.bot import FileStream
+from FileStream.bot import MULTI_CLIENTS, WORK_LOADS
 from FileStream.server.exceptions import FIleNotFound, InvalidHash
 from FileStream import utils, StartTime, __version__
 from FileStream.utils.FileProcessors.custom_ul import TeleUploader
@@ -26,8 +27,8 @@ async def root_status_handler(_):
       "server_status":"running",
       "uptime": utils.get_readable_time(time.time() - StartTime),
       "telegram_bot": "@" + FileStream.username,
-      "connected_bots": len(multi_clients),
-      "loads":dict(("bot" + str(c + 1), l) for c, (_, l) in enumerate(sorted(work_loads.items(), key=lambda x: x[1], reverse=True))),
+      "connected_bots": len(MULTI_CLIENTS),
+      "loads":dict(("bot" + str(c + 1), l) for c, (_, l) in enumerate(sorted(WORK_LOADS.items(), key=lambda x: x[1], reverse=True))),
       "version": __version__,
   })
 

FileStream/utils/FileProcessors/custom_dl.py

@@ -1,7 +1,7 @@
 import asyncio
 import logging
 from typing import Dict, Union
-from FileStream.bot import work_loads
+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
@@ -155,7 +155,7 @@ class ByteStreamer:
   ) -> Union[str, None]:
 
     client = self.client
-    work_loads[index] += 1
+    WORK_LOADS[index] += 1
     logging.debug(f"Starting to yielding file with client {index}.")
     media_session = await self.generate_media_session(client, file_id)
 
@@ -196,7 +196,7 @@ class ByteStreamer:
       pass
     finally:
       logging.debug(f"Finished yielding file with {current_part} parts.")
-      work_loads[index] -= 1
+      WORK_LOADS[index] -= 1
 
   async def clean_cache(self) -> None:
     """

FileStream/utils/FileProcessors/custom_mix.py

@@ -14,9 +14,9 @@ from pyrogram.file_id import FileId, FileType, ThumbnailSource
 from pyrogram.types import Message
 from pyrogram import StopTransmission
 
-from FileStream.bot import work_loads
+
 from typing import Dict, Union
-from FileStream.bot import work_loads
+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
@@ -49,7 +49,7 @@ from pyrogram.enums.parse_mode import ParseMode
 
 #-----------------------Local Imports----------------------------------#
 from FileStream import utils, StartTime, __version__
-from FileStream.bot import FileStream, multi_clients, work_loads
+from FileStream.bot import FileStream, MULTI_CLIENTS, WORK_LOADS
 from FileStream.utils.FileProcessors.bot_utils import is_user_banned, is_user_exist, is_user_joined, gen_link, is_channel_banned, is_channel_exist, is_user_authorized
 from FileStream.Database import Database
 from FileStream.utils.FileProcessors.file_properties import get_file_ids, get_file_info
@@ -78,7 +78,7 @@ class TGFileController:
   async def get_me(self):
     return await self.client.get_me().username
 
-  async def get_file_properties(self, db_id: str, multi_clients) -> FileId:
+  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.
@@ -86,12 +86,12 @@ class TGFileController:
         """
     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)
+      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:
+                                     MULTI_CLIENTS) -> FileId:
     """
         Generates the properties of a media file on a specific message.
         returns ths properties in a FIleId class.
@@ -306,7 +306,7 @@ class TGFileController:
         client.loop.create_task(worker(session)) for _ in range(workers_count)
     ]
 
-    work_loads[index] += 1
+    WORK_LOADS[index] += 1
     logging.debug(f"Starting to yielding file with client {index}.")
     media_session = await self.generate_media_session(client, file_id)
 
@@ -370,7 +370,7 @@ class TGFileController:
 
       await session.stop()
       logging.debug(f"Finished yielding file with {file_part} parts.")
-      work_loads[index] -= 1
+      WORK_LOADS[index] -= 1
 
     if is_big:
       return raw.types.InputFileBig(

FileStream/utils/FileProcessors/custom_ul.py

@@ -11,7 +11,7 @@ from pyrogram import filters, types, Client, raw
 from pyrogram.file_id import FileId, FileType, PHOTO_TYPES, ThumbnailSource
 from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton, CallbackQuery
 #----------------------------------------------
-from FileStream.bot import FileStream, multi_clients, work_loads
+from FileStream.bot import FileStream, MULTI_CLIENTS, WORK_LOADS
 from FileStream.config import Telegram, Server
 from FileStream.Database import Database
 import asyncio
@@ -48,7 +48,7 @@ class TeleUploader:
   async def get_me(self):
     return await self.client.get_me().username
 
-  async def get_file_properties(self, db_id: str, multi_clients) -> FileId:
+  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.
@@ -56,7 +56,7 @@ class TeleUploader:
     """
     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)
+      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]
 
@@ -72,12 +72,11 @@ class TeleUploader:
     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,
+          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()
 
@@ -87,23 +86,21 @@ class TeleUploader:
 
           try:
             await media_session.invoke(
-                raw.functions.auth.ImportAuthorization(
-                    id=exported_auth.id, bytes=exported_auth.bytes))
+                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}")
+            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,
+          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}")
@@ -149,8 +146,7 @@ class TeleUploader:
     file_size_limit_mib = 4000 if client.me.is_premium else 2000
     #file_size_limit_mib = 4000
     if file_details["file"]["file_size"] > file_size_limit_mib * 1024 * 1024:
-      raise ValueError(
-          f"Can't upload files bigger than {file_size_limit_mib} MiB")
+      raise ValueError(f"Can't upload files bigger than {file_size_limit_mib} MiB")
 
     #file_total_parts = file_details["total_parts"]
     #is_big = file_size > 10 * 1024 * 1024
@@ -175,8 +171,7 @@ class TeleUploader:
             file_total_parts=file_details["file"]["total_parts"],
             bytes=chunk)
         response['status'] = "success"
-        response[
-            'message'] = f"Uploading as Bigfile {file_details['file']['file_part']}/{file_details['file']['total_parts']}"
+        response['message'] = f"Uploading as Bigfile {file_details['file']['file_part']}/{file_details['file']['total_parts']}"
         print("Response", response)
 
       await session.invoke(rpc)
@@ -197,8 +192,7 @@ class TeleUploader:
           file=final,
           mime_type=file_details['file']["mime_type"],
           attributes=[
-              raw.types.DocumentAttributeFilename(
-                  file_name=file_details['file']["file_name"])
+              raw.types.DocumentAttributeFilename(file_name=file_details['file']["file_name"])
           ])
 
       try:
@@ -243,7 +237,7 @@ class TeleUploader:
         )
 
         #log_msg = await send_file(FileStream, db_id, file_info['file_id'], message)
-        #await update_file_id(log_msg.id, multi_clients))
+        #await update_file_id(log_msg.id, MULTI_CLIENTS))
       except Exception as e:
         await client.send_message(chat_id=Telegram.ULOG_GROUP,
                                   text=f"**#EʀʀᴏʀTʀᴀᴄᴋᴇʙᴀᴄᴋ:** `{e}`",

FileStream/utils/FileProcessors/file_properties.py

@@ -8,7 +8,8 @@ from pyrogram.enums import ParseMode, ChatType
 from pyrogram.types import Message
 from pyrogram.file_id import FileId
 #-----------------------------------------------------
-from FileStream.bot import FileStream, multi_clients
+from FileStream.bot import FileStream
+from FileStream.bot import MULTI_CLIENTS
 from FileStream.Database import Database
 from FileStream.config import Telegram, Server
 from FileStream.Tools import Time_ISTKolNow
@@ -39,9 +40,9 @@ async def send_file(client: Client, db_id, file_id: str, message, send_to):
   return {"message": log_msg, "sent_to": send_to}
 
 
-async def update_file_id(message, multi_clients):
+async def update_file_id(message, MULTI_CLIENTS):
   file_ids = {}
-  for client_id, client in multi_clients.items():
+  for client_id, client in MULTI_CLIENTS.items():
     #log_msg = await client.get_messages(message['location'],message['message_id'])
     media = get_media_from_message(await client.get_messages(message['location'],message['message_id']))
     file_ids[str(client.id)] = getattr(media, "file_id", "")
@@ -81,7 +82,7 @@ async def get_file_ids(client: Client | bool, db_id: str, message) -> Optional[F
         log_msg = await send_file(FileStream, db_id,file_info['file']['file_id'], message,Telegram.FLOG_CHANNEL)
         #updated_info = update_file_info(log_msg)
         await db.update_file_info(db_id, update_file_info(log_msg))
-        await db.update_file_ids(db_id, await update_file_id(await db.get_file(db_id),multi_clients))
+        await db.update_file_ids(db_id, await update_file_id(await db.get_file(db_id),MULTI_CLIENTS))
 
       logging.debug("Stored file_id of all clients in DB")
       if not client:
@@ -89,7 +90,7 @@ async def get_file_ids(client: Client | bool, db_id: str, message) -> Optional[F
       file_info = await db.get_file(db_id)
 
     if file_info['user_type'] == "WEB":
-      await db.update_file_ids(db_id, await update_file_id(await db.get_file(db_id), multi_clients))
+      await db.update_file_ids(db_id, await update_file_id(await db.get_file(db_id), MULTI_CLIENTS))
       logging.debug("Stored file_id of all clients in DB")
       if not client:
         return

Unused Codes/__main__old.py

@@ -0,0 +1,94 @@
+import sys
+import asyncio
+import logging
+import traceback
+import logging.handlers as handlers
+from FileStream.config import Telegram, Server
+from aiohttp import web
+from pyrogram import idle
+
+from FileStream.bot import FileStream
+from FileStream.Tools import Time_ISTKolNow
+from FileStream.server import web_server
+from FileStream.bot.clients import initialize_clients
+
+logging.basicConfig(
+    level=logging.INFO,
+    datefmt="%d/%m/%Y %H:%M:%S",
+    format=
+    '[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(stream=sys.stdout),
+        handlers.RotatingFileHandler("streambot.log",
+                                     mode="a",
+                                     maxBytes=104857600,
+                                     backupCount=2,
+                                     encoding="utf-8")
+    ],
+)
+
+logging.getLogger("aiohttp").setLevel(logging.ERROR)
+logging.getLogger("pyrogram").setLevel(logging.ERROR)
+logging.getLogger("aiohttp.web").setLevel(logging.ERROR)
+
+server = web.AppRunner(web_server())
+
+loop = asyncio.get_event_loop()
+
+
+async def start_services():
+  print("****")
+  if Telegram.SECONDARY:
+    print("------------------ Starting as Secondary Server ------------------")
+  else:
+    print("------------------- Starting as Primary Server -------------------")
+  print( "****")
+  print("-------------------- Initializing Telegram Bot --------------------")
+
+  await FileStream.start()
+  bot_info = await FileStream.get_me()
+  FileStream.id = bot_info.id
+  FileStream.username = bot_info.username
+  FileStream.fname = bot_info.first_name
+  print("------------------------------ DONE ------------------------------")
+  print("\n")
+  print("---------------------- Initializing Clients ----------------------")
+  await initialize_clients()
+  print("------------------------------ DONE ------------------------------")
+  print("\n")
+  print("--------------------- Initializing Web Server ---------------------")
+  await server.setup()
+  await web.TCPSite(server, Server.BIND_ADDRESS, Server.PORT).start()
+  print("------------------------------ DONE ------------------------------")
+  print("\n")
+  print("------------------------- Service Started -------------------------")
+  print("Bot =>> {}".format(bot_info.first_name))
+  if bot_info.dc_id:
+    print("DC ID =>> {}".format(str(bot_info.dc_id)))
+  print(" URL =>> {}".format(Server.URL))
+  print("------------------------------------------------------------------")
+  """
+  all_sources = [
+      Telegram.ULOG_GROUP, Telegram.FLOG_CHANNEL, Telegram.PFLOG_CHANNEL
+  ]
+  for source in all_sources:
+    await FileStream.send_message(chat_id=source,
+                                  text=f"Hi, I am Online @{ISTKolNow()}",
+                                  disable_web_page_preview=True)
+  """
+  await idle()
+
+
+async def cleanup():
+  await server.cleanup()
+  #await FileStream.stop()
+
+
+if __name__ == "__main__":
+  try:
+    loop.run_until_complete(start_services())
+  except KeyboardInterrupt:
+    loop.stop()
+    print("------------------------ Stopped Services ------------------------")
+  except Exception as err:
+    logging.error(traceback.format_exc())