Initial commit

app.py

@@ -5,7 +5,6 @@
 import os
 import io
 import gc
-import sys
 import time
 import warnings
 import pandas as pd
@@ -16,28 +15,14 @@ from contextlib import redirect_stdout, redirect_stderr
 # CrewAI
 from crewai import Agent, Task, Crew
 
-# === DEBUG INFO - TEMPORAL ===
-print("=== STARTING APP ===")
-print(f"Python version: {sys.version}")
-print(f"OPENAI_API_KEY present: {bool(os.getenv('OPENAI_API_KEY'))}")
-if os.getenv('OPENAI_API_KEY'):
-    key_length = len(os.getenv('OPENAI_API_KEY'))
-    key_start = os.getenv('OPENAI_API_KEY')[:10]
-    print(f"API key length: {key_length}")
-    print(f"API key starts with: {key_start}...")
-else:
-    print("API key is None or empty")
-print("=== DEBUG END ===")
-
 # --- Configuración de entorno ---
+# IMPORTANTE: En HuggingFace Spaces, las variables de entorno se configuran en la interfaz web
+# NO pongas tu API key directamente en el código
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 if not OPENAI_API_KEY:
-    print("WARNING: OPENAI_API_KEY not found!")
-    # Para HuggingFace, esto puede ser normal durante el build
-else:
-    os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
-    print(f"API key configured successfully")
+    raise ValueError("OPENAI_API_KEY environment variable is required")
 
+os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
 os.environ["USER_AGENT"] = os.getenv("USER_AGENT", "ConsensusApp")
 os.environ['CREWAI_DO_NOT_TELEMETRY'] = 'true'
 os.environ['CREWAI_SHARE_CREW'] = 'false'
@@ -45,12 +30,12 @@ os.environ['CREWAI_SHARE_CREW'] = 'false'
 # Suprimir warnings ruidosos
 warnings.filterwarnings("ignore", category=UserWarning, module="crewai")
 warnings.filterwarnings("ignore", category=DeprecationWarning)
-warnings.filterwarnings("ignore", category=FutureWarning)
 
 # =========================
 # Datos base y utilidades
 # =========================
 
