Update main.py

main.py

@@ -1,103 +1,115 @@
-# main.py
 import os
+import requests
 import logging
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
-
-from hydrogram import Client, idle
-from hydrogram.errors import AuthKeyUnregistered
-
-from config import Config
-import handlers # To access register_handlers
-
-# --- Global Executor ---
-# Defined here so it can be imported by handlers if structured that way,
-# or simply passed/used within main_async_logic.
-# max_workers can be adjusted based on CPU cores or expected load.
-executor = ThreadPoolExecutor(max_workers=(os.cpu_count() or 1) + 4)
-
-
-# --- Logging Setup ---
-def setup_logging():
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(name)s - %(levelname)s - [%(module)s.%(funcName)s:%(lineno)d] - %(message)s',
-    )
-    logging.getLogger("hydrogram").setLevel(logging.WARNING) # Reduce hydrogram verbosity
-    return logging.getLogger(__name__)
-
-logger = setup_logging()
-
-
-# --- Directory and Font Checks ---
-def run_startup_checks():
-    logger.info("Running startup checks...")
-    # Check directories (expected to be created by Dockerfile or COPY . .)
-    if not os.path.isdir(Config.PREDEFINED_TEMPLATES_DIR):
-        logger.error(f"FATAL: Templates directory '{Config.PREDEFINED_TEMPLATES_DIR}' not found or is not a directory in the repository root.")
-        return False
-    if not os.path.isdir(Config.OUTPUT_DIR): # This one is created by Dockerfile if not present
-        logger.info(f"Output directory '{Config.OUTPUT_DIR}' not found, will be created by Dockerfile.")
-        # It's okay if this one is missing initially, Dockerfile handles it.
-        # But templates dir *must* come from repo.
-
-    # Check if templates directory has content (optional but good)
+from telethon import TelegramClient, events
+
+# --- Configuration ---
+# Set up basic logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Retrieve secrets from Hugging Face secrets (environment variables)
+# These MUST be set in your Hugging Face Space/Repo secrets settings
+API_ID = os.environ.get('API_ID')
+API_HASH = os.environ.get('API_HASH')
+BOT_TOKEN = os.environ.get('BOT_TOKEN')
+
+# Your "Permanent Template" URL
+TEMPLATE_URL = "https://mediaflare.adasin.workers.dev/dl/4AmNTDcYQSPNQS"
+
+# --- Helper Function to Fetch Template ---
+def fetch_template(url):
+    """Fetches content from the template URL."""
+    logger.info(f"Fetching template from {url}")
     try:
