fix: event loop

Author: An0nX

userbot/__init__.py

@@ -23,7 +23,6 @@
 # --- Globals ---
 ACTIVE_CLIENTS: Dict[int, "TelegramClient"] = {}
 LOOP: asyncio.AbstractEventLoop = asyncio.get_event_loop()
-# Re-adding FAKE and GLOBAL_HELP_INFO to resolve the ImportError in __main__.py
 FAKE: Faker = Faker()
 GLOBAL_HELP_INFO: Dict[int, Dict[str, str]] = {}
 
@@ -101,10 +100,8 @@ async def start_individual_client(client: TelegramClient, account: Account) -> N
         await client.start()
         if await client.is_user_authorized():
             logger.info(f"Client for account '{account_name}' (ID: {account_id}) is authorized.")
-            # Initialize help_info dict for this client
             GLOBAL_HELP_INFO[account_id] = {}
 
-            # Register core handlers
             client.add_event_handler(help_commands_handler, events.NewMessage(outgoing=True, pattern=r"^\.help$"))
             client.add_event_handler(about_command_handler, events.NewMessage(outgoing=True, pattern=r"^\.about$"))
             client.add_event_handler(list_accounts_handler, events.NewMessage(outgoing=True, pattern=r"^\.listaccs$"))
@@ -113,8 +110,7 @@ async def start_individual_client(client: TelegramClient, account: Account) -> N
             client.add_event_handler(toggle_account_handler, events.NewMessage(outgoing=True, pattern=r"^\.toggleacc\s+([a-zA-Z0-9_]+)$"))
             client.add_event_handler(set_lang_handler, events.NewMessage(outgoing=True, pattern=r"^\.setlang\s+([a-zA-Z]{2,5})$"))
 
-            # Placeholder for module handlers
-            # await load_account_modules(account_id, client, GLOBAL_HELP_INFO[account_id])
+            await load_account_modules(account_id, client, GLOBAL_HELP_INFO[account_id])
         else:
             logger.warning(f"Client for '{account_name}' started, but user is NOT authorized.")
     except Exception as e:
@@ -160,19 +156,3 @@ async def manage_clients() -> None:
         tasks.append(start_individual_client(new_client, account))
 
     await asyncio.gather(*tasks)
-
-# --- Main Execution Block ---
-# This logic ensures the script can be run directly but not when imported.
-if __name__ != "userbot":
-    if LOOP.is_running():
-        asyncio.ensure_future(db_setup())
-        asyncio.ensure_future(manage_clients())
-    else:
-        try:
-            LOOP.run_until_complete(db_setup())
-            LOOP.run_until_complete(manage_clients())
-        except Exception as e:
-            logger.critical(f"Failed during initial setup: {e}")
-            sys.exit(1)
-
-    logger.info("Userbot __init__ finished. Client management tasks scheduled.")

userbot/__main__.py

@@ -1,45 +1,38 @@
 import asyncio
 import gc
 import logging
-import subprocess
 import sys
-from typing import Dict, Any, Optional, List, Set
+from typing import Dict, Any
 
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from rich.console import Console
-from telethon import events, helpers
+from telethon import events
 from telethon.errors import SessionPasswordNeededError
 from telethon.sessions import StringSession
 from art import text2art
 
-from userbot import ACTIVE_CLIENTS, LOOP, GLOBAL_HELP_INFO, FAKE, TelegramClient
+from userbot import (
+    ACTIVE_CLIENTS, FAKE, TelegramClient,
+    db_setup, manage_clients, GLOBAL_HELP_INFO
+)
 from userbot.src.config import GC_INTERVAL_SECONDS
 from userbot.src.db.session import get_db
 import userbot.src.db_manager as db_manager
-from userbot.src.module_parser import parse_module_metadata
 
 console: Console = Console()
 logger: logging.Logger = logging.getLogger(__name__)
 
 # --- Helper Functions ---
 async def get_account_id_from_client(client) -> int | None:
-    """Gets the account_id associated with a client instance."""
     return next((acc_id for acc_id, c in ACTIVE_CLIENTS.items() if c == client), None)
 
 # --- Module Management (Placeholders) ---
 async def load_account_modules(account_id: int, client_instance, current_help_info: Dict[str, str]) -> None:
-    """Loads all active and trusted modules for a given account."""
     console.print(f"[MODULES] - Loading modules for account_id: {account_id}...", style="yellow")
-    # In a real scenario, this would populate current_help_info based on loaded modules
     pass
 
-async def delmod_handler(event: events.NewMessage.Event):
-    """Handles unlinking a module and safely uninstalling its dependencies."""
-    await event.edit("Команда `.delmod` в разработке.")
-
 # --- Account Management Handlers ---
 async def list_accounts_handler(event: events.NewMessage.Event):
-    """Lists all accounts in the database with their status."""
     await event.edit(await event.client.get_string("verifying_creds"))
     header = await event.client.get_string("account_list_header")
     response_lines = [header]
@@ -66,7 +59,6 @@ async def list_accounts_handler(event: events.NewMessage.Event):
     await event.edit("\n".join(response_lines), parse_mode="html")
 
 async def add_account_handler(event: events.NewMessage.Event):
-    """Interactively adds a new account session."""
     account_name = event.pattern_match.group(1)
 
     try:
