Update main.py

main.py

@@ -1,124 +1,167 @@
 import os
-import requests
 import logging
-import io # Import io for BytesIO
+import asyncio
+from pathlib import Path # For handling file paths robustly
 
 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__)
 
-API_ID = os.environ.get('API_ID')
-API_HASH = os.environ.get('API_HASH')
-BOT_TOKEN = os.environ.get('BOT_TOKEN')
-TEMPLATE_URL = "https://mediaflare.adasin.workers.dev/dl/4AmNTDcYQSPNQS"
+# Retrieve Session String from Hugging Face secrets
+# MUST be set in your Hugging Face Space/Repo secrets settings as SESSION_STRING
+SESSION_STRING = os.environ.get('SESSION_STRING')
 
-# --- Helper Function to Fetch Template (Handles Binary Content) ---
-def fetch_template(url):
-    """Fetches binary content (like an image) from the template URL."""
-    logger.info(f"Fetching template from {url}")
+# Path for storing the template content
+DATA_DIR = Path("data")
+TEMPLATE_FILE_PATH = DATA_DIR / "template_content.txt"
+
+# Global variable to hold the loaded template content
+current_template_content = None
+
+# --- Helper Functions for Template Management ---
+def ensure_data_dir_exists():
+    """Ensures the data directory exists."""
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    logger.info(f"Data directory '{DATA_DIR}' ensured.")
+
+async def load_template_from_file():
+    """Loads template content from the persistent file."""
+    global current_template_content
+    ensure_data_dir_exists()
+    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 # Or a default error message
+    else:
+        logger.info(f"Template file {TEMPLATE_FILE_PATH} not found. No template loaded.")
+        current_template_content = None
+
+async def save_template_to_file(content: str):
+    """Saves template content to the persistent file."""
+    global current_template_content
+    ensure_data_dir_exists()
     try:
-        response = requests.get(url, timeout=10)
-        response.raise_for_status()
-        logger.info(f"Template fetched successfully (Content-Type: {response.headers.get('Content-Type')}).")
-        # Return the raw binary content
-        return response.content
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Error fetching template from {url}: {e}")
-        return None
+        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 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.")
+if not SESSION_STRING:
+    logger.error("SESSION_STRING environment variable not found. Please set it in Hugging Face secrets.")
     exit(1)
 
-try:
-    API_ID = int(API_ID)
-except ValueError:
-    logger.error("API_ID environment variable is not a valid integer.")
-    exit(1)
-
-# Fetch the template image content (bytes)
-template_image_bytes = fetch_template(TEMPLATE_URL)
-if template_image_bytes is None:
-    logger.warning("Proceeding without template image due to fetch error.")
-
-# Initialize the Hydrogram (Pyrogram) client
-# *** Add workdir='.' to explicitly use the current directory for the session file ***
-logger.info("Initializing Hydrogram Client...")
+# Initialize the Hydrogram Client using the session string
+# The name "user_session" is arbitrary when using a session_string,
+# as the session is loaded directly from the string into memory.
+logger.info("Initializing Hydrogram Client with session string...")
 try:
     app = Client(
-        name="my_bot", # Session file will be my_bot.session
-        api_id=API_ID,
-        api_hash=API_HASH,
-        bot_token=BOT_TOKEN,
-        workdir="."  # <--- Explicitly set workdir to the current directory
+        name="user_session", # Name is a placeholder when session_string is used
+        session_string=SESSION_STRING,
+        # workdir="." # workdir is not strictly necessary for session file when session_string is used,
+                      # but good if other client files are ever created.
+                      # The template file path is handled separately.
     )
     logger.info("Hydrogram Client initialized.")
 except Exception as e:
-    # Log the specific exception
     logger.error(f"Failed to initialize Hydrogram Client: {type(e).__name__} - {e}")
     exit(1)
 
+
 # --- Bot Event Handlers ---
-@app.on_message(filters.command("start"))
+@app.on_message(filters.command("start") & filters.private)
 async def start_handler(client: Client, message: Message):
-    """Handler for the /start command. Sends the template image if available."""
+    """Handler for the /start command."""
     sender_name = message.from_user.first_name if message.from_user else "User"
-    sender_id = message.from_user.id if message.from_user else "Unknown ID"
-    logger.info(f"Received /start command from {sender_name} (ID: {sender_id})")
+    logger.info(f"Received /start command from {sender_name} (ID: {message.from_user.id})")
 
