Update main.py

main.py

@@ -1,7 +1,7 @@
 import os
 import logging
 import asyncio
-from pathlib import Path # For handling file paths robustly
+from pathlib import Path
 
 from hydrogram import Client, filters
 from hydrogram.types import Message
@@ -12,26 +12,85 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(level
 logger = logging.getLogger(__name__)
 
 # 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')
 
-# Path for storing the template content
-DATA_DIR = Path("data")
-TEMPLATE_FILE_PATH = DATA_DIR / "template_content.txt"
+# --- Dynamic Storage Path Initialization ---
+# Define potential base directories for storage and a subdirectory name
+PERSISTENT_STORAGE_CANDIDATES = [
+    Path("/data"),  # Common absolute path for persistent data in containers
+    Path("."),      # Current working directory (e.g., /app if WORKDIR is /app)
+]
+APP_STORAGE_SUBDIR_NAME = "app_template_storage" # Subdirectory to hold our template
+TEMPLATE_FILENAME = "user_template_content.txt"
+
+DATA_DIR: Path = None
+TEMPLATE_FILE_PATH: Path = None
+
+def initialize_storage_paths():
+    """Tries to find/create a writable directory for the template file."""
+    global DATA_DIR, TEMPLATE_FILE_PATH
+
+    # 1. Try creating a subdirectory in candidate locations
+    for base_candidate in PERSISTENT_STORAGE_CANDIDATES:
+        potential_data_dir = base_candidate / APP_STORAGE_SUBDIR_NAME
+        try:
+            potential_data_dir.mkdir(parents=True, exist_ok=True)
+            # Test if we can actually write a dummy file here
+            test_file = potential_data_dir / ".writable_test"
+            with open(test_file, "w") as f:
+                f.write("test")
+            test_file.unlink() # Clean up test file
+
+            DATA_DIR = potential_data_dir
+            TEMPLATE_FILE_PATH = DATA_DIR / TEMPLATE_FILENAME
+            logger.info(f"Successfully established writable data directory: {DATA_DIR}")
+            return
+        except PermissionError:
+            logger.warning(f"Permission denied to create/use directory {potential_data_dir}. Trying next candidate.")
+        except Exception as e:
+            logger.warning(f"Failed to create/use directory {potential_data_dir} due to {type(e).__name__}: {e}. Trying next candidate.")
+
+    # 2. If subdirectory creation failed, try to place the file directly in a candidate base directory
+    logger.warning("Could not create/use a dedicated subdirectory. Attempting to use a base directory directly for the file.")
+    for base_candidate in PERSISTENT_STORAGE_CANDIDATES:
+        potential_template_file_path = base_candidate / TEMPLATE_FILENAME
+        try:
+            # Test writability by trying to open the file in append mode (creates if not exists)
+            with open(potential_template_file_path, 'a'):
+                pass # Just testing if open works without error
+            # If we are here, it means we can probably write the file directly.
+            DATA_DIR = base_candidate # The "data directory" is now the base itself
+            TEMPLATE_FILE_PATH = potential_template_file_path
+            logger.info(f"Using base directory {DATA_DIR.resolve()} directly for template file: {TEMPLATE_FILE_PATH}")
+            return
+        except PermissionError:
+            logger.warning(f"Permission denied to write template file directly in {base_candidate.resolve()}. Trying next candidate.")
+        except Exception as e:
+            logger.warning(f"Failed to write template file in {base_candidate.resolve()} due to {type(e).__name__}: {e}. Trying next candidate.")
+
+    # If all attempts fail
+    logger.error("CRITICAL: Unable to find or create a writable location for the template file.")
+    # Set paths to None to indicate failure; the app might crash or malfunction later.
+    # A more robust solution would be to exit here.
+    DATA_DIR = None
+    TEMPLATE_FILE_PATH = None
+    # Consider exiting: exit("Failed to initialize storage.")
+
+# Call this ONCE at the start of the script
+initialize_storage_paths()
 
 # 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 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:
@@ -39,7 +98,7 @@ async def load_template_from_file():
             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
+            current_template_content = None
     else:
         logger.info(f"Template file {TEMPLATE_FILE_PATH} not found. No template loaded.")
         current_template_content = None
@@ -47,8 +106,15 @@ async def load_template_from_file():
 async def save_template_to_file(content: str):
     """Saves template content to the persistent file."""
     global current_template_content
-    ensure_data_dir_exists()
+    if not TEMPLATE_FILE_PATH:
+        logger.error("Template file path is not configured. Cannot save template.")
+        return False
+
     try:
+        # Ensure the parent directory exists (it should if initialize_storage_paths worked for a subdir)
+        if TEMPLATE_FILE_PATH.parent != Path("."): # Avoid trying to create "." if file is in current dir
+             TEMPLATE_FILE_PATH.parent.mkdir(parents=True, exist_ok=True)
+
         with open(TEMPLATE_FILE_PATH, "w", encoding="utf-8") as f:
             f.write(content)
         current_template_content = content
@@ -63,17 +129,16 @@ if not SESSION_STRING:
     logger.error("SESSION_STRING environment variable not found. Please set it in Hugging Face secrets.")
     exit(1)
 
-# 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.
+if not TEMPLATE_FILE_PATH:
+    logger.critical("CRITICAL: Template storage path could not be initialized. The application cannot manage templates. Exiting.")
+    exit(1)
+
+
 logger.info("Initializing Hydrogram Client with session string...")
 try:
     app = Client(
-        name="user_session", # Name is a placeholder when session_string is used
+        name="user_session_hgs", # Changed name slightly to avoid old session file conflicts if any
         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:
@@ -81,33 +146,27 @@ except Exception as e:
     exit(1)
 
 
-# --- Bot Event Handlers ---
+# --- Bot Event Handlers (Unchanged from your previous version) ---
 @app.on_message(filters.command("start") & filters.private)
 async def start_handler(client: Client, message: Message):
-    """Handler for the /start command."""
     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})")
-
     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 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):
-    """Handler for the /settemplate command."""
     user_id = message.from_user.id
     logger.info(f"Received /settemplate command from User ID: {user_id}")
-
     if len(message.command) > 1:
-        new_template = message.text.split(" ", 1)[1].strip() # Get content after "/settemplate "
+        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!")
@@ -120,10 +179,8 @@ async def set_template_handler(client: Client, message: Message):
 
 @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:
@@ -132,16 +189,14 @@ async def get_template_handler(client: Client, message: Message):
 
 # --- 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
-
+    await load_template_from_file()
     logger.info("Attempting to connect and start the bot...")
     try:
         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
+        await asyncio.Event().wait()
     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:
@@ -149,19 +204,20 @@ async def main():
     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_connected:
+        if app.is_initialized and app.is_connected: # Check if initialized before checking is_connected
             logger.info("Stopping the bot...")
             await app.stop()
             logger.info("Bot stopped.")
         else:
-            logger.info("Bot was not connected or already stopped.")
+            logger.info("Bot was not fully 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 SystemExit as e: # Catch explicit exits
+        logger.info(f"Application exiting with status: {e.code}")
     except Exception as e:
-        logger.critical(f"Critical error in main execution block: {e}", exc_info=True)
+        logger.critical(f"Critical error in main execution block: {type(e).__name__} - {e}", exc_info=True)