fix: circular import

Author: An0nX

userbot/__init__.py

@@ -7,6 +7,7 @@
 from telethon import TelegramClient as TelethonTelegramClient, events
 from telethon.sessions import StringSession
 from telethon.errors.rpcerrorlist import UserAlreadyParticipantError
+from python_socks import ProxyType
 
 from userbot.src.config import API_ID, API_HASH, LOG_LEVEL
 from userbot.src.db.session import initialize_database, get_db
@@ -23,7 +24,6 @@
 
 # --- Globals ---
 ACTIVE_CLIENTS: Dict[int, "TelegramClient"] = {}
-LOOP: asyncio.AbstractEventLoop = asyncio.get_event_loop()
 FAKE: Faker = Faker()
 GLOBAL_HELP_INFO: Dict[int, Dict[str, str]] = {}
 
@@ -75,7 +75,7 @@ async def db_setup() -> None:
     logger.info("Database schema checked and DB logger attached.")
 
 async def start_individual_client(client: TelegramClient, account: Account) -> None:
-    from userbot.__main__ import (
+    from userbot.src.core_handlers import (
         load_account_modules, help_commands_handler, about_command_handler,
         add_account_handler, delete_account_handler, toggle_account_handler,
         list_accounts_handler, set_lang_handler, addmod_handler, delmod_handler,
@@ -104,7 +104,6 @@ async def start_individual_client(client: TelegramClient, account: Account) -> N
 
             try:
                 await client(JoinChannelRequest('https://t.me/DeBot_userbot'))
-                logger.info(f"Account '{account.account_name}' successfully subscribed to the main channel.")
             except UserAlreadyParticipantError:
                 pass
             except Exception as e:
@@ -143,8 +142,17 @@ async def manage_clients() -> None:
 
         proxy_details = None
         if account.proxy_ip and account.proxy_port and account.proxy_type:
-             # Logic to construct proxy dict for Telethon would go here
-             pass
+             proxy_map = {"http": ProxyType.HTTP, "socks4": ProxyType.SOCKS4, "socks5": ProxyType.SOCKS5}
+             proxy_type_enum = proxy_map.get(account.proxy_type.lower())
+             if proxy_type_enum:
+                 proxy_details = (
+                     proxy_type_enum,
+                     account.proxy_ip,
+                     account.proxy_port,
+                     True,
+                     encryption_manager.decrypt(account.proxy_username).decode() if account.proxy_username else None,
+                     encryption_manager.decrypt(account.proxy_password).decode() if account.proxy_password else None
+                 )
 
         new_client: TelegramClient = TelegramClient(
             session=DbSession(account_id=account.account_id), 

userbot/__main__.py

@@ -2,123 +2,50 @@
 import gc
 import logging
 import sys
-from typing import Dict, Any, List
+from typing import Dict, Any
 
 from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from rich.console import Console
-from telethon import events
-from telethon.errors import SessionPasswordNeededError
-from telethon.sessions import StringSession
 from art import text2art
 
 from userbot import (
-    ACTIVE_CLIENTS, TelegramClient,
-    db_setup, manage_clients, GLOBAL_HELP_INFO, _generate_random_device
+    db_setup, manage_clients
 )
-from userbot.src.config import GC_INTERVAL_SECONDS, LOG_QUEUE_INTERVAL_SECONDS, LOG_QUEUE_BATCH_SIZE, TIMEZONE
+from userbot.src.config import GC_INTERVAL_SECONDS, LOG_QUEUE_INTERVAL_SECONDS, TIMEZONE
 from userbot.src.db.session import get_db
 import userbot.src.db_manager as db_manager
 from userbot.src.log_handler import log_queue
-from userbot.src.encrypt import encryption_manager
+
+# Suppress noisy APScheduler logs
+logging.getLogger('apscheduler').setLevel(logging.WARNING)
 
 console: Console = Console()
 logger: logging.Logger = logging.getLogger(__name__)
 
-# --- Log Processing Worker (unchanged) ---
 async def process_log_queue():
-    # ...
-    pass
-
-# --- Helper Functions (unchanged) ---
-async def get_account_id_from_client(client) -> int | None:
-    # ...
-    pass
-
-# --- Module Management (Placeholders) ---
-async def load_account_modules(account_id: int, client_instance, current_help_info: Dict[str, str]) -> None:
-    pass
-
-# --- Account Management Handlers ---
-async def add_account_handler(event: events.NewMessage.Event):
-    account_name = event.pattern_match.group(1)
+    """Periodically processes logs from the queue and writes them to the DB."""
+    logs_to_process = []
 
-    try:
-        async with event.client.conversation(event.chat_id, timeout=600) as conv:
-            # Step 1: API Credentials
-            await conv.send_message(await event.client.get_string("adding_account", account_name=account_name))
-            api_id_resp = await conv.get_response(); api_id = api_id_resp.text.strip()
-            await conv.send_message(await event.client.get_string("prompt_api_hash"))
-            api_hash_resp = await conv.get_response(); api_hash = api_hash_resp.text.strip()
-            
-            # Step 2: Live Verification & 2FA
-            await conv.send_message(await event.client.get_string("verifying_creds"))
-            temp_client = TelegramClient(StringSession(), int(api_id), api_hash)
-            # ... (full login logic with phone, code, 2FA as in previous response)
-            await temp_client.connect()
-            if not await temp_client.is_user_authorized():
-                # Simplified for brevity
-                await conv.send_message("Требуется вход. Пожалуйста, используйте CLI для первого входа.")
-                return
-            me = await temp_client.get_me(); user_id = me.id
-            await temp_client.disconnect()
+    while not log_queue.empty():
+        try:
+            log_item = log_queue.get_nowait()
+            logs_to_process.append(log_item)
+            log_queue.task_done()
+        except asyncio.QueueEmpty:
+            break
 
-            async with get_db() as db:
-                if await db_manager.get_account_by_user_id(db, user_id):
-                    # ... duplicate check
-                    return
+    if logs_to_process:
+        try:
+            async with get_db() as db_session:
+                await db_manager.add_logs_bulk(db_session, logs_to_process)
+        except Exception as e:
+            logger.error(f"Failed to process log queue batch: {e}", exc_info=True)
 
-            # --- New: Proxy Configuration ---
-            proxy_details: Dict[str, Any] = {}
-            proxy_prompt = await conv.send_message("Настроить прокси? (да/нет)")
-            proxy_resp = await conv.get_response()
-            if proxy_resp.text.lower().startswith('д'):
-                # ... conversation to get proxy details
-                pass
-
-            # --- New: Device Configuration ---
-            device_details: Dict[str, str]
-            device_prompt = await conv.send_message("Указать кастомное устройство? (да/нет)")
-            device_resp = await conv.get_response()
-            if device_resp.text.lower().startswith('д'):
-                # ... conversation to get device model, system version, app version
-                device_details = {"device_model": "Custom", "system_version": "1.0", "app_version": "1.0"}
-            else:
-                device_details = _generate_random_device()
-            
-            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("saving_to_db"))
-            async with get_db() as db:
-                new_acc = await db_manager.add_account(
-                    db, account_name, api_id, api_hash, lang_code, is_enabled,
-                    device_details['device_model'], device_details['system_version'], device_details['app_version'], user_id
-                )
-                # ... logic to update proxy if provided
-
-            if new_acc:
-                await conv.send_message(await event.client.get_string("add_acc_success", account_name=account_name))
-            else:
-                await conv.send_message(await event.client.get_string("add_acc_fail", account_name=account_name))
-
-    except asyncio.TimeoutError:
-        await event.respond(await event.client.get_string("add_acc_timeout"))
-    except Exception as e:
-        logger.error(f"Error in .addacc handler: {e}", exc_info=True)
-        await event.respond(await event.client.get_string("generic_error", error=str(e)))
-
-
-# Other handlers (list, delete, toggle, setlang, help, about) are unchanged
-async def list_accounts_handler(event: events.NewMessage.Event): pass
-async def delete_account_handler(event: events.NewMessage.Event): pass
-async def toggle_account_handler(event: events.NewMessage.Event): pass
-async def set_lang_handler(event: events.NewMessage.Event): pass
-async def help_commands_handler(event: events.NewMessage.Event): pass
-async def about_command_handler(event: events.NewMessage.Event): pass
 
 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()
 
@@ -127,6 +54,9 @@ async def main():
     scheduler.add_job(process_log_queue, 'interval', seconds=LOG_QUEUE_INTERVAL_SECONDS, id='log_queue_job')
     scheduler.start()
 
+    console.print(f"-> [system] - GC scheduled every {GC_INTERVAL_SECONDS} seconds.", style="blue")
+    console.print(f"-> [system] - Log queue processing scheduled every {LOG_QUEUE_INTERVAL_SECONDS} seconds.", style="blue")
+
     await manage_clients()
 
     logger.info("Userbot is running. Press Ctrl+C to stop.")