-    start_message_caption = f"Hello {sender_name}!" # Caption for the photo
+    welcome_text = f"Hello {sender_name}!\n"
+    welcome_text += "I am ready to manage your template.\n"
+    welcome_text += "Use /settemplate <your text> to set a new template.\n"
+    welcome_text += "Use /gettemplate to view the current template."
 
-    if template_image_bytes:
-        logger.info("Attempting to send template image...")
-        try:
-            # Send the image bytes directly using io.BytesIO
-            await message.reply_photo(
-                photo=io.BytesIO(template_image_bytes),
-                caption=start_message_caption + "\n\nHere's the template image."
-            )
-            logger.info("Template image sent successfully.")
-        except Exception as e:
-            logger.error(f"Failed to send template image: {e}")
-            # Fallback to text message if sending photo fails
-            await message.reply_text(start_message_caption + "\n\n(Could not send the template image due to an error.)")
+    if current_template_content:
+        welcome_text += "\n\nA template is currently set."
     else:
-        # If template wasn't loaded, just send text
-        await message.reply_text(start_message_caption + "\n\n(Could not load the template image.)")
+        welcome_text += "\n\nNo template is currently set."
 
+    await message.reply_text(welcome_text)
 
-@app.on_message(filters.command("help"))
-async def help_handler(client: Client, message: Message):
-    """Handler for the /help command."""
-    sender_id = message.from_user.id if message.from_user else "Unknown ID"
-    logger.info(f"Received /help command from {sender_id}")
-    await message.reply_text(
-        "This is a sample bot (Hydrogram).\nCommands:\n/start - Show welcome message and template image\n/help - Show this help message"
-    )
+@app.on_message(filters.command("settemplate") & filters.private)
+async def set_template_handler(client: Client, message: Message):
+    """Handler for the /settemplate command."""
+    user_id = message.from_user.id
+    logger.info(f"Received /settemplate command from User ID: {user_id}")
 
-# --- Main Execution ---
-if __name__ == '__main__':
-    if template_image_bytes is not None:
-        # Log that we have image bytes, maybe length
-        logger.info(f"Template image content loaded ({len(template_image_bytes)} bytes).")
+    if len(message.command) > 1:
+        new_template = message.text.split(" ", 1)[1].strip() # Get content after "/settemplate "
+        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):
+    """Handler for the /gettemplate command."""
+    user_id = message.from_user.id
+    logger.info(f"Received /gettemplate command from User ID: {user_id}")
+
+    if current_template_content:
+        response_text = f"📜 **Current Template:**\n\n{current_template_content}"
     else:
-        logger.warning("Template image content is not available.")
+        response_text = "ℹ️ No template is currently set. Use `/settemplate <your text>` to set one."
+    await message.reply_text(response_text)
 
-    logger.info("Starting bot...")
+# --- Main Execution ---
+async def main():
+    """Main function to load initial data and start the bot."""
+    await load_template_from_file() # Load any existing template on startup
+
+    logger.info("Attempting to connect and start the bot...")
     try:
-        app.run()
-    except sqlite3.OperationalError as e:
-         # Catch the specific error again if setting workdir didn't help
-         logger.error(f"Caught sqlite3 error during app.run(): {e}. Check filesystem permissions for '.' directory.")
-         # You might try workdir='/data' if '.' doesn't work on HF Spaces specifically
-         logger.error("Consider trying workdir='/data' in Client initialization if '.' is not writable.")
+        await app.start()
+        me = await app.get_me()
+        logger.info(f"Bot started successfully as {me.first_name} (ID: {me.id})")
+        logger.info("Listening for messages...")
+        await asyncio.Event().wait()  # Keep the bot running indefinitely
+    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:
-        # Catch any other exception during startup/runtime
-        logger.error(f"An unexpected error occurred during app.run(): {type(e).__name__} - {e}")
+        logger.error(f"An unexpected error occurred during bot startup or runtime: {type(e).__name__} - {e}", exc_info=True)
     finally:
-        # This might not be reached if app.run() blocks indefinitely,
-        # but good practice if it were to exit cleanly.
-        logger.info("Bot stopped or encountered a fatal error.")
+        if app.is_connected:
+            logger.info("Stopping the bot...")
+            await app.stop()
+            logger.info("Bot stopped.")
+        else:
+            logger.info("Bot was not connected or already stopped.")
+
+if __name__ == '__main__':
+    # Run the main function in the asyncio event loop
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        logger.info("Bot manually interrupted. Exiting...")
+    except Exception as e:
+        logger.critical(f"Critical error in main execution block: {e}", exc_info=True)
+