m1

app.py

@@ -389,6 +389,33 @@ def execute_sql_query(query, db_connection):
     except Exception as e:
         return f"Error ejecutando la consulta: {str(e)}"
 
+def parse_markdown_table(markdown_text: str) -> Optional[List[Dict[str, Any]]]:
+    """Parse a GitHub-style markdown table string to a list of dicts.
+
+    Returns None if parsing fails or no rows are found.
+    """
+    if not isinstance(markdown_text, str):
+        return None
+    try:
+        # Keep only table lines with pipes and drop the separator row
+        lines = [
+            line.strip() for line in markdown_text.split('\n')
+            if line.strip() and '|' in line and set(line.strip()) != {'-','|',':',' '}
+        ]
+        if len(lines) < 2:
+            return None
+        # First line is header
+        columns = [col.strip() for col in lines[0].split('|')[1:-1]]
+        data: List[Dict[str, Any]] = []
+        for line in lines[1:]:
+            values = [val.strip() for val in line.split('|')[1:-1]]
+            if len(values) != len(columns):
+                continue
+            data.append(dict(zip(columns, values)))
+        return data if data else None
+    except Exception:
+        return None
+
 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))
@@ -606,24 +633,18 @@ async def stream_agent_response(question: str, chat_history: List[List[str]]) ->
                             db_connection, _ = setup_database_connection()
                             if db_connection:
                                 query_result = execute_sql_query(sql_query2, db_connection)
-                                # Try to parse table-like text into DataFrame if possible
-                                data = None
-                                if isinstance(query_result, str):
-                                    try:
-                                        import pandas as pd
-                                        df = pd.read_csv(io.StringIO(query_result), sep="|")
-                                        data = df
-                                    except Exception:
-                                        pass
-                                # As a fallback, don't rely on text table; just skip charting here
-                                if data is not None and hasattr(data, "empty") and not data.empty:
-                                    # Heuristics: choose first column as x and second as y if numeric
-                                    x_col = data.columns[0]
-                                    # pick first numeric column different to x
+                                # Append query and result to response_text for transparency
+                                response_text += f"\n\n### 🔍 Resultado de la consulta (2ª pasada):\n```sql\n{sql_query2}\n```\n\n{query_result}"
+                                # Try robust markdown table parse
+                                data_list = parse_markdown_table(query_result) if isinstance(query_result, str) else None
+                                if data_list:
+                                    # Infer columns
+                                    columns = list(data_list[0].keys())
+                                    x_col = columns[0]
                                     y_col = None
-                                    for col in data.columns[1:]:
+                                    for col in columns[1:]:
                                         try:
-                                            pd.to_numeric(data[col])
+                                            pd.to_numeric(data_list[0][col])
                                             y_col = col
                                             break
                                         except Exception:
@@ -631,15 +652,15 @@ async def stream_agent_response(question: str, chat_history: List[List[str]]) ->
                                     if y_col:
                                         desired_type = 'pie' if any(k in q_lower for k in ["gráfico circular", "grafico circular", "pie", "pastel"]) else 'bar'
                                         chart_fig = generate_chart(
-                                            data=data,
+                                            data=data_list,
                                             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("Chart generated from second-pass SQL execution.")
-                                            chart_state = {"data": data, "x_col": x_col, "y_col": y_col, "title": f"{y_col} por {x_col}", "chart_type": desired_type}
+                                            logger.info("Chart generated from second-pass SQL execution (markdown parse).")
+                                            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:
                                 logger.info("No DB connection on second pass; skipping.")
                     except Exception as e:
@@ -662,7 +683,8 @@ async def stream_agent_response(question: str, chat_history: List[List[str]]) ->
                     if not candidate_text and isinstance(response_text, str) and response_text.strip():
                         candidate_text = response_text
                     if candidate_text:
-                        raw_lines = candidate_text.split('\n')
+                        # Support colon-number pairs even when they are in one paragraph
+                        raw_lines = re.split(r"\n|,\s+(?=[^,]+:\s*\d)" , candidate_text)
                         # Normalize lines: strip bullets and markdown symbols
                         norm_lines = []
                         for l in raw_lines: