Update app.py

app.py

@@ -2,8 +2,8 @@
 Advanced URL & Text Processing Suite - Main Application
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-A sophisticated Gradio interface for URL processing, file manipulation, and QR operations.
-Features a modern, responsive UI with real-time feedback and advanced processing capabilities.
+A sophisticated Gradio interface with URL processing, file manipulation, QR operations,
+and advanced data chat capabilities.
 """
 
 import gradio as gr
@@ -11,14 +11,13 @@ import logging
 import json
 import os
 import sys
+import zipfile
+import pandas as pd
+import numpy as np
 from datetime import datetime
 from pathlib import Path
 from typing import Dict, List, Optional, Union, Any, Tuple
 
-from url_processor import URLProcessor
-from file_processor import FileProcessor
-from qr_processor import QRProcessor
-
 # Configure logging
 logging.basicConfig(
     level=logging.INFO,
@@ -35,391 +34,243 @@ THEME = gr.themes.Soft(
     spacing_size=gr.themes.sizes.spacing_md,
     radius_size=gr.themes.sizes.radius_md,
     text_size=gr.themes.sizes.text_md,
-).set(
-    body_background_fill="*background_fill_secondary",
-    button_primary_background_fill="*primary_500",
-    button_primary_background_fill_hover="*primary_600",
-    button_primary_text_color="white",
-    button_primary_border_color="*primary_500",
-    button_secondary_background_fill="*secondary_500",
-    button_secondary_background_fill_hover="*secondary_600",
-    button_secondary_text_color="white",
-    button_secondary_border_color="*secondary_500",
 )
 
-# Custom CSS for enhanced visual appeal
-CUSTOM_CSS = """
-.container {
-    max-width: 1200px !important;
-    margin: auto !important;
-    padding: 2rem !important;
-}
-
-.header {
-    text-align: center;
-    margin-bottom: 2rem;
-    padding: 1rem;
-    background: linear-gradient(135deg, #6366f1 0%, #2563eb 100%);
-    border-radius: 1rem;
-    color: white;
-}
-
-.status-bar {
-    background: #f8fafc;
-    border-radius: 0.5rem;
-    padding: 0.5rem;
-    margin: 1rem 0;
-    border: 1px solid #e2e8f0;
-}
-
-.success-message {
-    color: #059669;
-    background: #ecfdf5;
-    border: 1px solid #059669;
-    border-radius: 0.5rem;
-    padding: 1rem;
-    margin: 1rem 0;
-}
-
-.error-message {
-    color: #dc2626;
-    background: #fef2f2;
-    border: 1px solid #dc2626;
-    border-radius: 0.5rem;
-    padding: 1rem;
-    margin: 1rem 0;
-}
-
-.tab-nav {
-    background: #f8fafc;
-    border-radius: 0.5rem;
-    padding: 0.5rem;
-    margin-bottom: 1rem;
-}
-
-.tab-nav button {
-    transition: all 0.3s ease;
-}
-
-.tab-nav button:hover {
-    transform: translateY(-1px);
-}
-
-.json-editor {
-    font-family: 'JetBrains Mono', monospace;
-    background: #1e293b;
-    color: #e2e8f0;
-    border-radius: 0.5rem;
-    padding: 1rem;
-}
-
-.file-upload {
-    border: 2px dashed #e2e8f0;
-    border-radius: 1rem;
-    padding: 2rem;
-    text-align: center;
-    transition: all 0.3s ease;
-}
-
-.file-upload:hover {
-    border-color: #6366f1;
-    background: #f8fafc;
-}
-
-@keyframes pulse {
-    0% { transform: scale(1); }
-    50% { transform: scale(1.05); }
-    100% { transform: scale(1); }
-}
-
-.processing {
-    animation: pulse 2s infinite;
-}
-"""
-
-class AdvancedInterface:
-    """Advanced Gradio interface with sophisticated processing capabilities"""
-    
+class DataChatProcessor:
     def __init__(self):
-        """Initialize processors and interface components"""
-        self.url_processor = URLProcessor()
-        self.file_processor = FileProcessor()
-        self.qr_processor = QRProcessor()
-        self.processing_history: List[Dict] = []
+        self.trained_data = {}
+        self.current_dataset = None
         
-    def process_urls(self, urls: str, mode: str) -> Tuple[str, str, str]:
-        """Process URLs with advanced error handling and result formatting"""
+    def process_zip_file(self, file_obj, mode):
         try:
-            # Split and clean URLs
-            url_list = [url.strip() for url in urls.split('\n') if url.strip()]
+            if not file_obj:
+                return "Please upload a ZIP file", []
             
-            if not url_list:
-                return "", "⚠️ No valid URLs provided", ""
+            # Extract ZIP contents
+            with zipfile.ZipFile(file_obj.name, 'r') as zip_ref:
+                temp_dir = Path('temp_data')
+                temp_dir.mkdir(exist_ok=True)
+                zip_ref.extractall(temp_dir)
             
-            # Process URLs
-            results = self.url_processor.process_urls(url_list, mode=mode)
+            # Process based on mode
+            if mode == "TrainedOnData":
+                return self._train_on_data(temp_dir)
+            else:  # TalkAboutData
+                return self._analyze_data(temp_dir)
+                
+        except Exception as e:
+            logger.error(f"Error processing ZIP file: {e}")
+            return f"Error: {str(e)}", []
+    
+    def _train_on_data(self, data_dir):
+        try:
+            datasets = []
+            for file in data_dir.glob('**/*.csv'):
+                df = pd.read_csv(file)
+                datasets.append({
+                    'name': file.name,
+                    'data': df,
+                    'summary': {
+                        'rows': len(df),
+                        'columns': len(df.columns),
+                        'dtypes': df.dtypes.astype(str).to_dict()
+                    }
+                })
             
-            # Format results
-            formatted_results = json.dumps(results, indent=2)
-            summary = self._generate_summary(results)
+            self.trained_data = {
+                'datasets': datasets,
+                'timestamp': datetime.now().isoformat()
+            }
             
-            # Update history
-            self.processing_history.append({
-                'timestamp': datetime.now().isoformat(),
-                'type': 'url_processing',
-                'input_count': len(url_list),
-                'success_count': len([r for r in results if 'error' not in r]),
-                'results': results
-            })
+            summary = f"Trained on {len(datasets)} datasets"
+            messages = [
+                {"role": "assistant", "content": "Training completed successfully."},
+                {"role": "assistant", "content": summary}
+            ]
             
-            return formatted_results, f"✅ Successfully processed {len(url_list)} URLs", summary
+            return summary, messages
             
         except Exception as e:
-            logger.error(f"URL processing error: {e}", exc_info=True)
-            return "", f"❌ Error: {str(e)}", ""
-
-    def process_file(self, file: gr.File) -> Tuple[str, str, Optional[Path]]:
-        """Process uploaded file with comprehensive error handling"""
+            logger.error(f"Error training on data: {e}")
+            return f"Error during training: {str(e)}", []
+    
+    def _analyze_data(self, data_dir):
         try:
-            if not file:
-                return "", "⚠️ No file provided", None
+            analyses = []
+            for file in data_dir.glob('**/*.csv'):
+                df = pd.read_csv(file)
+                analyses.append({
+                    'file': file.name,
+                    'shape': df.shape,
+                    'dtypes': df.dtypes.astype(str).to_dict()
+                })
             
-            results = self.file_processor.process_file(file)
+            self.current_dataset = {
+                'analyses': analyses,
+                'timestamp': datetime.now().isoformat()
+            }
             
-            # Generate output file
-            output_path = Path('processed_output.json')
-            with open(output_path, 'w') as f:
-                json.dump(results, f, indent=2)
+            summary = f"Analyzed {len(analyses)} files"
+            messages = [
+                {"role": "assistant", "content": "Analysis completed successfully."},
+                {"role": "assistant", "content": summary}
+            ]
             
-            # Update history
-            self.processing_history.append({
-                'timestamp': datetime.now().isoformat(),
-                'type': 'file_processing',
-                'filename': file.name,
-                'results': results
-            })
-            
-            return (
-                json.dumps(results, indent=2),
-                f"✅ Successfully processed {file.name}",
-                output_path
-            )
+            return summary, messages
             
         except Exception as e:
-            logger.error(f"File processing error: {e}", exc_info=True)
-            return "", f"❌ Error: {str(e)}", None
-
-    def generate_qr(self, data: str, size: int = 10) -> Tuple[Optional[Path], str]:
-        """Generate QR code with advanced options"""
+            logger.error(f"Error analyzing data: {e}")
+            return f"Error during analysis: {str(e)}", []
+    
+    def chat(self, message, history, mode):
+        if not message:
+            return "", history
+        
+        history.append({"role": "user", "content": message})
+        
         try:
-            if not data:
-                return None, "⚠️ No data provided"
-            
-            result = self.qr_processor.generate_qr_code(data, size=size)
-            
-            if 'error' in result:
-                return None, f"❌ Error: {result['error']}"
-            
-            # Update history
-            self.processing_history.append({
-                'timestamp': datetime.now().isoformat(),
-                'type': 'qr_generation',
-                'data_length': len(data),
-                'output_path': result['output_path']
-            })
+            if mode == "TrainedOnData":
+                if not self.trained_data:
+                    response = "Please upload and train on data first."
+                else:
+                    response = self._generate_trained_response(message)
+            else:
+                if not self.current_dataset:
+                    response = "Please upload data for analysis first."
+                else:
+                    response = self._generate_analysis_response(message)
             
-            return result['output_path'], "✅ QR code generated successfully"
+            history.append({"role": "assistant", "content": response})
+            return "", history
             
         except Exception as e:
-            logger.error(f"QR generation error: {e}", exc_info=True)
-            return None, f"❌ Error: {str(e)}"
-
-    def _generate_summary(self, results: List[Dict]) -> str:
-        """Generate a human-readable summary of processing results"""
-        success_count = len([r for r in results if 'error' not in r])
-        error_count = len(results) - success_count
+            logger.error(f"Error in chat: {e}")
+            history.append({"role": "assistant", "content": f"Error: {str(e)}"})
+            return "", history
+    
+    def _generate_trained_response(self, message):
+        datasets = self.trained_data['datasets']
         
-        summary = [
-            "📊 Processing Summary",
-            f"Total URLs: {len(results)}",
-            f"Successful: {success_count}",
-            f"Failed: {error_count}",
-            "",
-            "🔍 Details:"
-        ]
+        if "how many" in message.lower():
+            return f"There are {len(datasets)} datasets."
         
-        for result in results:
-            if 'error' in result:
-                summary.append(f"❌ {result['url']}: {result['error']}")
-            else:
-                summary.append(f"✅ {result['url']}: Successfully processed")
+        if "summary" in message.lower():
+            summaries = []
+            for ds in datasets:
+                summaries.append(
+                    f"Dataset '{ds['name']}': {ds['summary']['rows']} rows, "
+                    f"{ds['summary']['columns']} columns"
+                )
+            return "\n".join(summaries)
         
-        return '\n'.join(summary)
+        return "I can help you analyze the trained datasets. Ask about number of datasets or summaries."
+    
+    def _generate_analysis_response(self, message):
+        analyses = self.current_dataset['analyses']
+        
+        if "how many" in message.lower():
+            return f"There are {len(analyses)} files."
+        
+        if "summary" in message.lower():
+            summaries = []
+            for analysis in analyses:
+                summaries.append(
+                    f"File '{analysis['file']}': {analysis['shape'][0]} rows, "
+                    f"{analysis['shape'][1]} columns"
+                )
+            return "\n".join(summaries)
+        
+        return "I can help you explore the current dataset. Ask about file count or summaries."
 
-    def create_interface(self) -> gr.Blocks:
-        """Create a sophisticated Gradio interface"""
+def create_interface():
+    data_chat = DataChatProcessor()
+    
+    with gr.Blocks(theme=THEME) as interface:
+        gr.Markdown(
+            """
+            # 🌐 Advanced Data Processing & Analysis Suite
+            Enterprise-grade toolkit for data processing, analysis, and interactive chat capabilities.
+            """
+        )
         
-        with gr.Blocks(theme=THEME, css=CUSTOM_CSS) as interface:
-            # Header
-            gr.Markdown(
-                """
-                <div class="header">
-                    <h1>🌐 Advanced URL & Text Processing Suite</h1>
-                    <p>Enterprise-grade toolkit for URL processing, file manipulation, and QR operations</p>
-                </div>
-                """
-            )
-            
-            # Main tabs
-            with gr.Tabs(elem_classes="tab-nav") as tabs:
-                # URL Processing Tab
-                with gr.Tab("🔗 URL Processing", id=1):
-                    with gr.Row():
-                        with gr.Column(scale=2):
-                            url_input = gr.Textbox(
-                                label="URLs",
-                                placeholder="Enter URLs (one per line)",
-                                lines=5
-                            )
-                            mode = gr.Radio(
-                                choices=["basic", "interactive", "deep"],
-                                value="basic",
-                                label="Processing Mode"
-                            )
-                            process_btn = gr.Button("🚀 Process URLs", variant="primary")
-                        
-                        with gr.Column(scale=1):
-                            gr.Markdown(
-                                """
-                                ### 📝 Instructions
-                                1. Enter URLs (one per line)
-                                2. Select processing mode:
-                                   - Basic: Simple content fetch
-                                   - Interactive: Handle dynamic content
-                                   - Deep: Follow links and analyze deeply
-                                3. Click Process to start
-                                """
-                            )
+        with gr.Tab("💬 DataChat"):
+            with gr.Row():
+                # Left column for file upload and mode selection
+                with gr.Column(scale=1):
+                    data_file = gr.File(
+                        label="Upload ZIP File",
+                        file_types=[".zip"]
+                    )
                     
-                    with gr.Row():
-                        status_output = gr.Textbox(label="Status", interactive=False)
-                        clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+                    mode = gr.Radio(
+                        choices=["TrainedOnData", "TalkAboutData"],
+                        value="TrainedOnData",
+                        label="Chat Mode"
+                    )
+                    
+                    process_btn = gr.Button("Process Data", variant="primary")
                     
-                    with gr.Accordion("Results", open=False):
-                        json_output = gr.JSON(label="Detailed Results")
-                        summary_output = gr.Textbox(
-                            label="Summary",
-                            interactive=False,
-                            lines=10
-                        )
+                    status_output = gr.Textbox(
+                        label="Status",
+                        interactive=False
+                    )
                 
-                # File Processing Tab
-                with gr.Tab("📁 File Processing", id=2):
-                    with gr.Row():
-                        with gr.Column(scale=2):
-                            file_input = gr.File(
-                                label="Upload File",
-                                file_types=[".txt", ".pdf", ".zip", ".tar.gz"]
-                            )
-                            process_file_btn = gr.Button("📥 Process File", variant="primary")
-                        
-                        with gr.Column(scale=1):
-                            gr.Markdown(
-                                """
-                                ### 📝 Supported Formats
-                                - Text files (.txt)
-                                - PDF documents (.pdf)
-                                - Archives (.zip, .tar.gz)
-                                - Images (.jpg, .png)
-                                - And more...
-                                """
-                            )
+                # Right column for chat interface
+                with gr.Column(scale=2):
+                    chatbot = gr.Chatbot(
+                        label="Chat History",
+                        height=400,
+                        show_label=True,
+                        type="messages"  # Specify OpenAI-style message format
+                    )
                     
-                    with gr.Row():
-                        file_status = gr.Textbox(label="Status", interactive=False)
-                        file_output = gr.File(label="Processed Output")
+                    msg = gr.Textbox(
+                        label="Your Message",
+                        placeholder="Ask questions about your data...",
+                        lines=2
+                    )
                     
-                    with gr.Accordion("Results", open=False):
-                        file_json_output = gr.JSON(label="Detailed Results")
-                
-                # QR Code Tab
-                with gr.Tab("📱 QR Code", id=3):
                     with gr.Row():
-                        with gr.Column(scale=2):
-                            qr_input = gr.Textbox(
-                                label="Data",
-                                placeholder="Enter data to encode",
-                                lines=3
-                            )
-                            qr_size = gr.Slider(
-                                minimum=5,
-                                maximum=50,
-                                value=10,
-                                step=1,
-                                label="QR Code Size"
-                            )
-                            generate_qr_btn = gr.Button("✨ Generate QR", variant="primary")
-                        
-                        with gr.Column(scale=1):
-                            qr_output = gr.Image(label="Generated QR Code")
-                            qr_status = gr.Textbox(label="Status", interactive=False)
-            
-            # Footer
-            gr.Markdown(
-                """
-                <div style="text-align: center; margin-top: 2rem; padding: 1rem; background: #f8fafc; border-radius: 0.5rem;">
-                    <p>Made with ❤️ by Advanced URL Processing Team</p>
-                    <p style="font-size: 0.8rem;">Version 1.0.0</p>
-                </div>
-                """
-            )
-            
-            # Event handlers
-            process_btn.click(
-                fn=self.process_urls,
-                inputs=[url_input, mode],
-                outputs=[json_output, status_output, summary_output]
-            )
-            
-            clear_btn.click(
-                fn=lambda: ("", "", ""),
-                inputs=[],
-                outputs=[url_input, status_output, summary_output]
-            )
-            
-            process_file_btn.click(
-                fn=self.process_file,
-                inputs=[file_input],
-                outputs=[file_json_output, file_status, file_output]
-            )
-            
-            generate_qr_btn.click(
-                fn=self.generate_qr,
-                inputs=[qr_input, qr_size],
-                outputs=[qr_output, qr_status]
-            )
+                        submit_btn = gr.Button("Send", variant="primary")
+                        clear_btn = gr.Button("Clear Chat", variant="secondary")
+        
+        # Event handlers
+        process_btn.click(
+            fn=data_chat.process_zip_file,
+            inputs=[data_file, mode],
+            outputs=[status_output, chatbot]
+        )
+        
+        submit_btn.click(
+            fn=data_chat.chat,
+            inputs=[msg, chatbot, mode],
+            outputs=[msg, chatbot]
+        )
+        
+        msg.submit(
+            fn=data_chat.chat,
+            inputs=[msg, chatbot, mode],
+            outputs=[msg, chatbot]
+        )
+        
+        clear_btn.click(
+            fn=lambda: ([], "Chat cleared"),
+            outputs=[chatbot, status_output]
+        )
         
         return interface
 
 def main():
-    """Main entry point"""
     try:
-        # Initialize interface
-        app = AdvancedInterface()
-        interface = app.create_interface()
-        
-        # Launch with optimal settings
-        interface.launch(
-            server_name="0.0.0.0",
-            server_port=8000,
-            share=False,
-            debug=True,
-            enable_queue=True,
-            max_threads=40,
-            auth=None,  # Add authentication if needed
-            ssl_keyfile=None,  # Add SSL if needed
-            ssl_certfile=None
-        )
+        interface = create_interface()
+        if interface:
+            interface.launch(
+                server_name="0.0.0.0",
+                server_port=8000
+            )
+        else:
+            logger.error("Failed to create interface")
+            sys.exit(1)
     except Exception as e:
         logger.error(f"Application startup error: {e}", exc_info=True)
         sys.exit(1)