+# Mapeo de partidos políticos a orientaciones
 PARTY_TO_ORIENTATION = {
     "FDP": "RIGHT", "jf": "RIGHT", "CVP": "CENTER", "Grüne": "LEFT", "SVP": "RIGHT",
     "PdA": "LEFT", "SP": "LEFT", "glp": "CENTER", "JUSO": "LEFT", "BDP": "CENTER",
@@ -59,11 +44,19 @@ PARTY_TO_ORIENTATION = {
     "JBDP": "CENTER", "Die": "CENTER", "JFS": "RIGHT", "SD": "RIGHT", "JM": "CENTER"
 }
 
+# Modelos por nivel
 LLM_BASE = "gpt-4o-mini"
 LLM_SUPERVISOR = "gpt-4o-mini"
 LLM_DIRECTOR = "gpt-4o-mini"
 
 def get_majority_decision_groups(df: pd.DataFrame) -> Dict:
+    """
+    Calcula decisiones por mayoría y porcentajes (FAVOR/AGAINST) por:
+    - language
+    - party_reply
+    - orientación (derivada de party_reply via PARTY_TO_ORIENTATION)
+    - FINAL_MAJORITY global
+    """
     result = {}
 
     def calc_decision_and_percentages(series):
@@ -81,46 +74,30 @@ def get_majority_decision_groups(df: pd.DataFrame) -> Dict:
         return {"decision": decision, "percent_favor": favor_pct, "percent_against": against_pct}
 
     # Por idioma
-    try:
-        for lang, group in df.groupby('language')['label']:
-            result[lang] = calc_decision_and_percentages(group)
-    except Exception as e:
-        print(f"Error processing languages: {e}")
+    for lang, group in df.groupby('language')['label']:
+        result[lang] = calc_decision_and_percentages(group)
 
     # Por partido
-    try:
-        for party, group in df.groupby('party_reply')['label']:
-            result[party] = calc_decision_and_percentages(group)
-    except Exception as e:
-        print(f"Error processing parties: {e}")
+    for party, group in df.groupby('party_reply')['label']:
+        result[party] = calc_decision_and_percentages(group)
 
     # Por orientación
-    try:
-        df_or = df.copy()
-        df_or['orientation'] = df_or['party_reply'].map(PARTY_TO_ORIENTATION)
-        df_or = df_or.dropna(subset=['orientation'])
-        if not df_or.empty:
-            for orient, group in df_or.groupby('orientation')['label']:
-                result[f"{orient}_MAJORITY"] = calc_decision_and_percentages(group)
-    except Exception as e:
-        print(f"Error processing orientations: {e}")
+    df_or = df.copy()
+    df_or['orientation'] = df_or['party_reply'].map(PARTY_TO_ORIENTATION)
+    df_or = df_or.dropna(subset=['orientation'])
+    if not df_or.empty:
+        for orient, group in df_or.groupby('orientation')['label']:
+            result[f"{orient}_MAJORITY"] = calc_decision_and_percentages(group)
 
     # Global
-    try:
-        result['FINAL_MAJORITY'] = calc_decision_and_percentages(df['label'])
-    except Exception as e:
-        print(f"Error processing final majority: {e}")
-        
+    result['FINAL_MAJORITY'] = calc_decision_and_percentages(df['label'])
     return result
 
+# Silenciar salidas ruidosas de CrewAI
 def _silent_kickoff(crew: Crew):
     buf_out, buf_err = io.StringIO(), io.StringIO()
     with redirect_stdout(buf_out), redirect_stderr(buf_err):
-        try:
-            return crew.kickoff()
-        except Exception as e:
-            print(f"Crew kickoff error: {e}")
-            return None
+        return crew.kickoff()
 
 # =========================
 # Sistema Multiagente (CrewAI)
@@ -131,51 +108,42 @@ class DemocraticConsensusCrewAI:
         self.question = question
         self.results = {"base_agents": {}, "supervisors": {}, "director": ""}
 
-        try:
-            self.base_agent = Agent(
-                role="Democratic Base Representative",
-                goal="Generate democratic consensus for any given group of opinions, weighting all perspectives equally.",
-                backstory=("You are a neutral representative. Given any group's opinions and a majority decision, "
-                           "you craft a fair, balanced consensus that aligns with that majority, acknowledging minorities as nuances."),
-                verbose=False,
-                allow_delegation=False,
-                llm=LLM_BASE
-            )
-            self.supervisor_agent = Agent(
-                role="Democratic Supervisor",
-                goal="Refine and consolidate consensuses for a language or an orientation umbrella.",
-                backstory=("You refine base consensuses for a given umbrella (language or orientation), "
-                           "keeping the specified majority as the core, integrating minority views as exceptions."),
-                verbose=False,
-                allow_delegation=False,
-                llm=LLM_SUPERVISOR
-            )
-            self.director_agent = Agent(
-                role="Digital President - Final Decision Maker",
-                goal="Synthesize all supervisor consensuses into a final consensus that aligns with the absolute majority.",
-                backstory=("You aggregate all umbrellas and issue a final democratic position respecting the global majority."),
-                verbose=False,
-                allow_delegation=False,
-                llm=LLM_DIRECTOR
-            )
-        except Exception as e:
-            print(f"Error initializing agents: {e}")
-            # Crear agentes básicos como fallback
-            self.base_agent = None
-            self.supervisor_agent = None  
-            self.director_agent = None
+        # Un agente por nivel
+        self.base_agent = Agent(
+            role="Democratic Base Representative",
+            goal="Generate democratic consensus for any given group of opinions, weighting all perspectives equally.",
+            backstory=("You are a neutral representative. Given any group's opinions and a majority decision, "
+                       "you craft a fair, balanced consensus that aligns with that majority, acknowledging minorities as nuances."),
+            verbose=False,
+            allow_delegation=False,
+            llm=LLM_BASE
+        )
+        self.supervisor_agent = Agent(
+            role="Democratic Supervisor",
+            goal="Refine and consolidate consensuses for a language or an orientation umbrella.",
+            backstory=("You refine base consensuses for a given umbrella (language or orientation), "
+                       "keeping the specified majority as the core, integrating minority views as exceptions."),
+            verbose=False,
+            allow_delegation=False,
+            llm=LLM_SUPERVISOR
+        )
+        self.director_agent = Agent(
+            role="Digital President - Final Decision Maker",
+            goal="Synthesize all supervisor consensuses into a final consensus that aligns with the absolute majority.",
+            backstory=("You aggregate all umbrellas and issue a final democratic position respecting the global majority."),
+            verbose=False,
+            allow_delegation=False,
+            llm=LLM_DIRECTOR
+        )
 
+    # Creación de tareas
     def create_base_tasks(self, large_strings_by_language: Dict, large_strings_by_party: Dict, majorities_decision: Dict):
-        if not self.base_agent:
-            return []
-            
         tasks = []
-        try:
-            # Por idioma
-            for language, opinions_text in large_strings_by_language.items():
-                maj = majorities_decision.get(language, {}).get('decision', 'AMBIGUOUS')
-                t = Task(
-                    description=f"""
+        # Por idioma
+        for language, opinions_text in large_strings_by_language.items():
+            maj = majorities_decision.get(language, {}).get('decision', 'AMBIGUOUS')
+            t = Task(
+                description=f"""
 MANDATORY INSTRUCTION: The consensus you generate MUST be based around the MAJORITY DECISION: {maj}
 
 Analyze the following {language} language opinions to answer the question: '{self.question}'
@@ -190,16 +158,16 @@ CRITICAL REQUIREMENTS:
 
 Return only the final consensus text that supports {maj}.
 """.strip(),
-                    agent=self.base_agent,
-                    expected_output=f"[BASE][LANG={language}][MAJ={maj}]"
-                )
-                tasks.append(t)
+                agent=self.base_agent,
+                expected_output=f"[BASE][LANG={language}][MAJ={maj}]"
+            )
+            tasks.append(t)
 
-            # Por partido
-            for party, opinions_text in large_strings_by_party.items():
-                maj = majorities_decision.get(party, {}).get('decision', 'AMBIGUOUS')
-                t = Task(
-                    description=f"""
+        # Por partido
+        for party, opinions_text in large_strings_by_party.items():
+            maj = majorities_decision.get(party, {}).get('decision', 'AMBIGUOUS')
+            t = Task(
+                description=f"""
 MANDATORY INSTRUCTION: The consensus you generate MUST be based around the MAJORITY DECISION: {maj}
 
 Analyze the following {party} party opinions to answer the question: '{self.question}'
@@ -214,28 +182,21 @@ CRITICAL REQUIREMENTS:
 
 Return only the final consensus text that supports {maj}.
 """.strip(),
-                    agent=self.base_agent,
-                    expected_output=f"[BASE][PARTY={party}][MAJ={maj}]"
-                )
-                tasks.append(t)
-        except Exception as e:
-            print(f"Error creating base tasks: {e}")
-            
+                agent=self.base_agent,
+                expected_output=f"[BASE][PARTY={party}][MAJ={maj}]"
+            )
+            tasks.append(t)
         return tasks
 
     def create_supervisor_tasks(self, base_results: Dict, majorities_decision: Dict):
-        if not self.supervisor_agent:
-            return []
-            
         tasks = []
-        try:
-            # Idiomas
-            for lang in ["German", "French", "Italian"]:
-                key = ('LANGUAGE', lang)
-                if key in base_results:
-                    maj = majorities_decision.get(lang, {}).get('decision', 'AMBIGUOUS')
-                    t = Task(
-                        description=f"""
+        # Idiomas
+        for lang in ["German", "French", "Italian"]:
+            key = ('LANGUAGE', lang)
+            if key in base_results:
+                maj = majorities_decision.get(lang, {}).get('decision', 'AMBIGUOUS')
+                t = Task(
+                    description=f"""
 MANDATORY INSTRUCTION: Your refined consensus MUST be based around the MAJORITY DECISION: {maj}
 
 Refine and consolidate the democratic consensus for {lang} language regarding: '{self.question}'
@@ -249,23 +210,23 @@ CRITICAL REQUIREMENTS:
 
 Return only the refined consensus in English supporting {maj}.
 """.strip(),
-                        agent=self.supervisor_agent,
-                        expected_output=f"[SUPERVISOR][LANG={lang}][MAJ={maj}]"
-                    )
-                    tasks.append(t)
-
-            # Orientaciones (unifica partidos)
-            orientation_consensuses = {"LEFT": [], "CENTER": [], "RIGHT": []}
-            for (kind, name), consensus in base_results.items():
-                if kind == 'PARTY' and name in PARTY_TO_ORIENTATION:
-                    orientation_consensuses[PARTY_TO_ORIENTATION[name]].append(consensus)
-
-            for orientation in ["LEFT", "CENTER", "RIGHT"]:
-                if orientation_consensuses[orientation]:
-                    combined = "\n\n".join([f"Consensus {i+1}: {c}" for i, c in enumerate(orientation_consensuses[orientation], 1)])
-                    maj = majorities_decision.get(f"{orientation}_MAJORITY", {}).get('decision', 'AMBIGUOUS')
-                    t = Task(
-                        description=f"""
+                    agent=self.supervisor_agent,
+                    expected_output=f"[SUPERVISOR][LANG={lang}][MAJ={maj}]"
+                )
+                tasks.append(t)
+
+        # Orientaciones (unifica partidos)
+        orientation_consensuses = {"LEFT": [], "CENTER": [], "RIGHT": []}
+        for (kind, name), consensus in base_results.items():
+            if kind == 'PARTY' and name in PARTY_TO_ORIENTATION:
+                orientation_consensuses[PARTY_TO_ORIENTATION[name]].append(consensus)
+
+        for orientation in ["LEFT", "CENTER", "RIGHT"]:
+            if orientation_consensuses[orientation]:
+                combined = "\n\n".join([f"Consensus {i+1}: {c}" for i, c in enumerate(orientation_consensuses[orientation], 1)])
+                maj = majorities_decision.get(f"{orientation}_MAJORITY", {}).get('decision', 'AMBIGUOUS')
+                t = Task(
+                    description=f"""
 MANDATORY INSTRUCTION: Your unified consensus MUST be based around the MAJORITY DECISION: {maj}
 
 Create a unified democratic consensus for {orientation} orientation regarding: '{self.question}'
@@ -279,24 +240,17 @@ CRITICAL REQUIREMENTS:
 
 Return only the meta-consensus in English supporting {maj}.
 """.strip(),
-                        agent=self.supervisor_agent,
-                        expected_output=f"[SUPERVISOR][ORIENT={orientation}][MAJ={maj}]"
-                    )
-                    tasks.append(t)
-        except Exception as e:
-            print(f"Error creating supervisor tasks: {e}")
-            
+                    agent=self.supervisor_agent,
+                    expected_output=f"[SUPERVISOR][ORIENT={orientation}][MAJ={maj}]"
+                )
+                tasks.append(t)
         return tasks
 
     def create_director_task(self, supervisor_results: Dict, majorities_decision: Dict):
-        if not self.director_agent:
-            return None
-            
-        try:
-            all_consensuses = "\n\n".join([f"{k}: {v}" for k, v in supervisor_results.items()])
-            final_majority = majorities_decision.get('FINAL_MAJORITY', {}).get('decision', 'AMBIGUOUS')
-            t = Task(
-                description=f"""
+        all_consensuses = "\n\n".join([f"{k}: {v}" for k, v in supervisor_results.items()])
+        final_majority = majorities_decision.get('FINAL_MAJORITY', {}).get('decision', 'AMBIGUOUS')
+        t = Task(
+            description=f"""
 SUPREME MANDATORY INSTRUCTION: Your FINAL consensus MUST be based around the ABSOLUTE MAJORITY DECISION: {final_majority}
 
 As Digital President, synthesize the FINAL DEMOCRATIC CONSENSUS for the question: '{self.question}'
@@ -311,82 +265,58 @@ CRITICAL REQUIREMENTS:
 
 Return only the final consensus supporting {final_majority}.
 """.strip(),
-                agent=self.director_agent,
-                expected_output=f"[DIRECTOR][MAJ={final_majority}]"
-            )
-            return t
-        except Exception as e:
-            print(f"Error creating director task: {e}")
-            return None
+            agent=self.director_agent,
+            expected_output=f"[DIRECTOR][MAJ={final_majority}]"
+        )
+        return t
 
     def run_democratic_consensus_system(self, large_strings_by_language: Dict, large_strings_by_party: Dict, majorities_decision: Dict = {}) -> Dict:
-        try:
-            # Nivel 1: Base
-            base_tasks = self.create_base_tasks(large_strings_by_language, large_strings_by_party, majorities_decision)
-            base_results = {}
-            if base_tasks and self.base_agent:
-                base_crew = Crew(agents=[self.base_agent], tasks=base_tasks, verbose=0, share_crew=False)
-                base_out = _silent_kickoff(base_crew)
-                if base_out and hasattr(base_out, 'tasks_output'):
-                    for i, task in enumerate(base_tasks):
-                        raw = base_out.tasks_output[i].raw if i < len(base_out.tasks_output) else ""
-                        tag = task.expected_output
-                        if "[LANG=" in tag:
-                            lang = tag.split("[LANG=")[1].split("]")[0]
-                            base_results[('LANGUAGE', lang)] = raw
-                        elif "[PARTY=" in tag:
-                            party = tag.split("[PARTY=")[1].split("]")[0]
-                            base_results[('PARTY', party)] = raw
-            self.results["base_agents"] = base_results
-
-            # Nivel 2: Supervisor
-            supervisor_tasks = self.create_supervisor_tasks(base_results, majorities_decision)
-            supervisor_results = {}
-            if supervisor_tasks and self.supervisor_agent:
-                sup_crew = Crew(agents=[self.supervisor_agent], tasks=supervisor_tasks, verbose=0, share_crew=False)
-                sup_out = _silent_kickoff(sup_crew)
-                if sup_out and hasattr(sup_out, 'tasks_output'):
-                    for i, task in enumerate(supervisor_tasks):
-                        raw = sup_out.tasks_output[i].raw if i < len(sup_out.tasks_output) else ""
-                        tag = task.expected_output
-                        if "[LANG=" in tag:
-                            lang = tag.split("[LANG=")[1].split("]")[0]
-                            supervisor_results[('LANGUAGE', lang)] = raw
-                        elif "[ORIENT=" in tag:
-                            orient = tag.split("[ORIENT=")[1].split("]")[0]
-                            supervisor_results[('ORIENTATION', orient)] = raw
-            self.results["supervisors"] = supervisor_results
-
-            # Nivel 3: Director
-            director_task = self.create_director_task(supervisor_results, majorities_decision)
-            final_consensus = "No final consensus generated"
-            if director_task and self.director_agent:
-                dir_crew = Crew(agents=[self.director_agent], tasks=[director_task], verbose=0, share_crew=False)
-                dir_out = _silent_kickoff(dir_crew)
-                if dir_out and hasattr(dir_out, 'tasks_output') and dir_out.tasks_output:
-                    final_consensus = dir_out.tasks_output[0].raw
-            self.results["director"] = final_consensus
-
-        except Exception as e:
-            print(f"Error in consensus system: {e}")
-            # Generar resultados de fallback
-            self.results = {
-                "base_agents": {},
-                "supervisors": {
-                    ('LANGUAGE', 'German'): "Error: Unable to generate consensus due to system issues.",
-                    ('LANGUAGE', 'French'): "Error: Unable to generate consensus due to system issues.", 
-                    ('LANGUAGE', 'Italian'): "Error: Unable to generate consensus due to system issues.",
-                    ('ORIENTATION', 'LEFT'): "Error: Unable to generate consensus due to system issues.",
-                    ('ORIENTATION', 'CENTER'): "Error: Unable to generate consensus due to system issues.",
-                    ('ORIENTATION', 'RIGHT'): "Error: Unable to generate consensus due to system issues."
-                },
-                "director": "Error: Unable to generate final consensus due to system issues."
-            }
+        # Nivel 1: Base
+        base_tasks = self.create_base_tasks(large_strings_by_language, large_strings_by_party, majorities_decision)
+        base_results = {}
+        if base_tasks:
+            base_crew = Crew(agents=[self.base_agent], tasks=base_tasks, verbose=0, share_crew=False)
+            base_out = _silent_kickoff(base_crew)
+            for i, task in enumerate(base_tasks):
+                raw = base_out.tasks_output[i].raw if i < len(base_out.tasks_output) else ""
+                tag = task.expected_output
+                if "[LANG=" in tag:
+                    lang = tag.split("[LANG=")[1].split("]")[0]
+                    base_results[('LANGUAGE', lang)] = raw
+                elif "[PARTY=" in tag:
+                    party = tag.split("[PARTY=")[1].split("]")[0]
+                    base_results[('PARTY', party)] = raw
+        self.results["base_agents"] = base_results
+
+        # Nivel 2: Supervisor
+        supervisor_tasks = self.create_supervisor_tasks(base_results, majorities_decision)
+        supervisor_results = {}
+        if supervisor_tasks:
+            sup_crew = Crew(agents=[self.supervisor_agent], tasks=supervisor_tasks, verbose=0, share_crew=False)
+            sup_out = _silent_kickoff(sup_crew)
+            for i, task in enumerate(supervisor_tasks):
+                raw = sup_out.tasks_output[i].raw if i < len(sup_out.tasks_output) else ""
+                tag = task.expected_output
+                if "[LANG=" in tag:
+                    lang = tag.split("[LANG=")[1].split("]")[0]
+                    supervisor_results[('LANGUAGE', lang)] = raw
+                elif "[ORIENT=" in tag:
+                    orient = tag.split("[ORIENT=")[1].split("]")[0]
+                    supervisor_results[('ORIENTATION', orient)] = raw
+        self.results["supervisors"] = supervisor_results
+
+        # Nivel 3: Director
+        director_task = self.create_director_task(supervisor_results, majorities_decision)
+        dir_crew = Crew(agents=[self.director_agent], tasks=[director_task], verbose=0, share_crew=False)
+        dir_out = _silent_kickoff(dir_crew)
+        final_consensus = dir_out.tasks_output[0].raw if dir_out.tasks_output else "No final consensus generated"
+        self.results["director"] = final_consensus
 
         # Limpieza
         gc.collect()
         return self.results
 
+# Wrapper
 def run_democratic_consensus_system(large_strings_by_language: Dict, large_strings_by_party: Dict, question: str = "", majorities_decision: Dict = {}) -> Dict:
     system = DemocraticConsensusCrewAI(question=question)
     return system.run_democratic_consensus_system(large_strings_by_language, large_strings_by_party, majorities_decision)
@@ -396,6 +326,11 @@ def run_democratic_consensus_system(large_strings_by_language: Dict, large_strin
 # =========================
 
 def process_excel_and_generate_consensus(excel_file_path):
+    """
+    Lee el Excel subido, calcula mayorías, corre el sistema de consenso y
+    devuelve los textos + porcentajes para mostrarlos en la UI.
+    Se espera que el Excel tenga: ['language', 'party_reply', 'label', 'comment'].
+    """
     if not excel_file_path:
         return ("Error: No file uploaded", "", "", "", "", "", "", "", "",
                 "", "", "", "", "", "", "")
@@ -411,21 +346,22 @@ def process_excel_and_generate_consensus(excel_file_path):
                     "", "", "", "", "", "", "")
 
         # Extraer pregunta si existe
-        question = "Question not found in Excel"
-        if 'question_y' in df.columns and not df['question_y'].dropna().empty:
+        if 'question_y' in df.columns and df['question_y'].dropna().size:
             question = str(df['question_y'].dropna().iloc[0])
-        elif 'question' in df.columns and not df['question'].dropna().empty:
+        elif 'question' in df.columns and df['question'].dropna().size:
             question = str(df['question'].dropna().iloc[0])
+        else:
+            question = "Question not found in Excel"
 
         # Strings por idioma y partido
         large_strings_by_language = (
             df.groupby("language")["comment"]
-              .apply(lambda g: "'; ".join([f"Opinion {i+1}: '{str(c)}" for i, c in enumerate(g.dropna())]))
+              .apply(lambda g: "'; ".join([f"Opinion {i+1}: '{c}" for i, c in enumerate(g.dropna().astype(str))]))
               .to_dict()
         )
         large_strings_by_party = (
             df.groupby("party_reply")["comment"]
-              .apply(lambda g: "'; ".join([f"Opinion {i+1}: '{str(c)}" for i, c in enumerate(g.dropna())]))
+              .apply(lambda g: "'; ".join([f"Opinion {i+1}: '{c}" for i, c in enumerate(g.dropna().astype(str))]))
               .to_dict()
         )
 
@@ -467,7 +403,6 @@ def process_excel_and_generate_consensus(excel_file_path):
                 left_percentage, center_percentage, right_percentage, final_percentage)
 
     except Exception as e:
-        print(f"Error processing Excel: {e}")
         return (f"Error processing file: {e}", "", "", "", "", "", "", "", "",
                 "", "", "", "", "", "", "")
 
@@ -476,184 +411,168 @@ def process_excel_and_generate_consensus(excel_file_path):
 # =========================
 
 def create_consensus_app():
-    try:
-        demo = gr.Blocks(
-            title="🏛️ Consensus Statements",
-            theme=gr.themes.Default(),
-            css="""
+    with gr.Blocks(
+        title="🏛️ Consensus Statements",
+        theme=gr.themes.Base(),
+        css="""
+/* Estilos de banderas */
 .flag-container { display: flex; justify-content: center; align-items: center; gap: 15px; margin-bottom: 10px; }
 .flag-image { width: 50px; height: auto; border-radius: 5px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+
+/* Estilos de las cajas de consenso */
 .consensus-box { padding: 15px; border-radius: 15px; margin: 10px; min-height: 300px; max-height: 500px;
   overflow-y: auto; word-wrap: break-word; display: flex; align-items: flex-start; justify-content: center;
   text-align: center; font-family: 'Georgia', 'Times New Roman', serif; font-weight: normal; }
 .consensus-box-content { font-size: 1.0em; line-height: 1.4; padding: 5px; width: 100%; }
+
 .consensus-box-german { background: linear-gradient(135deg, #FFB6C1, #FFC0CB); color: #333333; }
 .consensus-box-french { background: linear-gradient(135deg, #E6E6FA, #DDA0DD); color: #333333; }
 .consensus-box-italian { background: linear-gradient(135deg, #F0E68C, #F5DEB3); color: #333333; }
 .consensus-box-left { background: linear-gradient(135deg, #98FB98, #90EE90); color: #333333; }
 .consensus-box-center { background: linear-gradient(135deg, #87CEEB, #B0E0E6); color: #333333; }
 .consensus-box-right { background: linear-gradient(135deg, #FFDAB9, #FFE4B5); color: #333333; }
+
+/* Estilo para la caja del consenso final */
 .final-consensus-box { background: linear-gradient(135deg, #A5D6A7, #66BB6A); color: #333333; padding: 30px; border-radius: 15px;
   margin: 20px 0; box-shadow: 0 6px 10px rgba(0,0,0,0.15); min-height: 150px; max-height: 400px; overflow-y: auto;
   display: flex; align-items: flex-start; justify-content: center; text-align: center; font-family: 'Georgia', 'Times New Roman', serif;
   font-weight: normal; font-size: 1.1em; }
+
 .question-header { background: linear-gradient(135deg, #1e3a5f, #2d5a87); color: white; padding: 15px; border-radius: 10px;
   text-align: center; margin-bottom: 20px; font-family: 'Georgia', 'Times New Roman', serif; font-weight: normal; }
+
 .upload-section { text-align: center; margin: 20px 0; }
 .gradio-container { font-family: 'Georgia', 'Times New Roman', serif; }
+
+/* Botón personalizado */
 .custom-button-color { background-color: #2e8b57 !important; color: #ffffff !important; border-color: #2e8b57 !important; }
 """
-        )
+    ) as demo:
+        # Título y banderas
+        gr.HTML("""
+            <div class="flag-container">
+                <img src="https://upload.wikimedia.org/wikipedia/commons/b/ba/Flag_of_Germany.svg" class="flag-image" alt="German Flag">
+                <img src="https://upload.wikimedia.org/wikipedia/commons/c/c3/Flag_of_France.svg" class="flag-image" alt="French Flag">
+                <img src="https://upload.wikimedia.org/wikipedia/commons/0/03/Flag_of_Italy.svg" class="flag-image" alt="Italian Flag">
+            </div>
+            <h1 style='text-align: center; font-size: 1.8em; margin-bottom: 15px;'>Consensus Statements</h1>
+        """)
+
+        # Carga
+        with gr.Row(elem_classes=["upload-section"]):
+            with gr.Column():
+                excel_input = gr.File(label="📊 UPLOAD EXCEL HERE!", file_types=[".xlsx", ".xls"], type="filepath")
+                process_btn = gr.Button("🚀 Generate Consensus", elem_classes=["custom-button-color"], size="lg")
+
+        status_output = gr.Textbox(label="Status", interactive=False, value="Ready to process Excel file...")
+        question_display = gr.HTML(value='<div class="question-header">Upload an Excel file to see the question here</div>',
+                                   elem_classes=["question-header"])
+
+        # Estado
+        all_data = gr.State()
+
+        # Cajas
+        with gr.Row():
+            with gr.Column():
+                german_output = gr.HTML(
+                    value='<div class="consensus-box-content">Consensus Statement:<br>German-speaking cantons<br><br>Upload Excel file to see results<br><b>SUPPORTING THIS DECISION: --</b></div>',
+                    elem_classes=["consensus-box", "consensus-box-german"]
+                )
+            with gr.Column():
+                french_output = gr.HTML(
+                    value='<div class="consensus-box-content">Consensus Statement:<br>French-speaking cantons<br><br>Upload Excel file to see results<br><b>SUPPORTING THIS DECISION: --</b></div>',
+                    elem_classes=["consensus-box", "consensus-box-french"]
+                )
+            with gr.Column():
+                italian_output = gr.HTML(
+                    value='<div class="consensus-box-content">Consensus Statement:<br>Italian-speaking cantons<br><br>Upload Excel file to see results<br><b>SUPPORTING THIS DECISION: --</b></div>',
+                    elem_classes=["consensus-box", "consensus-box-italian"]
+                )
 
