import os import logging import asyncio from pathlib import Path from hydrogram import Client, filters from hydrogram.types import Message from hydrogram.errors import SessionPasswordNeeded, PhoneCodeInvalid, PhoneNumberInvalid, PasswordHashInvalid # --- Configuration --- logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) # Retrieve Session String from Hugging Face secrets SESSION_STRING = os.environ.get('SESSION_STRING') # --- Storage Path Initialization (Aligned with Dockerfile) --- # This name MUST match the directory created in the Dockerfile APP_TEMPLATE_SUBDIR_NAME = "app_template_storage" TEMPLATE_FILENAME = "user_template_content.txt" # The data directory is now relative to the WORKDIR (e.g., /app/app_template_storage) DATA_DIR = Path(".") / APP_TEMPLATE_SUBDIR_NAME TEMPLATE_FILE_PATH = DATA_DIR / TEMPLATE_FILENAME current_template_content = None # Global variable for template def verify_storage_path_is_writable(): """Verifies that the pre-configured DATA_DIR is writable.""" try: DATA_DIR.mkdir(parents=True, exist_ok=True) test_file = DATA_DIR / ".writable_test_py" with open(test_file, "w") as f: f.write("test") test_file.unlink() logger.info(f"Successfully verified writable data directory: {DATA_DIR.resolve()}") return True except Exception as e: logger.error(f"CRITICAL: Data directory {DATA_DIR.resolve()} (expected to be created and permissioned by Dockerfile) is not writable or accessible.") logger.error(f"Error details: {type(e).__name__} - {e}") return False # --- Helper Functions for Template Management --- async def load_template_from_file(): global current_template_content if not TEMPLATE_FILE_PATH: logger.error("Template file path is not configured. Cannot load template.") current_template_content = None return if TEMPLATE_FILE_PATH.exists(): try: with open(TEMPLATE_FILE_PATH, "r", encoding="utf-8") as f: current_template_content = f.read() logger.info(f"Template loaded successfully from {TEMPLATE_FILE_PATH}") except Exception as e: logger.error(f"Error loading template from {TEMPLATE_FILE_PATH}: {e}") current_template_content = None else: logger.info(f"Template file {TEMPLATE_FILE_PATH.resolve()} not found. No template loaded.") current_template_content = None async def save_template_to_file(content: str): global current_template_content if not TEMPLATE_FILE_PATH: logger.error("Template file path is not configured. Cannot save template.") return False try: with open(TEMPLATE_FILE_PATH, "w", encoding="utf-8") as f: f.write(content) current_template_content = content logger.info(f"Template saved successfully to {TEMPLATE_FILE_PATH}") return True except Exception as e: logger.error(f"Error saving template to {TEMPLATE_FILE_PATH}: {e}") return False # --- Initialization --- if not SESSION_STRING: logger.error("SESSION_STRING environment variable not found. Please set it in Hugging Face secrets.") exit(1) if not verify_storage_path_is_writable(): logger.critical("Exiting due to storage path issues. Check Dockerfile and permissions.") exit(1) logger.info("Initializing Hydrogram Client with BOT session string...") # Clarified log try: app = Client( name="my_bot_session_v4", # Use a distinct session name session_string=SESSION_STRING, # For bot sessions, api_id and api_hash are not strictly needed here # if they were embedded in the session string (Hydrogram handles this). # However, some older versions or ways of creating session strings might benefit # from having them. If your session string already works, this is fine. ) logger.info("Hydrogram Client initialized.") except Exception as e: logger.error(f"Failed to initialize Hydrogram Client: {type(e).__name__} - {e}") exit(1) # --- Bot Event Handlers --- @app.on_message(filters.command("start") & filters.private) async def start_handler(client: Client, message: Message): # THIS IS THE CRUCIAL DIAGNOSTIC LOG: logger.info(f"!!!!!! START HANDLER TRIGGERED by user {message.from_user.id} in chat {message.chat.id} with text: '{message.text}'") sender_name = message.from_user.first_name if message.from_user else "User" logger.info(f"Received /start command from {sender_name} (ID: {message.from_user.id})") # Original log welcome_text = f"Hello {sender_name}!\n" welcome_text += "I am your template management bot.\n" welcome_text += "Template storage is at: " + str(TEMPLATE_FILE_PATH.resolve()) + "\n" welcome_text += "Use /settemplate to set a new template.\n" welcome_text += "Use /gettemplate to view the current template." if current_template_content: welcome_text += "\n\nA template is currently set." else: welcome_text += "\n\nNo template is currently set." await message.reply_text(welcome_text) @app.on_message(filters.command("settemplate") & filters.private) async def set_template_handler(client: Client, message: Message): logger.info(f"!!!!!! SETTEMPLATE HANDLER TRIGGERED by user {message.from_user.id} in chat {message.chat.id}") user_id = message.from_user.id # Retained for potential future use if len(message.command) > 1: new_template = message.text.split(" ", 1)[1].strip() if new_template: if await save_template_to_file(new_template): await message.reply_text("✅ Template updated successfully!") else: await message.reply_text("❌ Failed to save the template. Please check the logs.") else: await message.reply_text("⚠️ Please provide content for the template. Usage: `/settemplate Your template text here`") else: await message.reply_text("ℹ️ Usage: `/settemplate Your template text here`") @app.on_message(filters.command("gettemplate") & filters.private) async def get_template_handler(client: Client, message: Message): logger.info(f"!!!!!! GETTEMPLATE HANDLER TRIGGERED by user {message.from_user.id} in chat {message.chat.id}") user_id = message.from_user.id # Retained for potential future use if current_template_content: response_text = f"📜 **Current Template:**\n\n{current_template_content}" else: response_text = "ℹ️ No template is currently set. Use `/settemplate ` to set one." await message.reply_text(response_text) # --- Main Execution --- async def main(): await load_template_from_file() logger.info("Attempting to connect and start the bot...") try: await app.start() me = await app.get_me() # For bots, me.username is also useful logger.info(f"Bot started successfully as '{me.first_name}' (ID: {me.id}, Username: @{me.username or 'N/A'})") logger.info("Listening for messages...") await asyncio.Event().wait() # Keep the bot running except (SessionPasswordNeeded, PhoneCodeInvalid, PhoneNumberInvalid, PasswordHashInvalid) as e: logger.error(f"Authorization error: {type(e).__name__} - {e}. Your SESSION_STRING might be invalid or expired.") except ConnectionError as e: logger.error(f"Connection error: {e}. Check your network or Telegram's status.") except Exception as e: logger.error(f"An unexpected error occurred during bot startup or runtime: {type(e).__name__} - {e}", exc_info=True) finally: if app.is_initialized and app.is_connected: logger.info("Stopping the bot...") await app.stop() logger.info("Bot stopped.") else: logger.info("Bot was not fully connected or already stopped.") if __name__ == '__main__': try: asyncio.run(main()) except KeyboardInterrupt: logger.info("Bot manually interrupted. Exiting...") except SystemExit as e: logger.info(f"Application exiting with status: {e.code}") except Exception as e: logger.critical(f"Critical error in main execution block: {type(e).__name__} - {e}", exc_info=True)