@@ -82,11 +74,10 @@ async def add_account_handler(event: events.NewMessage.Event):
             try:
                 await temp_client.connect()
                 if not await temp_client.is_user_authorized():
-                    # This part is highly simplified. A real sign-in flow is more complex.
-                    phone_number = await temp_client.send_code_request(api_id) 
+                    phone = await temp_client.send_code_request(api_id)
                     await conv.send_message(f"Код отправлен. Введите его:")
                     code = (await conv.get_response()).text.strip()
-                    await temp_client.sign_in(password=code)
+                    await temp_client.sign_in(phone=phone.phone, code=code)
             except SessionPasswordNeededError:
                 await conv.send_message(await event.client.get_string("prompt_2fa"))
                 two_fa_pass_resp = await conv.get_response(); two_fa_pass = two_fa_pass_resp.text.strip()
@@ -102,7 +93,7 @@ async def add_account_handler(event: events.NewMessage.Event):
                     return
 
             await conv.send_message(await event.client.get_string("prompt_lang")); lang_code = (await conv.get_response()).text.strip() or 'ru'
-            await conv.send_message(await event.client.get_string("prompt_activate")); is_enabled = (await conv.get_response()).text.lower().startswith('д')
+            await conv.send_message(await event.client.get_string("prompt_activate")); is_enabled = (await conv.get_response()).text.lower().startswith(('y', 'д'))
 
             device_model, system_version, app_version = FAKE.android_platform_token(), "SDK 31", "10.1.0"
 
@@ -125,7 +116,6 @@ async def add_account_handler(event: events.NewMessage.Event):
         await event.respond(await event.client.get_string("generic_error", error=str(e)))
 
 async def delete_account_handler(event: events.NewMessage.Event):
-    """Deletes an account from the database."""
     account_name = event.pattern_match.group(1)
     try:
         async with event.client.conversation(event.chat_id, timeout=60) as conv:
@@ -143,9 +133,7 @@ async def delete_account_handler(event: events.NewMessage.Event):
     except asyncio.TimeoutError:
         await event.respond(await event.client.get_string("delete_timeout"))
 
-
 async def toggle_account_handler(event: events.NewMessage.Event):
-    """Enables or disables an account."""
     account_name = event.pattern_match.group(1)
     async with get_db() as db:
         new_status = await db_manager.toggle_account_status(db, account_name)
@@ -158,7 +146,6 @@ async def toggle_account_handler(event: events.NewMessage.Event):
         await event.edit(await event.client.get_string("toggle_disabled", account_name=account_name))
 
 async def set_lang_handler(event: events.NewMessage.Event):
-    """Sets the language for the current account."""
     lang_code = event.pattern_match.group(1).lower()
     account_id = await get_account_id_from_client(event.client)
     if not account_id: return
@@ -173,7 +160,6 @@ async def set_lang_handler(event: events.NewMessage.Event):
         await event.edit(await event.client.get_string("lang_update_fail"))
 
 async def help_commands_handler(event: events.NewMessage.Event):
-    """Displays the help message."""
     help_management = "\n".join([
         f"<code>.listaccs</code> - {await event.client.get_string('help_listaccs')}",
         f"<code>.addacc &lt;name&gt;</code> - {await event.client.get_string('help_addacc')}",
@@ -182,28 +168,35 @@ async def help_commands_handler(event: events.NewMessage.Event):
         f"<code>.setlang &lt;code&gt;</code> - {await event.client.get_string('help_setlang')}",
         f"<code>.about</code> - {await event.client.get_string('help_about')}",
     ])
-    
     final_text = f"{await event.client.get_string('help_header_management')}\n{help_management}"
     await event.edit(final_text, parse_mode="HTML")
 
 async def about_command_handler(event: events.NewMessage.Event):
-    """Displays information about the userbot."""
     await event.edit(await event.client.get_string("about_text"), parse_mode="HTML")
 
-# --- Main Execution ---
-if __name__ == "__main__":
+async def main():
+    """The main entry point for the userbot."""
     console.print(text2art("DeBot", font="random", chr_ignore=True), style="cyan")
     console.print("\n                            coded by @whynothacked", style="yellow")
 
+    await db_setup()
+    await manage_clients()
+
     scheduler = AsyncIOScheduler(timezone="UTC")
     scheduler.add_job(gc.collect, 'interval', seconds=GC_INTERVAL_SECONDS, id='gc_job')
     scheduler.start()
     console.print(f"-> [system] - GC scheduled every {GC_INTERVAL_SECONDS} seconds.", style="blue")
-    
+
+    logger.info("Userbot is running. Press Ctrl+C to stop.")
+    # Keep the main coroutine alive indefinitely
+    await asyncio.Event().wait()
+
+
+if __name__ == "__main__":
     try:
-        LOOP.run_forever()
+        asyncio.run(main())
     except KeyboardInterrupt:
         console.print("\n[MAIN] - Userbot stopped by user.", style="bold yellow")
-    finally:
-        if scheduler.running: scheduler.shutdown()
-        console.print("[MAIN] - Userbot shutdown complete.", style="bold green")
+    except Exception as e:
+        logger.critical(f"An unhandled error occurred in main: {e}", exc_info=True)
+        sys.exit(1)