-        with demo:
-            # Título y banderas
-            gr.HTML("""
-                <div class="flag-container">
-                    <img src="https://upload.wikimedia.org/wikipedia/commons/b/ba/Flag_of_Germany.svg" class="flag-image" alt="German Flag">
-                    <img src="https://upload.wikimedia.org/wikipedia/commons/c/c3/Flag_of_France.svg" class="flag-image" alt="French Flag">
-                    <img src="https://upload.wikimedia.org/wikipedia/commons/0/03/Flag_of_Italy.svg" class="flag-image" alt="Italian Flag">
-                </div>
-                <h1 style='text-align: center; font-size: 1.8em; margin-bottom: 15px;'>Consensus Statements</h1>
-            """)
-
-            # Carga
-            with gr.Row(elem_classes=["upload-section"]):
-                with gr.Column():
-                    excel_input = gr.File(label="📊 UPLOAD EXCEL HERE!", file_types=[".xlsx", ".xls"], type="filepath")
-                    process_btn = gr.Button("🚀 Generate Consensus", elem_classes=["custom-button-color"], size="lg")
-
-            status_output = gr.Textbox(label="Status", interactive=False, value="Ready to process Excel file...")
-            question_display = gr.HTML(value='<div class="question-header">Upload an Excel file to see the question here</div>',
-                                       elem_classes=["question-header"])
-
-            # Estado
-            all_data = gr.State()
-
-            # Cajas
-            with gr.Row():
-                with gr.Column():
-                    german_output = gr.HTML(
-                        value='<div class="consensus-box-content">Consensus Statement:<br>German-speaking cantons<br><br>Upload Excel file to see results<br><b>SUPPORTING THIS DECISION: --</b></div>',
-                        elem_classes=["consensus-box", "consensus-box-german"]
-                    )
-                with gr.Column():
-                    french_output = gr.HTML(
-                        value='<div class="consensus-box-content">Consensus Statement:<br>French-speaking cantons<br><br>Upload Excel file to see results<br><b>SUPPORTING THIS DECISION: --</b></div>',
-                        elem_classes=["consensus-box", "consensus-box-french"]
-                    )
-                with gr.Column():
-                    italian_output = gr.HTML(
-                        value='<div class="consensus-box-content">Consensus Statement:<br>Italian-speaking cantons<br><br>Upload Excel file to see results<br><b>SUPPORTING THIS DECISION: --</b></div>',
-                        elem_classes=["consensus-box", "consensus-box-italian"]
-                    )
-
-            with gr.Row():
-                with gr.Column():
-                    left_output = gr.HTML(
-                        value='<div class="consensus-box-content">Consensus Statement:<br>LEFT<br><br>Upload Excel file to see results<br><b>SUPPORTING THIS DECISION: --</b></div>',
-                        elem_classes=["consensus-box", "consensus-box-left"]
-                    )
-                with gr.Column():
-                    center_output = gr.HTML(
-                        value='<div class="consensus-box-content">Consensus Statement:<br>CENTER<br><br>Upload Excel file to see results<br><b>SUPPORTING THIS DECISION: --</b></div>',
-                        elem_classes=["consensus-box", "consensus-box-center"]
-                    )
-                with gr.Column():
-                    right_output = gr.HTML(
-                        value='<div class="consensus-box-content">Consensus Statement:<br>RIGHT<br><br>Upload Excel file to see results<br><b>SUPPORTING THIS DECISION: --</b></div>',
-                        elem_classes=["consensus-box", "consensus-box-right"]
-                    )
-
-            final_output = gr.HTML(
-                value='<div class="consensus-box-content">FINAL - CONSENSUS STATEMENT:<br><br>Upload Excel file to see results<br><b>SUPPORTING THIS DECISION: --</b></div>',
-                elem_classes=["final-consensus-box"]
-            )
+        with gr.Row():
+            with gr.Column():
+                left_output = gr.HTML(
+                    value='<div class="consensus-box-content">Consensus Statement:<br>LEFT<br><br>Upload Excel file to see results<br><b>SUPPORTING THIS DECISION: --</b></div>',
+                    elem_classes=["consensus-box", "consensus-box-left"]
+                )
+            with gr.Column():
+                center_output = gr.HTML(
+                    value='<div class="consensus-box-content">Consensus Statement:<br>CENTER<br><br>Upload Excel file to see results<br><b>SUPPORTING THIS DECISION: --</b></div>',
+                    elem_classes=["consensus-box", "consensus-box-center"]
+                )
+            with gr.Column():
+                right_output = gr.HTML(
+                    value='<div class="consensus-box-content">Consensus Statement:<br>RIGHT<br><br>Upload Excel file to see results<br><b>SUPPORTING THIS DECISION: --</b></div>',
+                    elem_classes=["consensus-box", "consensus-box-right"]
+                )
 
