Update persistence_manager.py

persistence_manager.py

@@ -48,7 +48,7 @@ class APIConfigManager:
 class HuggingFacePersistenceManager:
     """
     Specialized persistence manager for Hugging Face Spaces
-    Provides multiple layers of data persistence
+    Provides multiple layers of data persistence with robust error handling
     """
     def __init__(self, base_storage_path: str = '/data'):
         """
@@ -57,17 +57,56 @@ class HuggingFacePersistenceManager:
         Args:
             base_storage_path (str): Base path for persistent storage
         """
-        # Ensure base storage path exists
-        self.base_storage_path = base_storage_path
+        # Determine storage path with fallback
+        self.base_storage_path = self._determine_storage_path(base_storage_path)
+        
+        # Create storage structure with error handling
         self._create_storage_structure()
         
         # Setup database connection
         self.db_path = os.path.join(self.base_storage_path, 'book_projects.db')
         self.conn = self._initialize_database()
 
+    def _determine_storage_path(self, preferred_path: str) -> str:
+        """
+        Determine an appropriate storage path with fallback mechanisms
+        
+        Args:
+            preferred_path (str): Preferred storage path
+        
+        Returns:
+            str: A writable storage path
+        """
+        # List of potential fallback paths
+        fallback_paths = [
+            preferred_path,  # Original /data path
+            '/tmp/book_writing_agent',  # Temporary directory
+            os.path.join(os.path.expanduser('~'), '.book_writing_agent'),  # Home directory
+        ]
+        
+        for path in fallback_paths:
+            try:
+                # Try to create directory if it doesn't exist
+                os.makedirs(path, exist_ok=True)
+                
+                # Check if directory is writable
+                test_file = os.path.join(path, '.writetest')
+                with open(test_file, 'w') as f:
+                    f.write('test')
+                os.remove(test_file)
+                
+                st.info(f"Using storage path: {path}")
+                return path
+            except Exception as e:
+                st.warning(f"Could not use path {path}: {e}")
+        
+        # If no path works, raise a critical error
+        raise RuntimeError("Could not find a writable storage location")
+
     def _create_storage_structure(self):
         """
         Create necessary directory structure for persistent storage
+        with comprehensive error handling
         """
         # Directories to create
         directories = [
@@ -80,9 +119,24 @@ class HuggingFacePersistenceManager:
         # Create directories with proper permissions
         for dir_path in directories:
             try:
+                # Use os.makedirs with exist_ok to prevent race conditions
                 os.makedirs(dir_path, exist_ok=True)
-                # Ensure write permissions
-                os.chmod(dir_path, 0o755)
+                
+                # Attempt to set permissions (if possible)
+                try:
+                    os.chmod(dir_path, 0o755)
+                except Exception as perm_error:
+                    # Log but don't fail if chmod is not possible
+                    st.warning(f"Could not set permissions for {dir_path}: {perm_error}")
+                
+                # Verify directory is writable
+                test_file = os.path.join(dir_path, '.writetest')
+                with open(test_file, 'w') as f:
+                    f.write('test')
+                os.remove(test_file)
+            
+            except PermissionError:
+                st.error(f"Permission denied when creating directory {dir_path}")
             except Exception as e:
                 st.error(f"Could not create directory {dir_path}: {e}")
 
@@ -159,35 +213,41 @@ class HuggingFacePersistenceManager:
             }
             
             # Write to JSON file
-            with open(project_file, 'w') as f:
-                json.dump(save_data, f, indent=4)
+            try:
+                with open(project_file, 'w') as f:
+                    json.dump(save_data, f, indent=4)
+            except Exception as json_error:
+                st.error(f"Error saving JSON file: {json_error}")
             
             # Save to SQLite database
             if self.conn:
