Revert "mv2"

This reverts commit 0444129cd807943e42ef65bab8724f4cb8f036ff.

app.py

@@ -432,21 +432,8 @@ def execute_sql_query(query, db_connection):
                     lines.append("| " + " | ".join(values) + " |")
                 return "\n".join(lines)
             except Exception:
-                # Formato markdown básico incluso si no hay metadatos de columnas
-                try:
-                    num_cols = len(rows[0]) if rows and hasattr(rows[0], "__len__") else 0
-                    headers = [f"col{i+1}" for i in range(num_cols)] or ["value"]
-                    lines = []
-                    header_line = "| " + " | ".join(headers) + " |"
-                    sep_line = "|" + "|".join([" --- " for _ in headers]) + "|"
-                    lines.append(header_line)
-                    lines.append(sep_line)
-                    for r in rows:
-                        vals = [str(v) for v in (list(r) if hasattr(r, "__iter__") and not isinstance(r, (str, bytes)) else [r])] 
-                        lines.append("| " + " | ".join(vals) + " |")
-                    return "\n".join(lines)
-                except Exception:
-                    return "\n".join([str(row) for row in rows])
+                # Formato simple si algo falla
+                return "\n".join([str(row) for row in rows])
                 
     except Exception as e:
         return f"Error ejecutando la consulta: {str(e)}"
@@ -478,55 +465,6 @@ def parse_markdown_table(markdown_text: str) -> Optional[List[Dict[str, Any]]]:
     except Exception:
         return None
 
-def parse_label_value_pairs(text: str) -> List[Dict[str, Any]]:
-    """Extract generic label-number pairs from free text.
-
-    Supports formats like:
-    - LABEL: 123
-    - LABEL (123)
-    - ('LABEL', 123)
-    Returns a list of {label, value}.
-    """
-    if not isinstance(text, str) or not text.strip():
-        return []
-    pairs: List[Dict[str, Any]] = []
-    lines = [l.strip() for l in text.split('\n') if l.strip()]
-    # 1) Tuple-like: ('LABEL', 123)
-    tuple_re = re.compile(r"\(\s*['\"]?\s*([^'\",()]+?)\s*['\"]?\s*,\s*([0-9][0-9.,]*)\s*\)")
-    # 2) Colon separated: LABEL: 123
-    colon_re = re.compile(r"^(.+?):\s*([0-9][0-9.,]*)$")
-    # 3) Parenthesis after label: LABEL (123)
-    paren_re = re.compile(r"^(.+?)\s*\(\s*([0-9][0-9.,]*)\s*\)$")
-    for l in lines:
-        m = tuple_re.search(l)
-        if m:
-            label = re.sub(r"[*_`]+", "", m.group(1)).strip()
-            try:
-                value = float(m.group(2).replace(',', ''))
-                pairs.append({"label": label, "value": value})
-                continue
-            except Exception:
-                pass
-        m = colon_re.match(l)
-        if m:
-            label = re.sub(r"[*_`]+", "", m.group(1)).strip()
-            try:
-                value = float(m.group(2).replace(',', ''))
-                pairs.append({"label": label, "value": value})
-                continue
-            except Exception:
-                pass
-        m = paren_re.match(l)
-        if m:
-            label = re.sub(r"[*_`]+", "", m.group(1)).strip()
-            try:
-                value = float(m.group(2).replace(',', ''))
-                pairs.append({"label": label, "value": value})
-                continue
-            except Exception:
-                pass
-    return pairs
-
 def generate_plot(data, x_col, y_col, title, x_label, y_label):
     """Generate a plot from data and return the file path."""
     plt.figure(figsize=(10, 6))
@@ -650,48 +588,79 @@ async def stream_agent_response(question: str, chat_history: List[List[str]]) ->
             
             logger.info(f"Extracted response text: {response_text[:200]}...")
             