-            # Flujo
-            def process_and_store_data(excel_file_path):
-                data = process_excel_and_generate_consensus(excel_file_path)
-                return data, data
-
-            def update_display(data):
-                if not data:
-                    return ("Error processing file", "", "", "", "", "", "", "", "")
-                (status, question, german, french, italian, left, center, right, final,
-                 german_percentage, french_percentage, italian_percentage,
-                 left_percentage, center_percentage, right_percentage, final_percentage) = data
-
-                question_html = f'<div class="question-header">Question: {question}</div>'
-                german_html = f'<div class="consensus-box-content">Consensus Statement:<br>German-speaking cantons<br><br>{german}<br><b>SUPPORTING THIS DECISION: {german_percentage}</b></div>'
-                french_html = f'<div class="consensus-box-content">Consensus Statement:<br>French-speaking cantons<br><br>{french}<br><b>SUPPORTING THIS DECISION: {french_percentage}</b></div>'
-                italian_html = f'<div class="consensus-box-content">Consensus Statement:<br>Italian-speaking cantons<br><br>{italian}<br><b>SUPPORTING THIS DECISION: {italian_percentage}</b></div>'
-                left_html = f'<div class="consensus-box-content">Consensus Statement:<br>LEFT<br><br>{left}<br><b>SUPPORTING THIS DECISION: {left_percentage}</b></div>'
-                center_html = f'<div class="consensus-box-content">Consensus Statement:<br>CENTER<br><br>{center}<br><b>SUPPORTING THIS DECISION: {center_percentage}</b></div>'
-                right_html = f'<div class="consensus-box-content">Consensus Statement:<br>RIGHT<br><br>{right}<br><b>SUPPORTING THIS DECISION: {right_percentage}</b></div>'
-                final_html = f'<div class="consensus-box-content">FINAL - CONSENSUS STATEMENT:<br><br>{final}<br><b>SUPPORTING THIS DECISION: {final_percentage}</b></div>'
-
-                return (status, question_html, german_html, french_html, italian_html,
-                        left_html, center_html, right_html, final_html)
-
-            # Encadenamiento
-            process_btn.click(
-                fn=process_and_store_data,
-                inputs=[excel_input],
-                outputs=[all_data, all_data]
-            ).then(
-                fn=update_display,
-                inputs=[all_data],
-                outputs=[status_output, question_display, german_output, french_output, italian_output,
-                         left_output, center_output, right_output, final_output]
-            )
+        final_output = gr.HTML(
+            value='<div class="consensus-box-content">FINAL - CONSENSUS STATEMENT:<br><br>Upload Excel file to see results<br><b>SUPPORTING THIS DECISION: --</b></div>',
+            elem_classes=["final-consensus-box"]
+        )
 
