Update app.py

app.py

@@ -33,21 +33,9 @@ class DataAnalysisAgent:
         self.task_agent = TaskAgent()
         self.analysis_agent = AnalysisAgent()
 
-        
-        # Visualization configuration
-        self.chart_styles = {
-            'trend_analysis': {'type': 'line', 'color': '#4C72B0'},
-            'clustering': {'type': 'scatter', 'color': '#DD8452'},
-            'distribution': {'type': 'hist', 'color': '#55A868'}
-        }
-
     def preprocess_data(self, data):
-        """Clean and prepare uploaded data"""
-        # Handle missing values
         data = data.dropna(axis=1, how='all')
         data = data.fillna(data.mean(numeric_only=True))
-        
-        # Convert datetime columns
         for col in data.columns:
             if data[col].dtype == 'object':
                 try:
@@ -57,132 +45,96 @@ class DataAnalysisAgent:
         return data
 
     def parse_query(self, query):
-        """Convert natural language to analysis tasks"""
-        # Classify query intent
-        result = self.nlp_pipeline(query)[0]
-        intent = result['label']
-        
-        # Map to analysis tasks
-        task_mapping = {
-            'trend': 'trend_analysis',
-            'cluster': 'clustering',
-            'distribution': 'distribution',
-            'compare': 'comparison'
-        }
-        
-        # Extract parameters using simple rule-based parsing
-        params = {}
-        if 'by' in query:
-            params['group_by'] = query.split('by')[-1].strip()
-        
-        return {
-            'task': task_mapping.get(intent, 'trend_analysis'),
-            'params': params
-        }
+        return self.task_agent.parse_query(query)
 
     def analyze(self, data, task):
-        """Perform data analysis based on task"""
         if task['task'] == 'trend_analysis':
-            # Time series analysis
             group_col = task['params'].get('group_by', data.columns[0])
             return data.groupby(group_col).mean().reset_index()
-            
         elif task['task'] == 'clustering':
-            # Unsupervised clustering
-            numeric_cols = data.select_dtypes(include='number').columns
+            numeric_cols = data.select_dtypes(include=np.number).columns
             kmeans = KMeans(n_clusters=3)
             data['cluster'] = kmeans.fit_predict(data[numeric_cols])
             return data
-            
         elif task['task'] == 'distribution':
-            # Statistical distribution
             return data.describe()
-        
         return data
 
     def visualize(self, data, task):
-        """Generate appropriate visualization"""
-        chart_type = self.chart_styles[task['task']]['type']
-        fig, ax = plt.subplots(figsize=(8, 4))
-        
         try:
-            if chart_type == 'line':
+            fig, ax = plt.subplots(figsize=(8, 4))
+            if task['task'] == 'trend_analysis':
                 data.plot(kind='line', ax=ax, title='Trend Analysis')
-            elif chart_type == 'scatter':
+            elif task['task'] == 'clustering':
                 ax.scatter(data.iloc[:, 0], data.iloc[:, 1], c=data['cluster'])
                 ax.set_title('Cluster Analysis')
-            elif chart_type == 'hist':
-                data.hist(ax=ax, bins=20)
-                ax.set_title('Distribution Analysis')
-                
-            plt.tight_layout()
+            else:
+                data.plot(kind='bar', ax=ax, title='Distribution Analysis')
             
-            # Save to temporary file
+            plt.tight_layout()
             temp_file = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
             plt.savefig(temp_file.name)
             plt.close()
             return temp_file.name
-            
         except Exception as e:
             print(f"Visualization error: {e}")
             return None
 
-    def generate_insights(self, data, task):
-        """Create natural language explanations"""
-        insights = []
-        
-        if task['task'] == 'trend_analysis':
-            max_value = data.iloc[:, -1].max()
-            min_value = data.iloc[:, -1].min()
-            insights.append(
-                f"The data shows peaks up to {max_value:.2f} and lows around {min_value:.2f}"
-            )
-            
-        elif task['task'] == 'clustering':
-            cluster_dist = data['cluster'].value_counts().to_dict()
-            insights.append(
-                f"Data distribution across clusters: {cluster_dist}"
-            )
-            
-        return "\n".join(insights) if insights else "No significant patterns detected"
-
 def process_data(file, query):
-    """Main processing function for Gradio interface"""
     agent = DataAnalysisAgent()
     
     try:
-        # Read uploaded file
+        # Validate CSV file
+        if not file.name.endswith('.csv'):
+            raise ValueError("Please upload a CSV file")
+            
         df = pd.read_csv(file.name)
         df = agent.preprocess_data(df)
         
-        # Process query
         task = agent.parse_query(query)
-        
-        # Perform analysis
         analyzed_data = agent.analyze(df, task)
         
-        # Generate outputs
-        insights = agent.generate_insights(analyzed_data, task)
+        insights = agent.analysis_agent.generate_insights(analyzed_data)
         chart_path = agent.visualize(analyzed_data, task)
         
         return insights, chart_path if chart_path else None
         
     except Exception as e:
-        return f"Error processing data: {str(e)}", None
+        return f"Error: {str(e)}", None
 
-# Gradio Interface
+# Gradio Interface with CSV-specific upload
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# Intelligent Data Analysis Agent (IDAA)")
+    gr.Markdown("""
+    # Intelligent Data Analysis Agent
+    **Upload your CSV file and ask questions about your data**
+    """)
     
     with gr.Row():
         with gr.Column():
-            file_input = gr.File(label="Upload CSV Dataset")
-            query_input = gr.Textbox(label="Ask a question about your data")
-            submit_btn = gr.Button("Analyze")
+            gr.Markdown("## Step 1: Upload your CSV file")
+            file_input = gr.File(
+                label="Select CSV File",
+                file_types=[".csv"],
+                type="filepath"
+            )
+            gr.Markdown("## Step 2: Ask your question")
+            query_input = gr.Textbox(
+                label="Data Question",
+                placeholder="e.g., 'Show sales trends by region'"
+            )
+            submit_btn = gr.Button("Analyze", variant="primary")
             
         with gr.Column():
-            insights_output = gr.Textbox(label="Insights", interactive=False)
-            chart_output = gr.Image(label="Visualization")
+            gr.Markdown("## Analysis Results")
+            insights_output = gr.Textbox(
+                label="Insights",
+                interactive=False,
+                lines=10
+            )
+            chart_output = gr.Image(
+                label="Visualization",
+                show_label=True
+            )
     
     submit_btn.click(
         fn=process_data,
@@ -192,14 +144,14 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
 
     gr.Examples(
         examples=[
-            ["sample_sales_data.csv", "Show sales trends by region"],
-            ["customer_data.csv", "Cluster customers by spending habits"]
+            [["sample_sales_data.csv"], "Show sales trends over time"],
+            [["customer_data.csv"], "Cluster customers by purchase habits"]
         ],
-        fn=process_data,
         inputs=[file_input, query_input],
         outputs=[insights_output, chart_output],
+        fn=process_data,
         cache_examples=False
     )
 
 if __name__ == "__main__":
-    demo.launch(debug=True)
+    demo.queue().launch(debug=True)