-            # 1) Try to parse label/number pairs from the agent's answer directly
-            parsed_pairs = parse_label_value_pairs(response_text)
-            q_lower = question.lower()
-            desired_type = 'pie' if any(k in q_lower for k in ["gráfico circular", "grafico circular", "pie", "pastel"]) else 'bar'
-            if chart_fig is None and len(parsed_pairs) >= 2:
-                chart_fig = generate_chart(parsed_pairs, desired_type, 'label', 'value', 'Distribución')
-                if chart_fig is not None:
-                    chart_state = {"data": parsed_pairs, "x_col": "label", "y_col": "value", "title": "Distribución", "chart_type": desired_type}
-
-            # 2) If not, execute any SQL present in the response once and chart it
-            if chart_fig is None:
-                sql_query = extract_sql_query(response_text)
-                if sql_query and looks_like_sql(sql_query):
-                    logger.info(f"Detected SQL query: {sql_query}")
-                    db_connection, _ = setup_database_connection()
-                    if db_connection:
-                        query_result = execute_sql_query(sanitize_sql_query_text(sql_query), db_connection)
-                        response_text += f"\n\n### 🔍 Resultado de la consulta:\n```sql\n{sql_query}\n```\n\n{query_result}"
-                        data_list = parse_markdown_table(query_result) if isinstance(query_result, str) else None
-                        if data_list:
-                            columns = list(data_list[0].keys())
-                            x_col = columns[0]
-                            y_col = None
-                            for col in columns[1:]:
-                                try:
-                                    pd.to_numeric(data_list[0][col])
-                                    y_col = col
-                                    break
-                                except Exception:
-                                    continue
-                            if y_col:
-                                chart_fig = generate_chart(data_list, desired_type, x_col, y_col, f"{y_col} por {x_col}")
-                                if chart_fig is not None:
-                                    chart_state = {"data": data_list, "x_col": x_col, "y_col": y_col, "title": f"{y_col} por {x_col}", "chart_type": desired_type}
-                        else:
-                            tuples = parse_label_value_pairs(str(query_result))
-                            if len(tuples) >= 2:
-                                chart_fig = generate_chart(tuples, desired_type, 'label', 'value', 'Distribución')
-                                if chart_fig is not None:
-                                    chart_state = {"data": tuples, "x_col": "label", "y_col": "value", "title": "Distribución", "chart_type": desired_type}
-                    else:
-                        response_text += "\n\n⚠️ No se pudo conectar a la base de datos para ejecutar la consulta."
+            # Check if the response contains an SQL query and it truly looks like SQL
+            sql_query = extract_sql_query(response_text)
+            if sql_query and looks_like_sql(sql_query):
+                logger.info(f"Detected SQL query: {sql_query}")
+                db_connection, _ = setup_database_connection()
+                if db_connection:
+                    query_result = execute_sql_query(sanitize_sql_query_text(sql_query), db_connection)
+                    
+                    # Add the query and its result to the response
+                    response_text += f"\n\n### 🔍 Resultado de la consulta:\n```sql\n{sql_query}\n```\n\n{query_result}"
+                    
+                    # Try to generate an interactive chart if the result is tabular
+                    try:
+                        if isinstance(query_result, str) and '|' in query_result and '---' in query_result:
+                            # Convert markdown table to DataFrame
+                            
+                            # Clean up the markdown table
+                            lines = [line.strip() for line in query_result.split('\n') 
+                                    if line.strip() and '---' not in line and '|' in line]
+                            if len(lines) > 1:  # At least header + 1 data row
+                                # Get column names from the first line
+                                columns = [col.strip() for col in lines[0].split('|')[1:-1]]
+                                # Get data rows
+                                data = []
+                                for line in lines[1:]:
+                                    values = [val.strip() for val in line.split('|')[1:-1]]
+                                    if len(values) == len(columns):
+                                        data.append(dict(zip(columns, values)))
+                                
+                                if data and len(columns) >= 2:
+                                    # Determine chart type from user's question (supports pie chart)
+                                    q_lower = question.lower()
+                                    if any(k in q_lower for k in ["gráfico circular", "grafico circular", "pie", "pastel"]):
+                                        desired_type = 'pie'
+                                    elif any(k in q_lower for k in ["línea", "linea", "line"]):
+                                        desired_type = 'line'
+                                    elif any(k in q_lower for k in ["dispersión", "dispersion", "scatter"]):
+                                        desired_type = 'scatter'
+                                    elif any(k in q_lower for k in ["histograma", "histogram"]):
+                                        desired_type = 'histogram'
+                                    else:
+                                        desired_type = 'bar'
+
+                                    # Choose x/y columns (assume first is category, second numeric)
+                                    x_col = columns[0]
+                                    # pick first numeric column different to x
+                                    y_col = None
+                                    for col in columns[1:]:
+                                        try:
+                                            pd.to_numeric(data[0][col])
+                                            y_col = col
+                                            break
+                                        except Exception:
+                                            continue
+                                    if y_col:
+                                        chart_fig = generate_chart(
+                                            data=data,
+                                            chart_type=desired_type,
+                                            x=x_col,
+                                            y=y_col,
+                                            title=f"{y_col} por {x_col}"
+                                        )
+                                        if chart_fig is not None:
+                                            logger.info(f"Chart generated from SQL table: type={desired_type}, x={x_col}, y={y_col}, rows={len(data)}")
+                                            chart_state = {"data": data, "x_col": x_col, "y_col": y_col, "title": f"{y_col} por {x_col}", "chart_type": desired_type}
+                    except Exception as e:
+                        logger.error(f"Error generating chart: {str(e)}", exc_info=True)
+                        # Don't fail the whole request if chart generation fails
+                        response_text += "\n\n⚠️ No se pudo generar la visualización de los datos."
+                else:
+                    response_text += "\n\n⚠️ No se pudo conectar a la base de datos para ejecutar la consulta."
+            elif sql_query and not looks_like_sql(sql_query):
+                logger.info("Detected code block but it does not look like SQL; skipping execution.")
 
             # If we still have no chart but the user clearly wants one,
             # try a second pass to get ONLY a SQL query from the agent and execute it.