-        return demo
-    except Exception as e:
-        print(f"Error creating Gradio app: {e}")
-        # Crear una interfaz de fallback muy simple
-        def simple_interface():
-            return "Error: Unable to create full interface. Please check system configuration."
-        
-        return gr.Interface(
-            fn=simple_interface,
-            inputs=[],
-            outputs="text",
-            title="Consensus App - Error Mode"
+        # Flujo
+        def process_and_store_data(excel_file_path):
+            data = process_excel_and_generate_consensus(excel_file_path)
+            return data, data
+
+        def update_display(data):
+            if not data:
+                return ("Error processing file", "", "", "", "", "", "", "", "")
+            (status, question, german, french, italian, left, center, right, final,
+             german_percentage, french_percentage, italian_percentage,
+             left_percentage, center_percentage, right_percentage, final_percentage) = data
+
+            question_html = f'<div class="question-header">Question: {question}</div>'
+            german_html = f'<div class="consensus-box-content">Consensus Statement:<br>German-speaking cantons<br><br>{german}<br><b>SUPPORTING THIS DECISION: {german_percentage}</b></div>'
+            french_html = f'<div class="consensus-box-content">Consensus Statement:<br>French-speaking cantons<br><br>{french}<br><b>SUPPORTING THIS DECISION: {french_percentage}</b></div>'
+            italian_html = f'<div class="consensus-box-content">Consensus Statement:<br>Italian-speaking cantons<br><br>{italian}<br><b>SUPPORTING THIS DECISION: {italian_percentage}</b></div>'
+            left_html = f'<div class="consensus-box-content">Consensus Statement:<br>LEFT<br><br>{left}<br><b>SUPPORTING THIS DECISION: {left_percentage}</b></div>'
+            center_html = f'<div class="consensus-box-content">Consensus Statement:<br>CENTER<br><br>{center}<br><b>SUPPORTING THIS DECISION: {center_percentage}</b></div>'
+            right_html = f'<div class="consensus-box-content">Consensus Statement:<br>RIGHT<br><br>{right}<br><b>SUPPORTING THIS DECISION: {right_percentage}</b></div>'
+            final_html = f'<div class="consensus-box-content">FINAL - CONSENSUS STATEMENT:<br><br>{final}<br><b>SUPPORTING THIS DECISION: {final_percentage}</b></div>'
+
+            return (status, question_html, german_html, french_html, italian_html,
+                    left_html, center_html, right_html, final_html)
+
+        # Encadenamiento
+        process_btn.click(
+            fn=process_and_store_data,
+            inputs=[excel_input],
+            outputs=[all_data, all_data]
+        ).then(
+            fn=update_display,
+            inputs=[all_data],
+            outputs=[status_output, question_display, german_output, french_output, italian_output,
+                     left_output, center_output, right_output, final_output]
         )
 
+    return demo
+
 # =========================
-# Main - Para HuggingFace Spaces
+# Main - Compatible con local y HuggingFace Spaces
 # =========================
 if __name__ == "__main__":
-    try:
-        print("Creating Gradio app...")
-        app = create_consensus_app()
-        
-        print("Launching app...")
-        # Configuración específica para HuggingFace Spaces
+    app = create_consensus_app()
+    
+    # Detectar si estamos en HuggingFace Spaces o local
+    is_spaces = os.getenv("SPACE_ID") is not None
+    
+    if is_spaces:
+        # Configuración para HuggingFace Spaces
         app.launch(
-            share=False,  # HuggingFace maneja el sharing
-            server_name="0.0.0.0",
-            server_port=7860,
-            debug=False,
-            inbrowser=False,
-            show_error=True,
-            quiet=False
-        )
-    except Exception as e:
-        print(f"Critical error launching app: {e}")
-        # Último recurso: crear interfaz básica
-        def emergency_interface():
-            return f"Application Error: {str(e)}"
-        
-        emergency_app = gr.Interface(
-            fn=emergency_interface,
-            inputs=[],
-            outputs="text", 
-            title="Emergency Mode"
-        )
-        emergency_app.launch(
             share=False,
-            server_name="0.0.0.0", 
+            server_name="0.0.0.0",
             server_port=7860,
             debug=False,
             inbrowser=False
+        )
+    else:
+        # Configuración para desarrollo local
+        app.launch(
+            share=True,
+            server_name="127.0.0.1",  # Solo acceso local
+            server_port=None,  # Gradio encontrará un puerto libre automáticamente
+            debug=True,
+            inbrowser=True
         )

requirements.txt

@@ -1,5 +1,6 @@
-gradio==4.44.0
-pandas>=2.0.0
-openpyxl>=3.1.0
-crewai>=0.28.0,<1.0.0
-openai>=1.0.0,<2.0.0
+crewai==0.201.1
+gradio==5.47.2
+gradio_client==1.13.3
+openai==1.109.1
+openpyxl==3.1.5
+pandas==2.3.2