-                cursor = self.conn.cursor()
-                
-                # Insert or update project
-                cursor.execute('''
-                    INSERT OR REPLACE INTO projects 
-                    (project_id, title, genre, total_chapters) 
-                    VALUES (?, ?, ?, ?)
-                ''', (
-                    project_id, 
-                    save_data.get('title', 'Untitled'),
-                    save_data.get('genre', 'Unspecified'),
-                    save_data.get('total_chapters', 0)
-                ))
-                
-                # Save chapters if exists
-                if 'chapters' in save_data:
-                    for chapter_num, chapter_content in save_data['chapters'].items():
-                        cursor.execute('''
-                            INSERT OR REPLACE INTO chapters 
-                            (project_id, chapter_number, content) 
-                            VALUES (?, ?, ?)
-                        ''', (project_id, chapter_num, chapter_content))
-                
-                self.conn.commit()
+                try:
+                    cursor = self.conn.cursor()
+                    
+                    # Insert or update project
+                    cursor.execute('''
+                        INSERT OR REPLACE INTO projects 
+                        (project_id, title, genre, total_chapters) 
+                        VALUES (?, ?, ?, ?)
+                    ''', (
+                        project_id, 
+                        save_data.get('title', 'Untitled'),
+                        save_data.get('genre', 'Unspecified'),
+                        save_data.get('total_chapters', 0)
+                    ))
+                    
+                    # Save chapters if exists
+                    if 'chapters' in save_data:
+                        for chapter_num, chapter_content in save_data['chapters'].items():
+                            cursor.execute('''
+                                INSERT OR REPLACE INTO chapters 
+                                (project_id, chapter_number, content) 
+                                VALUES (?, ?, ?)
+                            ''', (project_id, chapter_num, chapter_content))
+                    
+                    self.conn.commit()
+                except Exception as db_error:
+                    st.error(f"Error saving to database: {db_error}")
             
             return project_id
         
@@ -214,31 +274,37 @@ class HuggingFacePersistenceManager:
             )
             
             if os.path.exists(project_file):
-                with open(project_file, 'r') as f:
-                    return json.load(f)
+                try:
+                    with open(project_file, 'r') as f:
+                        return json.load(f)
+                except Exception as json_error:
+                    st.error(f"Error reading JSON file: {json_error}")
             
             # Fallback to database
             if self.conn:
-                cursor = self.conn.cursor()
-                
-                # Fetch project details
-                cursor.execute('SELECT * FROM projects WHERE project_id = ?', (project_id,))
-                project = cursor.fetchone()
-                
-                if project:
-                    # Fetch chapters
-                    cursor.execute('SELECT * FROM chapters WHERE project_id = ?', (project_id,))
-                    chapters = cursor.fetchall()
+                try:
+                    cursor = self.conn.cursor()
                     
-                    return {
-                        'project_id': project[0],
-                        'title': project[1],
-                        'genre': project[2],
-                        'total_chapters': project[3],
-                        'chapters': {
-                            chapter[1]: chapter[2] for chapter in chapters
+                    # Fetch project details
+                    cursor.execute('SELECT * FROM projects WHERE project_id = ?', (project_id,))
+                    project = cursor.fetchone()
+                    
+                    if project:
+                        # Fetch chapters
+                        cursor.execute('SELECT * FROM chapters WHERE project_id = ?', (project_id,))
+                        chapters = cursor.fetchall()
+                        
+                        return {
+                            'project_id': project[0],
+                            'title': project[1],
+                            'genre': project[2],
+                            'total_chapters': project[3],
+                            'chapters': {
+                                chapter[1]: chapter[2] for chapter in chapters
+                            }
                         }
-                    }
+                except Exception as db_error:
+                    st.error(f"Error loading from database: {db_error}")
             
             return None
         
@@ -275,21 +341,24 @@ class HuggingFacePersistenceManager:
             
             # Supplement with database entries if available
             if self.conn:
-                cursor = self.conn.cursor()
-                cursor.execute('SELECT project_id, title, last_modified FROM projects')
-                db_projects = cursor.fetchall()
-                
-                # Add any database entries not already in file list
-                db_project_ids = {p[0] for p in db_projects}
-                file_project_ids = {p['project_id'] for p in projects}
-                
-                for db_project in db_projects:
-                    if db_project[0] not in file_project_ids:
-                        projects.append({
-                            'project_id': db_project[0],
-                            'title': db_project[1],
-                            'last_modified': db_project[2]
-                        })
+                try:
+                    cursor = self.conn.cursor()
+                    cursor.execute('SELECT project_id, title, last_modified FROM projects')
+                    db_projects = cursor.fetchall()
+                    
+                    # Add any database entries not already in file list
+                    db_project_ids = {p[0] for p in db_projects}
+                    file_project_ids = {p['project_id'] for p in projects}
+                    
+                    for db_project in db_projects:
+                        if db_project[0] not in file_project_ids:
+                            projects.append({
+                                'project_id': db_project[0],
+                                'title': db_project[1],
+                                'last_modified': db_project[2]
+                            })
+                except Exception as db_error:
+                    st.error(f"Error listing projects from database: {db_error}")
         
         except Exception as e:
             st.error(f"Error listing projects: {e}")
@@ -396,7 +465,10 @@ class ResiliентAPIHandler:
             "Error occurred"
         ]
         
