Use bot.session files instead of bot tokens

config.py

@@ -8,16 +8,21 @@ load_dotenv()
 API_ID = int(os.getenv("API_ID"))  # Your Telegram API ID
 API_HASH = os.getenv("API_HASH")  # Your Telegram API Hash
 
-# List of Telegram bot tokens used for file upload/download operations
-BOT_TOKENS = os.getenv("BOT_TOKENS", "").strip(", ").split(",")
-BOT_TOKENS = [token.strip() for token in BOT_TOKENS if token.strip() != ""]
+# List of Telegram bot session files (e.g., "bot1.session,bot2.session") used for file upload/download operations
+# Session files should be placed in the cache directory
+BOT_SESSIONS = os.getenv("BOT_SESSIONS", "").strip(", ").split(",")
+BOT_SESSIONS = [session.strip() for session in BOT_SESSIONS if session.strip() != ""]
 
-# List of Premium Telegram Account Pyrogram String Sessions used for file upload/download operations
+# List of Telegram Account Pyrogram String Sessions used for file upload/download operations (optional)
 STRING_SESSIONS = os.getenv("STRING_SESSIONS", "").strip(", ").split(",")
 STRING_SESSIONS = [
     session.strip() for session in STRING_SESSIONS if session.strip() != ""
 ]
 
+# List of Telegram bot tokens (deprecated - use BOT_SESSIONS instead)
+BOT_TOKENS = os.getenv("BOT_TOKENS", "").strip(", ").split(",")
+BOT_TOKENS = [token.strip() for token in BOT_TOKENS if token.strip() != ""]
+
 # Chat ID of the Telegram storage channel where files will be stored
 STORAGE_CHANNEL = int(os.getenv("STORAGE_CHANNEL"))  # Your storage channel's chat ID
 
@@ -30,11 +35,11 @@ DATABASE_BACKUP_MSG_ID = int(
 ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "admin")  # Default to "admin" if not set
 
 # Determine the maximum file size (in bytes) allowed for uploading to Telegram
-# 1.98 GB if no premium sessions are provided, otherwise 3.98 GB
-if len(STRING_SESSIONS) == 0:
-    MAX_FILE_SIZE = 1.98 * 1024 * 1024 * 1024  # 2 GB in bytes
+# String sessions support up to 4GB (if Premium), bot sessions/tokens limited to 2GB
+if len(STRING_SESSIONS) > 0:
+    MAX_FILE_SIZE = 3.98 * 1024 * 1024 * 1024  # 4 GB in bytes (with Premium)
 else:
