Update app.py

app.py

@@ -5,8 +5,7 @@ import datetime
 import os
 import base64
 from typing import List, Optional, Dict, Any
-import pandas as pd
-import matplotlib.pyplot as plt
+import json
 import io
 
 
@@ -45,60 +44,119 @@ def extract_structured_data(text: str, schema: str) -> str:
 
 @tool
 def data_visualization(data: str, chart_type: str, title: str = "Data Visualization") -> str:
-    """Creates a data visualization from structured data.
+    """Creates a textual representation of data for visualization.
     
     Args:
-        data: JSON string or CSV text with the data to visualize.
-        chart_type: Type of chart to create (bar, line, scatter, pie).
+        data: JSON string with the data to visualize.
+        chart_type: Type of representation to create (summary, table, ascii).
         title: Title for the visualization.
     """
     try:
         # Parse the input data
-        try:
-            # Try parsing as JSON first
-            data_parsed = json.loads(data)
-            df = pd.DataFrame(data_parsed)
-        except:
-            # If not JSON, try as CSV
-            csv_data = io.StringIO(data)
-            df = pd.DataFrame.from_records(pd.read_csv(csv_data))
+        data_parsed = json.loads(data)
         
-        # Create appropriate visualization
-        plt.figure(figsize=(10, 6))
+        # Create appropriate representation
+        result = f"=== {title} ===\n\n"
         
-        if chart_type.lower() == 'bar':
-            df.plot(kind='bar')
-        elif chart_type.lower() == 'line':
-            df.plot(kind='line')
-        elif chart_type.lower() == 'scatter':
-            # Assuming first two columns are x and y
-            columns = df.columns
-            if len(columns) >= 2:
-                plt.scatter(df[columns[0]], df[columns[1]])
+        if chart_type.lower() == 'summary':
+            # Provide summary statistics
+            if isinstance(data_parsed, list):
+                result += f"Number of items: {len(data_parsed)}\n"
+                if len(data_parsed) > 0 and isinstance(data_parsed[0], dict):
+                    keys = data_parsed[0].keys()
+                    result += f"Fields: {', '.join(keys)}\n\n"
+                    
+                    # Try to get numeric values for min/max/avg
+                    for key in keys:
+                        try:
+                            values = [item[key] for item in data_parsed if isinstance(item[key], (int, float))]
+                            if values:
+                                result += f"{key}:\n"
+                                result += f"  Min: {min(values)}\n"
+                                result += f"  Max: {max(values)}\n"
+                                result += f"  Avg: {sum(values)/len(values):.2f}\n\n"
+                        except (KeyError, TypeError):
+                            pass
+            else:
+                result += f"Data summary: {str(data_parsed)[:100]}...\n"
+                
+        elif chart_type.lower() == 'table':
+            # Create ASCII table
+            if isinstance(data_parsed, list) and len(data_parsed) > 0 and isinstance(data_parsed[0], dict):
+                # Get headers
+                headers = list(data_parsed[0].keys())
+                
+                # Calculate column widths
+                col_widths = [len(h) for h in headers]
+                for item in data_parsed:
+                    for i, h in enumerate(headers):
+                        if h in item:
+                            col_widths[i] = max(col_widths[i], len(str(item[h])))
+                
+                # Create header row
+                header_row = " | ".join(h.ljust(col_widths[i]) for i, h in enumerate(headers))
+                separator = "-+-".join("-" * w for w in col_widths)
+                
+                result += header_row + "\n"
+                result += separator + "\n"
+                
+                # Create data rows
+                for item in data_parsed[:10]:  # Limit to 10 rows for readability
+                    row = " | ".join(str(item.get(h, "")).ljust(col_widths[i]) for i, h in enumerate(headers))
+                    result += row + "\n"
+                
+                if len(data_parsed) > 10:
+                    result += f"\n... and {len(data_parsed) - 10} more rows"
             else:
-                return "Need at least two columns for scatter plot"
-        elif chart_type.lower() == 'pie':
-            # Assuming first column is labels, second is values
-            columns = df.columns
-            if len(columns) >= 2:
-                plt.pie(df[columns[1]], labels=df[columns[0]], autopct='%1.1f%%')
+                result += "Data is not in a format suitable for table display"
+                
+        elif chart_type.lower() == 'ascii':
+            # Create simple ASCII chart
+            if isinstance(data_parsed, list):
+                # Try to extract x and y values
+                x_values = []
+                y_values = []
+                
+                # Attempt to detect data structure
+                if len(data_parsed) > 0:
+                    if isinstance(data_parsed[0], dict) and len(data_parsed[0]) >= 2:
+                        # Use first two keys as x and y
+                        keys = list(data_parsed[0].keys())
+                        x_key, y_key = keys[0], keys[1]
+                        
+                        for item in data_parsed:
+                            try:
+                                x_values.append(str(item[x_key]))
+                                y_values.append(float(item[y_key]))
+                            except (KeyError, ValueError, TypeError):
+                                continue
+                    elif isinstance(data_parsed[0], (list, tuple)) and len(data_parsed[0]) >= 2:
+                        # Use first two elements as x and y
+                        for item in data_parsed:
+                            try:
+                                x_values.append(str(item[0]))
+                                y_values.append(float(item[1]))
+                            except (IndexError, ValueError, TypeError):
+                                continue
+                
+                if x_values and y_values:
+                    # Create a simple bar chart
+                    max_y = max(y_values)
+                    scale = 20 / max_y if max_y > 0 else 1
+                    
+                    result += f"Chart scale: Each * represents {1/scale:.2f} units\n\n"
+                    
+                    for i, (x, y) in enumerate(zip(x_values, y_values)):
+                        bar_length = int(y * scale)
+                        result += f"{x.ljust(10)}: {'*' * bar_length} ({y})\n"
+                else:
+                    result += "Could not extract plottable values from the data"
             else:
-                return "Need at least two columns for pie chart"
+                result += "Data is not in a format suitable for ASCII chart display"
         else:
-            return f"Unsupported chart type: {chart_type}"
-        
-        plt.title(title)
-        
-        # Save to bytes buffer
-        buf = io.BytesIO()
-        plt.savefig(buf, format='png')
-        buf.seek(0)
-        
-        # Convert to base64 for embedding in HTML or returning
-        img_str = base64.b64encode(buf.read()).decode('utf-8')
+            return f"Unsupported visualization type: {chart_type}. Use 'summary', 'table', or 'ascii'."
         
-        # Return a reference or small thumbnail
-        return f"Visualization created successfully. Image data (base64): {img_str[:30]}..."
+        return result
     except Exception as e:
         return f"Error creating visualization: {str(e)}"