Update app.py

app.py

@@ -70,7 +70,7 @@ class SupplyChainOptimizer:
     def call_claude_api(self, prompt, system_message=""):
         """Call Claude via AWS Bedrock"""
         if self.demo_mode:
-            return "Demo mode response"
+            return "Demo mode response - AI analysis would appear here with real API keys"
         
         try:
             body = {
@@ -184,8 +184,17 @@ class SupplyChainOptimizer:
         return processed_data
 
     def _process_csv_data(self, df):
-        """Process CSV data"""
-        return {'data': df.to_dict('records')}
+        # Clean column names first
+        df.columns = df.columns.str.strip().str.lower()
+        
+        # Let AI analyze the structure and map columns
+        column_analysis = self._analyze_columns_with_ai(df)
+        
+        return {
+            'data': df.to_dict('records'),
+            'column_mapping': column_analysis,
+            'original_columns': df.columns.tolist()
+        }
 
     def _process_pdf_data(self, file_path):
         """Extract text from PDF"""
@@ -223,8 +232,180 @@ class SupplyChainOptimizer:
         except Exception as e:
             return f"Error reading PowerPoint: {str(e)}"
 
+    def _analyze_columns_with_ai(self, df):
+        """Use AI to understand column structure and map to standard format"""
+        sample_data = df.head(3).to_string()
+        columns = df.columns.tolist()
+    
+        prompt = f"""
+        Analyze this data structure and map columns to standard supply chain format:
+    
+        Columns: {columns}
+        Sample Data:
+        {sample_data}
+    
+        Map these columns to:
+        - city/location: (identify city/location column)
+        - product: (identify product column) 
+        - demand/forecast: (identify demand/forecast column)
+        - stock/inventory: (identify stock/inventory column)
+        - cost: (identify cost column)
+        - distance: (identify distance column)
+    
+        Return JSON mapping like: {{"city": "actual_column_name", "product": "actual_column_name", ...}}
+        """
+    
+        if self.demo_mode:
+            # Return best guess mapping
+            mapping = {}
+            for col in columns:
+                col_lower = col.lower()
+                if any(word in col_lower for word in ['city', 'location', 'destination', 'source']):
+                    mapping['city'] = col
+                elif any(word in col_lower for word in ['product', 'item', 'sku']):
+                    mapping['product'] = col
+                elif any(word in col_lower for word in ['demand', 'forecast', 'required']):
+                    mapping['demand'] = col
+                elif any(word in col_lower for word in ['stock', 'inventory', 'level']):
+                    mapping['stock'] = col
+            return mapping   
+        else:
+            response = self.call_claude_api(prompt, "You are a data analyst expert at understanding file structures.")
+            # Parse JSON response
+            try:
+                return json.loads(response)
+            except:
+                return self._fallback_column_mapping(columns)
+
+    def _fallback_column_mapping(self, columns):
+        """Fallback column mapping if AI parsing fails"""
+        mapping = {}
+        for col in columns:
+            col_lower = col.lower()
+            if any(word in col_lower for word in ['city', 'location', 'destination', 'source']):
+                mapping['city'] = col
+            elif any(word in col_lower for word in ['product', 'item', 'sku']):
+                mapping['product'] = col
+            elif any(word in col_lower for word in ['demand', 'forecast', 'required']):
+                mapping['demand'] = col
+            elif any(word in col_lower for word in ['stock', 'inventory', 'level']):
+                mapping['stock'] = col
+            elif any(word in col_lower for word in ['cost', 'price']):
+                mapping['cost'] = col
+            elif any(word in col_lower for word in ['distance', 'km', 'miles']):
+                mapping['distance'] = col
+        return mapping
+
+    def analyze_file_with_ai(self, file_obj, data_type):
+        """Analyze uploaded file and standardize data format"""
+        try:
+            # Get file extension
+            file_name = file_obj.name
+            if file_name.endswith('.csv'):
+                df = pd.read_csv(file_obj.name)
+            elif file_name.endswith(('.xlsx', '.xls')):
+                df = pd.read_excel(file_obj.name)
+            else:
+                return {'standardized_data': [], 'detected_columns': [], 'error': 'Unsupported file format'}
+            
+            # Clean column names
+            df.columns = df.columns.str.strip()
+            detected_columns = df.columns.tolist()
+            
+            # Map columns based on data type
+            column_mapping = self._analyze_columns_with_ai(df)
+            
+            # Standardize data based on type
+            standardized_data = self._standardize_data(df, column_mapping, data_type)
+            
+            return {
+                'standardized_data': standardized_data,
+                'detected_columns': detected_columns,
+                'column_mapping': column_mapping
+            }
+        except Exception as e:
+            return {'standardized_data': [], 'detected_columns': [], 'error': str(e)}
+
+    def _standardize_data(self, df, column_mapping, data_type):
+        """Standardize data format based on type"""
+        standardized = []
+        
+        try:
+            if data_type == 'forecast':
+                for _, row in df.iterrows():
+                    item = {
+                        'City': row.get(column_mapping.get('city', ''), 'Unknown'),
+                        'Product': row.get(column_mapping.get('product', ''), 'Unknown'),
+                        'Forecasted_Demand': int(row.get(column_mapping.get('demand', ''), 0)),
+                        'Month': 'December'  # Default month
+                    }
+                    standardized.append(item)
+            
+            elif data_type == 'inventory':
+                for _, row in df.iterrows():
+                    item = {
+                        'City': row.get(column_mapping.get('city', ''), 'Unknown'),
+                        'Product': row.get(column_mapping.get('product', ''), 'Unknown'),
+                        'Stock_Level': int(row.get(column_mapping.get('stock', ''), 0))
+                    }
+                    standardized.append(item)
+            
+            elif data_type == 'routes':
+                for _, row in df.iterrows():
+                    item = {
+                        'Source': row.get(column_mapping.get('source', ''), 'Unknown'),
+                        'Destination': row.get(column_mapping.get('destination', ''), 'Unknown'),
+                        'Distance_km': float(row.get(column_mapping.get('distance', ''), 0)),
+                        'Cost_per_km': float(row.get(column_mapping.get('cost', ''), 0)),
+                        'Average_Travel_Time_hrs': float(row.get(column_mapping.get('time', ''), 0))
+                    }
+                    standardized.append(item)
+        
+        except Exception as e:
+            print(f"Error standardizing data: {e}")
+            return []
+        
+        return standardized
+
+    def generate_data_from_text(self, text_input):
+        """Generate sample data based on text description"""
+        prompt = f"""
+        Based on this business description, generate sample supply chain data:
+        
+        Text: {text_input}
+        
+        Generate realistic data for:
+        1. Forecast data (cities, products, demand)
+        2. Inventory data (cities, products, stock levels)
+        3. Route data (source, destination, distance, cost, travel time)
+        
+        Return as JSON with keys: forecast, inventory, routes
+        Each should be a list of dictionaries with appropriate fields.
+        """
+        
+        if self.demo_mode:
+            # Return default data
+            return {
+                'forecast': DEFAULT_FORECAST,
+                'inventory': DEFAULT_INVENTORY,
+                'routes': DEFAULT_ROUTES
+            }
+        else:
+            try:
+                response = self.call_claude_api(prompt, "You are a supply chain data expert.")
+                return json.loads(response)
+            except:
+                return {
+                    'forecast': DEFAULT_FORECAST,
+                    'inventory': DEFAULT_INVENTORY,
+                    'routes': DEFAULT_ROUTES
+                }
+
     def create_forecast_visualization(self, forecast_data):
         """Create interactive forecast visualization with vibrant colors"""
+        if not forecast_data:
+            forecast_data = DEFAULT_FORECAST
+            
         df = pd.DataFrame(forecast_data)
         
         fig = go.Figure()
@@ -266,6 +447,11 @@ class SupplyChainOptimizer:
 
     def create_inventory_chart(self, inventory_data, forecast_data):
         """Create inventory vs demand comparison with vibrant styling"""
+        if not inventory_data:
+            inventory_data = DEFAULT_INVENTORY
+        if not forecast_data:
+            forecast_data = DEFAULT_FORECAST
+            
         inv_df = pd.DataFrame(inventory_data)
         fore_df = pd.DataFrame(forecast_data)
         
@@ -320,6 +506,9 @@ class SupplyChainOptimizer:
 
     def create_route_network(self, route_data):
         """Create route network visualization with vibrant colors"""
+        if not route_data:
+            route_data = DEFAULT_ROUTES
+            
         df = pd.DataFrame(route_data)
         
         fig = go.Figure()
@@ -527,6 +716,12 @@ except Exception as e:
         
         def parse_file_content(self, path, file_type):
             return "Demo mode"
+        
+        def analyze_file_with_ai(self, file_obj, data_type):
+            return {'standardized_data': DEFAULT_FORECAST if data_type == 'forecast' else DEFAULT_INVENTORY if data_type == 'inventory' else DEFAULT_ROUTES, 'detected_columns': [], 'error': None}
+        
+        def generate_data_from_text(self, text):
+            return {'forecast': DEFAULT_FORECAST, 'inventory': DEFAULT_INVENTORY, 'routes': DEFAULT_ROUTES}
     
     optimizer = DemoOptimizer()
     startup_message = "Running in minimal demo mode due to initialization error."
@@ -560,52 +755,46 @@ DEFAULT_ROUTES = [
 def process_files_and_optimize(forecast_file, inventory_file, routes_file, text_input, search_query):
     """Process uploaded files and text input for optimization"""
     try:
-        forecast_data = DEFAULT_FORECAST
-        inventory_data = DEFAULT_INVENTORY
-        route_data = DEFAULT_ROUTES
-        
-        # Process uploaded files
+        # Let AI analyze files instead of using defaults
+        forecast_data = []
+        inventory_data = []
+        route_data = []
         file_contents = []
         
+        # AI-powered file processing
         if forecast_file:
-            file_ext = forecast_file.name.split('.')[-1].lower()
-            if file_ext in ['xlsx', 'xls']:
-                content = optimizer.parse_file_content(forecast_file.name, 'excel')
-                if 'forecast' in content:
-                    forecast_data = content['forecast']
-                file_contents.append(f"Forecast file processed: {forecast_file.name}")
-            elif file_ext == 'csv':
-                df = pd.read_csv(forecast_file.name)
-                forecast_data = df.to_dict('records')
-                file_contents.append(f"Forecast CSV processed: {forecast_file.name}")
+            analyzed_data = optimizer.analyze_file_with_ai(forecast_file, 'forecast')
+            forecast_data = analyzed_data['standardized_data']
+            file_contents.append(f"Forecast file analyzed: {forecast_file.name} - Found columns: {analyzed_data.get('detected_columns', 'N/A')}")
         
         if inventory_file:
-            file_ext = inventory_file.name.split('.')[-1].lower()
-            if file_ext in ['xlsx', 'xls']:
-                content = optimizer.parse_file_content(inventory_file.name, 'excel')
-                if 'inventory' in content:
-                    inventory_data = content['inventory']
-                file_contents.append(f"Inventory file processed: {inventory_file.name}")
-            elif file_ext == 'csv':
-                df = pd.read_csv(inventory_file.name)
-                inventory_data = df.to_dict('records')
-                file_contents.append(f"Inventory CSV processed: {inventory_file.name}")
+            analyzed_data = optimizer.analyze_file_with_ai(inventory_file, 'inventory')
+            inventory_data = analyzed_data['standardized_data']
+            file_contents.append(f"Inventory file analyzed: {inventory_file.name} - Found columns: {analyzed_data.get('detected_columns', 'N/A')}")
         
         if routes_file:
-            file_ext = routes_file.name.split('.')[-1].lower()
-            if file_ext in ['xlsx', 'xls']:
-                content = optimizer.parse_file_content(routes_file.name, 'excel')
-                if 'routes' in content:
-                    route_data = content['routes']
-                file_contents.append(f"Routes file processed: {routes_file.name}")
-            elif file_ext == 'csv':
-                df = pd.read_csv(routes_file.name)
-                route_data = df.to_dict('records')
-                file_contents.append(f"Routes CSV processed: {routes_file.name}")
+            analyzed_data = optimizer.analyze_file_with_ai(routes_file, 'routes')
+            route_data = analyzed_data['standardized_data']
+            file_contents.append(f"Routes file analyzed: {routes_file.name} - Found columns: {analyzed_data.get('detected_columns', 'N/A')}")
+        
+        # If no files uploaded, use defaults or generate from text
+        if not any([forecast_file, inventory_file, routes_file]):
+            if text_input and text_input.strip():
+                ai_generated_data = optimizer.generate_data_from_text(text_input)
+                forecast_data = ai_generated_data.get('forecast', DEFAULT_FORECAST)
+                inventory_data = ai_generated_data.get('inventory', DEFAULT_INVENTORY)
+                route_data = ai_generated_data.get('routes', DEFAULT_ROUTES)
+                file_contents.append("AI generated data from text description")
+            else:
+                # Use default data
+                forecast_data = DEFAULT_FORECAST
+                inventory_data = DEFAULT_INVENTORY
+                route_data = DEFAULT_ROUTES
+                file_contents.append("Using default sample data")
         
         # Process text input if provided
         if text_input and text_input.strip():
-            file_contents.append(f"Text input processed: {len(text_input)} characters")
+            file_contents.append(f"Text context processed: {len(text_input)} characters")
         
         # Create visualizations
         forecast_chart = optimizer.create_forecast_visualization(forecast_data)
@@ -617,8 +806,7 @@ def process_files_and_optimize(forecast_file, inventory_file, routes_file, text_
             forecast_data, inventory_data, route_data, search_query
         )
         
-        # Processing summary
-        processing_summary = "Files processed:\n" + "\n".join(file_contents) if file_contents else "Using default data"
+        processing_summary = "Files processed:\n" + "\n".join(file_contents) if file_contents else "No data provided"
         
         return (
             forecast_chart,
@@ -632,7 +820,8 @@ def process_files_and_optimize(forecast_file, inventory_file, routes_file, text_
         
     except Exception as e:
         error_msg = f"Processing error: {str(e)}"
-        return None, None, None, error_msg, error_msg, error_msg, error_msg
+        empty_fig = go.Figure().add_annotation(text=f"Error: {str(e)}", x=0.5, y=0.5, showarrow=False)
+        return empty_fig, empty_fig, empty_fig, error_msg, error_msg, error_msg, error_msg
 
 # Create Gradio interface with updated warm color scheme
 custom_css = """
@@ -717,7 +906,6 @@ custom_css = """
     transform: translateY(-2px);
 }
 
-/* Button styling */
 .gradio-button {
     background: linear-gradient(135deg, #FF4757 0%, #FFA502 100%) !important;
     color: white !important;
@@ -725,7 +913,7 @@ custom_css = """
     border: 2px solid #B8860B !important;
     border-radius: 8px !important;
     padding: 12px 24px !important;
-    font-size:  1rem !important;
+    font-size: 1rem !important;
     transition: all 0.3s ease !important;
     box-shadow: 0 4px 15px rgba(255, 71, 87, 0.2) !important;
 }
@@ -736,7 +924,6 @@ custom_css = """
     box-shadow: 0 6px 20px rgba(255, 71, 87, 0.3) !important;
 }
 
-/* Input styling */
 .gradio-textbox, .gradio-dropdown {
     border: 2px solid #DAA520 !important;
     border-radius: 8px !important;
@@ -864,7 +1051,7 @@ with gr.Blocks(css=custom_css, title="AI-Powered Supply Chain Optimizer") as int
     gr.HTML("""
     <div class="footer">
         <p><strong>AI-Powered Supply Chain Optimizer</strong> | Advanced Analytics & Real-Time Intelligence</p>
-        <p>🔧 Built with AutoGen, Tavily API, and Gradio | 🚀 Powered by OpenAI GPT</p>
+        <p>🔧 Built with AutoGen, Tavily API, and Claude | 🚀 Powered by AWS Bedrock</p>
     </div>
     """)