FIX: Complete DataManager session management

Added missing load_session() method
Added save_session() method for session persistence
Enhanced get_history_list() with error handling
Backward compatibility for different data formats
Robust directory handling (creates if missing)

Status: Session management fully functional with JSON storage

frontend_light.py

@@ -20,7 +20,7 @@ st.set_page_config(
 )
 
 # Configuration
-HF_SPACES_API_URL = "https://your-username-absa-backend.hf.space"  # Update with your HF Space URL
+HF_SPACES_API_URL = "https://huggingface.co/spaces/parthnuwal7/ABSA"  # Update with your HF Space URL
 
 def call_ml_backend(data: Dict) -> Dict:
     """Call the ML backend API on HF Spaces."""

src/utils/data_management.py

@@ -101,26 +101,105 @@ class DataManager:
     
     def get_history_list(self) -> List[Dict[str, Any]]:
         """Get list of all saved dashboard histories."""
-        history_files = [f for f in os.listdir(self.history_path) if f.endswith('.json')]
-        history_list = []
+        try:
+            # Ensure directory exists
+            os.makedirs(self.history_path, exist_ok=True)
+            
+            history_files = [f for f in os.listdir(self.history_path) if f.endswith('.json')]
+            history_list = []
+            
+            for filename in history_files:
+                filepath = os.path.join(self.history_path, filename)
+                try:
+                    with open(filepath, 'r') as f:
+                        history_entry = json.load(f)
+                        
+                        # Handle different data formats for backward compatibility
+                        entry_data = {
+                            'id': history_entry.get('id', filename.replace('.json', '')),
+                            'timestamp': history_entry.get('timestamp', datetime.now().isoformat()),
+                            'total_reviews': 0,
+                            'data_file': filename
+                        }
+                        
+                        # Try to get metadata
+                        if 'metadata' in history_entry:
+                            entry_data['total_reviews'] = history_entry['metadata'].get('total_reviews', 0)
+                            entry_data['data_file'] = history_entry['metadata'].get('data_file', filename)
+                        elif 'summary' in history_entry:
+                            entry_data['total_reviews'] = history_entry['summary'].get('total_reviews', 0)
+                        
+                        history_list.append(entry_data)
+                        
+                except Exception as e:
+                    # Log error but don't break the whole function
+                    print(f"Warning: Error loading history file {filename}: {str(e)}")
+                    continue
+            
+            # Sort by timestamp descending
+            history_list.sort(key=lambda x: x['timestamp'], reverse=True)
+            return history_list
+            
+        except Exception as e:
+            print(f"Error accessing history directory: {str(e)}")
+            return []  # Return empty list instead of failing
+    
+    def get_all_sessions(self) -> List[Dict[str, Any]]:
+        """Get all sessions - alias for get_history_list for backward compatibility."""
+        return self.get_history_list()
+    
+    def load_session(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Load a specific session by ID.
         
-        for filename in history_files:
-            filepath = os.path.join(self.history_path, filename)
+        Args:
+            session_id: Session identifier
+            
+        Returns:
+            Session data if found, None otherwise
+        """
+        # Try loading from history
+        session_data = self.load_dashboard_history(session_id)
+        if session_data:
+            return session_data
+        
+        # Try loading from processed data
+        processed_file = os.path.join(self.processed_path, f"processed_{session_id}.json")
+        if os.path.exists(processed_file):
             try:
-                with open(filepath, 'r') as f:
-                    history_entry = json.load(f)
-                    history_list.append({
-                        'id': history_entry['id'],
-                        'timestamp': history_entry['timestamp'],
-                        'total_reviews': history_entry['metadata']['total_reviews'],
-                        'data_file': history_entry['metadata']['data_file']
-                    })
-            except Exception as e:
-                st.error(f"Error loading history file {filename}: {str(e)}")
+                with open(processed_file, 'r') as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, IOError):
+                return None
         
-        # Sort by timestamp descending
-        history_list.sort(key=lambda x: x['timestamp'], reverse=True)
-        return history_list
+        return None
+    
+    def save_session(self, session_id: str, session_data: Dict[str, Any]) -> bool:
+        """
+        Save session data.
+        
+        Args:
+            session_id: Session identifier
+            session_data: Data to save
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Save to history
+            history_file = os.path.join(self.history_path, f"history_{session_id}.json")
+            
+            # Add metadata
+            session_data['session_id'] = session_id
+            session_data['timestamp'] = datetime.now().isoformat()
+            
+            with open(history_file, 'w') as f:
+                json.dump(session_data, f, cls=CustomJSONEncoder, indent=2)
+            
+            return True
+        except Exception as e:
+            print(f"Error saving session {session_id}: {str(e)}")
+            return False
     
     def load_dashboard_history(self, history_id: str) -> Optional[Dict[str, Any]]:
         """Load specific dashboard history."""