-        if os.path.isdir(Config.PREDEFINED_TEMPLATES_DIR) and not os.listdir(Config.PREDEFINED_TEMPLATES_DIR):
-            logger.warning(f"Templates directory '{Config.PREDEFINED_TEMPLATES_DIR}' is empty. Predefined templates will not work.")
-    except Exception as e:
-        logger.warning(f"Could not check contents of templates directory: {e}")
-
-
-    logger.info("Required directories check complete.")
-    logger.info(f"Attempting to use font: '{Config.FONT_PATH}' (requires system font access).")
-    return True
-
-# --- Main Application Logic ---
-async def main_async_logic():
-    logger.info("Initializing Hydrogram Bot Client...")
-
-    app = Client(
-        name=Config.SESSION_NAME,
-        api_id=Config.API_ID,
-        api_hash=Config.API_HASH,
-        bot_token=Config.BOT_TOKEN,
-        workdir="/app" # Ensures .session file is stored in /app (writable)
-    )
-
-    handlers.register_handlers(app)
-    logger.info("Message handlers registered.")
-
-    try:
-        logger.info("Starting Hydrogram client (as BOT)...")
-        await app.start()
-        me = await app.get_me()
-        logger.info(f"Successfully started. Bot: {me.first_name} (Username: @{me.username}, ID: {me.id})")
-        logger.info("Bot is up and listening for messages from admins!")
-        await idle()
-    except AuthKeyUnregistered:
-        logger.critical("BOT TOKEN INVALID or REVOKED. Please check your BOT_TOKEN secret in Hugging Face.")
-    except Exception as e:
-        logger.critical(f"Error starting or running Hydrogram client: {e}", exc_info=True)
-    finally:
-        logger.info("Shutting down executor...")
-        executor.shutdown(wait=True)
-        if app.is_initialized and app.is_connected: # Check if client was started
-            logger.info("Stopping Hydrogram client...")
-            await app.stop()
-        logger.info("Shutdown complete.")
-
-if __name__ == "__main__":
-    if not run_startup_checks():
-        logger.critical("Startup checks failed. Exiting.")
-        exit(1)
-
-    try:
-        asyncio.run(main_async_logic())
-    except KeyboardInterrupt:
-        logger.info("Bot stopped by KeyboardInterrupt.")
-    except Exception as e:
-        logger.critical(f"Unhandled exception in main: {e}", exc_info=True)
-    finally:
-        logger.info("Application terminated.")
+        response = requests.get(url, timeout=10) # Added timeout
+        response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)
+        logger.info("Template fetched successfully.")
+        # Assuming the template is text-based. Adjust if it's JSON, binary, etc.
+        return response.text
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error fetching template from {url}: {e}")
+        return None # Return None or a default value if fetching fails
+
+# --- Initialization ---
+# Check if essential secrets are loaded
+if not all([API_ID, API_HASH, BOT_TOKEN]):
+    logger.error("Missing required environment variables (API_ID, API_HASH, BOT_TOKEN). Ensure they are set in Hugging Face secrets.")
+    exit(1) # Exit if secrets are missing
+
+try:
+    # Convert API_ID to integer
+    API_ID = int(API_ID)
+except ValueError:
+    logger.error("API_ID environment variable is not a valid integer.")
+    exit(1)
+
+# Fetch the template content on startup
+template_content = fetch_template(TEMPLATE_URL)
+if template_content is None:
+    logger.warning("Proceeding without template content due to fetch error.")
+    # You might want to exit(1) here or use a default fallback template
+    # template_content = "Default template: An error occurred fetching the primary one."
+
+# Initialize the Telethon client
+# 'bot_session' is the name of the session file that will be created.
+logger.info("Initializing Telegram Client...")
+try:
+    client = TelegramClient('bot_session', API_ID, API_HASH)
+    logger.info("Telegram Client initialized.")
+except Exception as e:
+    logger.error(f"Failed to initialize Telegram Client: {e}")
+    exit(1)
+
+# --- Bot Event Handlers ---
+@client.on(events.NewMessage(pattern='/start'))
+async def start_handler(event):
+    """Handler for the /start command."""
+    sender = await event.get_sender()
+    sender_name = getattr(sender, 'first_name', 'User') # Get sender's first name
+    logger.info(f"Received /start command from {sender_name} (ID: {event.sender_id})")
+
+    # Example of using the fetched template content
+    start_message = f"Hello {sender_name}!\n\n"
+    if template_content:
+        start_message += f"Here's the template content:\n---\n{template_content}\n---"
+    else:
+        start_message += "Could not load the template content."
+
+    await event.reply(start_message)
+
+@client.on(events.NewMessage(pattern='/help'))
+async def help_handler(event):
+    """Handler for the /help command."""
+    logger.info(f"Received /help command from {event.sender_id}")
+    await event.reply("This is a sample bot.\nCommands:\n/start - Show welcome message and template\n/help - Show this help message")
+
+# Add more handlers as needed
+# @client.on(events.NewMessage)
+# async def message_handler(event):
+#     """Handles any other message."""
+#     logger.info(f"Received message from {event.sender_id}: {event.text}")
+#     # Process the message...
+#     # await event.reply(f"You said: {event.text}")
+
+
+# --- Main Execution ---
+async def main():
+    """Main function to start the bot."""
+    if template_content is not None:
+        logger.info("Template Content Loaded:\n" + template_content[:200] + "..." if len(template_content) > 200 else template_content) # Log first 200 chars
+    else:
+        logger.warning("Template content is not available.")
+
+    logger.info("Starting bot...")
+    # Start the client using the bot token
+    await client.start(bot_token=BOT_TOKEN)
+    logger.info("Bot started successfully and listening for messages.")
+    # Keep the client running until disconnected
+    await client.run_until_disconnected()
+    logger.info("Bot stopped.")
+
+if __name__ == '__main__':
+    # Run the main function in the asyncio event loop
+    client.loop.run_until_complete(main())