mv2

app.py

@@ -432,8 +432,21 @@ def execute_sql_query(query, db_connection):
                     lines.append("| " + " | ".join(values) + " |")
                 return "\n".join(lines)
             except Exception:
-                # Formato simple si algo falla
-                return "\n".join([str(row) for row in rows])
+                # 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])
                 
     except Exception as e:
         return f"Error ejecutando la consulta: {str(e)}"
@@ -465,6 +478,55 @@ 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))
@@ -588,79 +650,48 @@ async def stream_agent_response(question: str, chat_history: List[List[str]]) ->
             
             logger.info(f"Extracted response text: {response_text[:200]}...")
             
-            # 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.")
+            # 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."
 
             # 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.