Update main.py

main.py

@@ -14,79 +14,43 @@ logger = logging.getLogger(__name__)
 # Retrieve Session String from Hugging Face secrets
 SESSION_STRING = os.environ.get('SESSION_STRING')
 
-# --- 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
+# --- Storage Path Initialization (Aligned with Dockerfile) ---
+# This name MUST match the directory created in the Dockerfile
+# (either the default in ARG or how you set it in `RUN mkdir -p ./${APP_TEMPLATE_DIR_NAME}`)
+APP_TEMPLATE_SUBDIR_NAME = "app_template_storage"
 TEMPLATE_FILENAME = "user_template_content.txt"
 
-DATA_DIR: Path = None
-TEMPLATE_FILE_PATH: Path = None
+# The data directory is now relative to the WORKDIR (e.g., /app/app_template_storage)
+# This path is prepared by the Dockerfile.
+DATA_DIR = Path(".") / APP_TEMPLATE_SUBDIR_NAME
+TEMPLATE_FILE_PATH = DATA_DIR / TEMPLATE_FILENAME
 
-def initialize_storage_paths():
-    """Tries to find/create a writable directory for the template file."""
-    global DATA_DIR, TEMPLATE_FILE_PATH
+current_template_content = None # Global variable for template
 
-    # 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
+def verify_storage_path_is_writable():
+    """Verifies that the pre-configured DATA_DIR is writable."""
+    try:
+        # The Dockerfile should have created DATA_DIR.
+        # Python's mkdir with exist_ok=True is safe even if it exists.
+        # More importantly, we test if we can write into it.
+        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() # Clean up test file
+        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():
     """Loads template content from the persistent file."""
     global current_template_content
-    if not TEMPLATE_FILE_PATH:
+    if not TEMPLATE_FILE_PATH: # Should not happen if verify_storage_path_is_writable passes
         logger.error("Template file path is not configured. Cannot load template.")
         current_template_content = None
         return
@@ -106,15 +70,12 @@ 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
-    if not TEMPLATE_FILE_PATH:
+    if not TEMPLATE_FILE_PATH: # Should not happen
         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)
-
+        # DATA_DIR.mkdir(parents=True, exist_ok=True) # Dockerfile should handle this.
+                                                    # verify_storage_path_is_writable also calls it.
         with open(TEMPLATE_FILE_PATH, "w", encoding="utf-8") as f:
             f.write(content)
         current_template_content = content
@@ -129,15 +90,15 @@ if not SESSION_STRING:
     logger.error("SESSION_STRING environment variable not found. Please set it in Hugging Face secrets.")
     exit(1)
 
-if not TEMPLATE_FILE_PATH:
-    logger.critical("CRITICAL: Template storage path could not be initialized. The application cannot manage templates. Exiting.")
+# Verify the storage path *before* initializing the client or doing anything else
+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 session string...")
 try:
     app = Client(
-        name="user_session_hgs", # Changed name slightly to avoid old session file conflicts if any
+        name="user_session_hgs_v3", # Slightly new name again
         session_string=SESSION_STRING,
     )
     logger.info("Hydrogram Client initialized.")
@@ -146,13 +107,14 @@ except Exception as e:
     exit(1)
 
 
-# --- Bot Event Handlers (Unchanged from your previous version) ---
+# --- Bot Event Handlers (Unchanged) ---
 @app.on_message(filters.command("start") & filters.private)
 async def start_handler(client: Client, message: Message):
     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 += "Template storage is at: " + str(TEMPLATE_FILE_PATH.resolve()) + "\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:
@@ -187,7 +149,7 @@ async def get_template_handler(client: Client, message: Message):
         response_text = "ℹ️ No template is currently set. Use `/settemplate <your text>` to set one."
     await message.reply_text(response_text)
 
-# --- Main Execution ---
+# --- Main Execution (Unchanged) ---
 async def main():
     await load_template_from_file()
     logger.info("Attempting to connect and start the bot...")
@@ -204,7 +166,7 @@ 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_initialized and app.is_connected: # Check if initialized before checking is_connected
+        if app.is_initialized and app.is_connected:
             logger.info("Stopping the bot...")
             await app.stop()
             logger.info("Bot stopped.")
@@ -216,7 +178,7 @@ if __name__ == '__main__':
         asyncio.run(main())
     except KeyboardInterrupt:
         logger.info("Bot manually interrupted. Exiting...")
-    except SystemExit as e: # Catch explicit exits
+    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)