-        return not any(indicator in response for indicator in nonsense_indicators)
+        return not any(indicator in response for response lower case in content
+        ]
+        
+        return not any(indicator.lower() in response.lower() for indicator in nonsense_indicators)
 
 def check_huggingface_storage():
     """
@@ -405,31 +477,108 @@ def check_huggingface_storage():
     Returns:
         Dict with storage verification results
     """
-    # Check /data directory
-    data_dir = '/data'
+    # Check storage paths
+    paths_to_check = ['/data', '/tmp', os.path.expanduser('~')]
+    
+    storage_results = {}
+    
+    for path in paths_to_check:
+        try:
+            # Check if path exists
+            path_exists = os.path.exists(path)
+            
+            storage_results[path] = {
+                'exists': path_exists,
+                'writable': os.access(path, os.W_OK) if path_exists else False,
+                'readable': os.access(path, os.R_OK) if path_exists else False
+            }
+            
+            # Add free space if path exists
+            if path_exists:
+                try:
+                    statvfs = os.statvfs(path)
+                    storage_results[path]['free_space_bytes'] = statvfs.f_frsize * statvfs.f_bavail
+                    storage_results[path]['free_space_mb'] = (statvfs.f_frsize * statvfs.f_bavail) / (1024 * 1024)
+                except Exception:
+                    storage_results[path]['free_space_bytes'] = 0
+                    storage_results[path]['free_space_mb'] = 0
+        
+        except Exception as e:
+            storage_results[path] = {
+                'exists': False,
+                'writable': False,
+                'readable': False,
+                'error': str(e)
+            }
+    
+    return storage_results
+
+def debug_storage_capabilities():
+    """
+    Comprehensive debug function to check storage capabilities
+    Prints detailed information about storage access
+    """
+    import platform
     
-    return {
-        'data_dir_exists': os.path.exists(data_dir),
-        'data_dir_writable': os.access(data_dir, os.W_OK),
-        'data_dir_readable': os.access(data_dir, os.R_OK),
-        'free_space': os.statvfs(data_dir).f_bfree  # Free blocks available
-    }
+    print("Storage Capabilities Debug Report")
+    print("=" * 40)
+    
+    # System Information
+    print(f"Operating System: {platform.system()}")
+    print(f"OS Release: {platform.release()}")
+    print(f"Python Version: {platform.python_version()}")
+    
+    print("\nStorage Path Checks:")
+    print("-" * 20)
+    
+    # Check various potential storage paths
+    paths_to_check = [
+        '/data', 
+        '/tmp', 
+        os.path.expanduser('~'),
+        os.getcwd()
+    ]
+    
+    for path in paths_to_check:
+        print(f"\nPath: {path}")
+        try:
+            # Detailed path analysis
+            print(f"  Exists: {os.path.exists(path)}")
+            print(f"  Is Directory: {os.path.isdir(path)}")
+            print(f"  Readable: {os.access(path, os.R_OK)}")
+            print(f"  Writable: {os.access(path, os.W_OK)}")
+            print(f"  Executable: {os.access(path, os.X_OK)}")
+            
+            # Try creating a test file
+            try:
+                test_file = os.path.join(path, '.storage_test')
+                with open(test_file, 'w') as f:
+                    f.write('storage test')
+                os.remove(test_file)
+                print("  File Creation: SUCCESS")
+            except Exception as file_error:
+                print(f"  File Creation: FAILED - {file_error}")
+        
+        except Exception as e:
+            print(f"  Error checking path: {e}")
 
 def main():
-    # Retrieve API credentials
-    api_credentials = APIConfigManager.get_api_credentials()
+    """
+    Main function to demonstrate storage management capabilities
+    """
+    # Demonstrate storage check
+    storage_capabilities = check_huggingface_storage()
+    print("Storage Capabilities:")
+    print(json.dumps(storage_capabilities, indent=2))
     
-    # Print out configuration (for debugging)
-    print("API Credentials Configuration:")
+    # Run comprehensive debug
+    debug_storage_capabilities()
+    
+    # Demonstrate API configuration
+    api_credentials = APIConfigManager.get_api_credentials()
+    print("\nAPI Credentials:")
     for key in api_credentials:
         print(f"{key}: {'*' * 8 if api_credentials[key] else 'Not Set'}")
-    
-    # Initialize persistence manager
-    persistence_manager = HuggingFacePersistenceManager()
-    
-    # Verify storage capabilities
-    storage_check = check_huggingface_storage()
-    print("Hugging Face Storage Check:", json.dumps(storage_check, indent=2))
 
 if __name__ == "__main__":
     main()