-    MAX_FILE_SIZE = 3.98 * 1024 * 1024 * 1024  # 4 GB in bytes
+    MAX_FILE_SIZE = 1.98 * 1024 * 1024 * 1024  # 2 GB in bytes (bot sessions/tokens)
 
 # Database backup interval in seconds. Backups will be sent to the storage channel at this interval
 DATABASE_BACKUP_TIME = int(

sample.env

@@ -2,6 +2,12 @@
 
 API_ID=123456
 API_HASH=dagsjdhgjfsahgjfh
-BOT_TOKENS=21413535:gkdshajfhjfakhjf
+BOT_SESSIONS=bot1.session,bot2.session
 STORAGE_CHANNEL=-100123456789
-DATABASE_BACKUP_MSG_ID=123
+DATABASE_BACKUP_MSG_ID=123
+
+# Optional: String sessions for Premium accounts (files > 2GB)
+# STRING_SESSIONS=1BVtsOMwBu5...your_session_string_here...
+
+# Optional: Bot tokens (fallback if BOT_SESSIONS not available)
+# BOT_TOKENS=21413535:gkdshajfhjfakhjf

utils/clients.py

@@ -21,47 +21,71 @@ async def initialize_clients():
     session_cache_path = Path(f"./cache")
     session_cache_path.parent.mkdir(parents=True, exist_ok=True)
 
-    all_tokens = dict((i, t) for i, t in enumerate(config.BOT_TOKENS, start=1))
-    all_sessions = dict(
-        (i, s) for i, s in enumerate(config.STRING_SESSIONS, start=len(all_tokens) + 1)
+    # Use BOT_SESSIONS (session files) as primary method
+    all_bot_sessions = dict((i, s) for i, s in enumerate(config.BOT_SESSIONS, start=1))
+    all_string_sessions = dict(
+        (i, s) for i, s in enumerate(config.STRING_SESSIONS, start=len(all_bot_sessions) + 1)
+    )
+    # Fallback to bot tokens if session files not available
+    all_tokens = dict(
+        (i, t) for i, t in enumerate(config.BOT_TOKENS, start=len(all_bot_sessions) + len(all_string_sessions) + 1)
     )
 
-    async def start_client(client_id, token, type):
+    async def start_client(client_id, session_name_or_token, type):
         try:
             logger.info(f"Starting - {type.title()} Client {client_id}")
 
-            if type == "bot":
+            if type == "bot_session":
+                # Use bot session file (e.g., "bot1.session")
+                # Session file should be in cache directory
                 client = Client(
-                    name=str(client_id),
+                    name=session_name_or_token.replace(".session", ""),  # Remove .session extension
                     api_id=config.API_ID,
                     api_hash=config.API_HASH,
-                    bot_token=token,
                     workdir=session_cache_path,
                 )
                 client.loop = asyncio.get_running_loop()
                 await client.start()
                 await client.send_message(
                     config.STORAGE_CHANNEL,
-                    f"Started - {type.title()} Client {client_id}",
+                    f"Started - Bot Session Client {client_id}",
                 )
                 multi_clients[client_id] = client
                 work_loads[client_id] = 0
-            elif type == "user":
+            elif type == "string_session":
+                # Use string session (user account)
                 client = await Client(
                     name=str(client_id),
                     api_id=config.API_ID,
                     api_hash=config.API_HASH,
-                    session_string=token,
+                    session_string=session_name_or_token,
                     sleep_threshold=config.SLEEP_THRESHOLD,
                     workdir=session_cache_path,
                     no_updates=True,
                 ).start()
                 await client.send_message(
                     config.STORAGE_CHANNEL,
-                    f"Started - {type.title()} Client {client_id}",
+                    f"Started - String Session Client {client_id}",
                 )
                 premium_clients[client_id] = client
                 premium_work_loads[client_id] = 0
+            elif type == "bot_token":
+                # Fallback: Use bot token if session files not available
+                client = Client(
+                    name=str(client_id),
+                    api_id=config.API_ID,
+                    api_hash=config.API_HASH,
+                    bot_token=session_name_or_token,
+                    workdir=session_cache_path,
+                )
+                client.loop = asyncio.get_running_loop()
+                await client.start()
+                await client.send_message(
+                    config.STORAGE_CHANNEL,
+                    f"Started - Bot Token Client {client_id}",
+                )
+                multi_clients[client_id] = client
+                work_loads[client_id] = 0
 
             logger.info(f"Started - {type.title()} Client {client_id}")
         except Exception as e:
@@ -72,15 +96,20 @@ async def initialize_clients():
             )
             logger.error(f"Traceback: {error_trace}")
 
+    # Prioritize bot session files
     await asyncio.gather(
         *(
             [
-                start_client(client_id, client, "bot")
-                for client_id, client in all_tokens.items()
+                start_client(client_id, session_name, "bot_session")
+                for client_id, session_name in all_bot_sessions.items()
+            ]
+            + [
+                start_client(client_id, session, "string_session")
+                for client_id, session in all_string_sessions.items()
             ]
             + [
-                start_client(client_id, client, "user")
-                for client_id, client in all_sessions.items()
+                start_client(client_id, token, "bot_token")
+                for client_id, token in all_tokens.items()
             ]
         )
     )
@@ -89,11 +118,9 @@ async def initialize_clients():
     
     if not clients_initialized:
         logger.warning("No Clients Were Initialized - Website will run in offline mode")
+        logger.warning("Please configure BOT_SESSIONS in your environment variables")
         return False
 
-    if len(premium_clients) == 0:
-        logger.info("No Premium Clients Were Initialized")
-
     logger.info("Clients Initialized")
 
     # Load the drive data
@@ -122,7 +149,7 @@ def get_client(premium_required=False) -> Client:
         return premium_clients[index]
 
     if not work_loads:
-        raise RuntimeError("No Clients Available - Check BOT_TOKENS configuration")
+        raise RuntimeError("No Clients Available - Check BOT_SESSIONS configuration")
     index = min(work_loads, key=work_loads.get)
     work_loads[index] += 1
     return multi_clients[index]