Implementada estructura modular con controladores y modelos de datos siguiendo la versión local

app.py

@@ -23,6 +23,11 @@ from utils.export_utils import export_to_json, export_to_csv, get_download_link,
 from utils.preprocessing_ui import display_preprocessing_comparison, setup_preprocessing_controls, display_processing_status, get_processing_image, show_preprocessing_ui
 from services.database_service import DatabaseService
 from services.image_service import ImageService
+# Agregamos las importaciones de los módulos de controladores y modelos de datos
+from controllers.ui_controller import UIController
+from controllers.group_analysis_controller import GroupAnalysisController
+from data_models.image_context import ImageContext
+from data_models.context_member import ContextMember
 
 # Definimos funciones básicas de reemplazo para no alterar el código
 def display_image_with_controls(image, caption=None, use_column_width=True, title=None, allow_zoom=False, allow_download=False):

controllers/__init__.py

@@ -0,0 +1 @@
+# Controllers package

controllers/group_analysis_controller.py

@@ -0,0 +1,33 @@
+"""
+Group Analysis Controller Module for EmotionMirror application.
+
+This module contains the GroupAnalysisController class that manages the group analysis
+features of the application.
+"""
+import streamlit as st
+import logging
+from typing import Dict, Any, Optional, List
+import numpy as np
+
+from services.history_service import HistoryService
+
+class GroupAnalysisController:
+    """
+    Controller for managing group analysis of multiple faces.
+    Handles detection, analysis and display of group emotion data.
+    """
+    
+    def __init__(self, history_service=None):
+        """
+        Initialize the group analysis controller.
+        
+        Args:
+            history_service: Optional HistoryService for managing history data
+        """
+        self.history_service = history_service or HistoryService()
+        
+    def run(self):
+        """Run the group analysis controller and handle its operations."""
+        # Group analysis is not required for the immediate issue fix
+        # This is a minimal implementation for module compatibility
+        pass

controllers/ui_controller.py

@@ -0,0 +1,73 @@
+"""
+UI Controller Module for EmotionMirror application.
+
+This module contains the UIController class that manages the user interface components
+and interactions throughout the application.
+"""
+import streamlit as st
+import logging
+from typing import Dict, Any, Optional
+import numpy as np
+from PIL import Image
+import io
+import os
+import base64
+from datetime import datetime
+
+from services.image_service import ImageService
+from services.database_service import DatabaseService
+
+class UIController:
+    """
+    Controller for managing the user interface components of the application.
+    Handles the setup and display of UI elements throughout the app.
+    """
+    
+    def __init__(
+        self, 
+        image_service: Optional[ImageService] = None,
+        database_service: Optional[DatabaseService] = None,
+        config: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Initialize the UI controller with optional service dependencies.
+        
+        Args:
+            image_service: Optional ImageService instance for image processing
+            database_service: Optional service for database operations
+            config: Optional configuration dictionary with app settings
+        """
+        self.image_service = image_service or ImageService()
+        self.database_service = database_service or DatabaseService()
+        self.config = config or {}
+        
+    def setup_image_upload_interface(self):
+        """
+        Set up and display the image upload interface with validation feedback.
+        
+        Returns:
+            The uploaded file object if an image was successfully uploaded and validated
+        """
+        # Create file uploader
+        uploaded_file = st.file_uploader(
+            "Choose an image...", 
+            type=["jpg", "jpeg", "png"], 
+            help="Upload a clear image of a face for analysis."
+        )
+        
+        if uploaded_file is not None:
+            # Validate image file
+            validation_result = self.image_service.validate_image_file(
+                uploaded_file,
+                check_content=True,
+                check_dimensions=True
+            )
+            
+            # If validation failed, show issues
+            if not validation_result["valid"]:
+                st.error("Image validation failed:")
+                for issue in validation_result["issues"]:
+                    st.warning(issue)
+                return None
+        
+        return uploaded_file

data_models/__init__.py

@@ -0,0 +1 @@
+# Data models package

data_models/context_member.py

@@ -0,0 +1,76 @@
+"""
+Context Member Model for EmotionMirror application.
+
+This module defines the ContextMember class that represents
+a member (person) in a group analysis context.
+"""
+from typing import Dict, Any, Optional
+from datetime import datetime
+
+class ContextMember:
+    """
+    Represents a member (person) in a group analysis context.
+    """
+    
+    def __init__(
+        self, 
+        member_id: str,
+        name: Optional[str] = None,
+        face_data: Optional[Dict[str, Any]] = None,
+        emotion_data: Optional[Dict[str, float]] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Initialize a context member.
+        
+        Args:
+            member_id: Unique identifier for the member
+            name: Name of the person if known
+            face_data: Face detection data including coordinates, etc.
+            emotion_data: Emotion analysis results
+            metadata: Additional member metadata
+        """
+        self.member_id = member_id
+        self.name = name or "Unknown"
+        self.face_data = face_data or {}
+        self.emotion_data = emotion_data or {}
+        self.metadata = metadata or {}
+        self.created_at = datetime.now()
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the context member to a dictionary for storage or serialization.
+        
+        Returns:
+            Dictionary representation of the context member
+        """
+        return {
+            "member_id": self.member_id,
+            "name": self.name,
+            "face_data": self.face_data,
+            "emotion_data": self.emotion_data,
+            "metadata": self.metadata,
+            "created_at": self.created_at.isoformat()
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'ContextMember':
+        """
+        Create a context member from a dictionary.
+        
+        Args:
+            data: Dictionary with context member data
+            
+        Returns:
+            A ContextMember instance
+        """
+        instance = cls(
+            member_id=data.get("member_id", ""),
+            name=data.get("name", "Unknown"),
+            face_data=data.get("face_data", {}),
+            emotion_data=data.get("emotion_data", {}),
+            metadata=data.get("metadata", {})
+        )
+        if "created_at" in data:
+            instance.created_at = datetime.fromisoformat(data["created_at"])
+        return instance

data_models/image_context.py

@@ -0,0 +1,66 @@
+"""
+Image Context Model for EmotionMirror application.
+
+This module defines the ImageContext class that represents
+an image analysis context including metadata and results.
+"""
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+class ImageContext:
+    """
+    Represents an image context for analysis including metadata and results.
+    """
+    
+    def __init__(
+        self, 
+        image_id: str,
+        timestamp: Optional[datetime] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        faces: Optional[List[Dict[str, Any]]] = None
+    ):
+        """
+        Initialize an image context.
+        
+        Args:
+            image_id: Unique identifier for the image
+            timestamp: Time when the image was processed
+            metadata: Image metadata like dimensions, format, etc.
+            faces: List of detected faces and their analysis
+        """
+        self.image_id = image_id
+        self.timestamp = timestamp or datetime.now()
+        self.metadata = metadata or {}
+        self.faces = faces or []
+        
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Convert the image context to a dictionary for storage or serialization.
+        
+        Returns:
+            Dictionary representation of the image context
+        """
+        return {
+            "image_id": self.image_id,
+            "timestamp": self.timestamp.isoformat(),
+            "metadata": self.metadata,
+            "faces": self.faces
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'ImageContext':
+        """
+        Create an image context from a dictionary.
+        
+        Args:
+            data: Dictionary with image context data
+            
+        Returns:
+            An ImageContext instance
+        """
+        return cls(
+            image_id=data.get("image_id", ""),
+            timestamp=datetime.fromisoformat(data.get("timestamp", datetime.now().isoformat())),
+            metadata=data.get("metadata", {}),
+            faces=data.get("faces", [])
+        )