Spaces:
Sleeping
Sleeping
| import os | |
| import gradio as gr | |
| import pandas as pd | |
| import google.generativeai as genai | |
| import joblib | |
| from reportlab.lib import colors | |
| from reportlab.lib.pagesizes import letter | |
| from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image | |
| from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle | |
| import plotly.express as px | |
| import plotly.graph_objects as go | |
| import tempfile | |
| from datetime import datetime | |
| import numpy as np | |
| from xgboost import XGBRegressor | |
| # Configure Gemini API | |
| GEMINI_API_KEY = os.getenv("gemini_api") | |
| genai.configure(api_key=GEMINI_API_KEY) | |
| generation_config = { | |
| "temperature": 1, | |
| "top_p": 0.95, | |
| "top_k": 64, | |
| "max_output_tokens": 8192, | |
| } | |
| model = genai.GenerativeModel("gemini-pro", generation_config=generation_config) | |
| chat_model = genai.GenerativeModel("gemini-pro") | |
| # Create and save a simple model on first run | |
| def create_initial_model(): | |
| n_samples = 1000 | |
| np.random.seed(42) | |
| data = { | |
| 'weight (kilograms)': np.random.uniform(100, 10000, n_samples), | |
| 'line item value': np.random.uniform(1000, 1000000, n_samples), | |
| 'cost per kilogram': np.random.uniform(1, 500, n_samples), | |
| 'shipment mode_Air Charter_weight': np.zeros(n_samples), | |
| 'shipment mode_Ocean_weight': np.zeros(n_samples), | |
| 'shipment mode_Truck_weight': np.zeros(n_samples), | |
| 'shipment mode_Air Charter_line_item_value': np.zeros(n_samples), | |
| 'shipment mode_Ocean_line_item_value': np.zeros(n_samples), | |
| 'shipment mode_Truck_line_item_value': np.zeros(n_samples) | |
| } | |
| modes = ['Air', 'Ocean', 'Truck'] | |
| for i in range(n_samples): | |
| mode = np.random.choice(modes) | |
| if mode == 'Air': | |
| data['shipment mode_Air Charter_weight'][i] = data['weight (kilograms)'][i] | |
| data['shipment mode_Air Charter_line_item_value'][i] = data['line item value'][i] | |
| elif mode == 'Ocean': | |
| data['shipment mode_Ocean_weight'][i] = data['weight (kilograms)'][i] | |
| data['shipment mode_Ocean_line_item_value'][i] = data['line item value'][i] | |
| else: | |
| data['shipment mode_Truck_weight'][i] = data['weight (kilograms)'][i] | |
| data['shipment mode_Truck_line_item_value'][i] = data['line item value'][i] | |
| df = pd.DataFrame(data) | |
| base_cost = (df['weight (kilograms)'] * df['cost per kilogram'] * 0.8 + | |
| df['line item value'] * 0.02) | |
| air_multiplier = 1.5 | |
| ocean_multiplier = 0.8 | |
| truck_multiplier = 1.0 | |
| freight_cost = ( | |
| base_cost * (air_multiplier * (df['shipment mode_Air Charter_weight'] > 0) + | |
| ocean_multiplier * (df['shipment mode_Ocean_weight'] > 0) + | |
| truck_multiplier * (df['shipment mode_Truck_weight'] > 0)) | |
| ) | |
| freight_cost = freight_cost + np.random.normal(0, freight_cost * 0.1) | |
| model = XGBRegressor(n_estimators=100, learning_rate=0.1, max_depth=5, random_state=42) | |
| model.fit(df, freight_cost) | |
| return model | |
| # Enhanced CSS styling | |
| CUSTOM_CSS = ''' | |
| .gradio-container { | |
| max-width: 1200px !important; | |
| margin: auto !important; | |
| padding: 20px !important; | |
| background-color: #1a1a1a !important; | |
| color: #ffffff !important; | |
| } | |
| .main-header { | |
| background: linear-gradient(135deg, #1e3c72 0%, #2a5298 100%) !important; | |
| color: white !important; | |
| padding: 30px !important; | |
| border-radius: 15px !important; | |
| margin-bottom: 30px !important; | |
| text-align: center !important; | |
| box-shadow: 0 4px 15px rgba(0, 0, 0, 0.2) !important; | |
| } | |
| .app-title { | |
| font-size: 2.5em !important; | |
| font-weight: bold !important; | |
| margin-bottom: 10px !important; | |
| background: linear-gradient(90deg, #ffffff, #3498DB) !important; | |
| -webkit-background-clip: text !important; | |
| -webkit-text-fill-color: transparent !important; | |
| text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3) !important; | |
| } | |
| .app-subtitle { | |
| font-size: 1.3em !important; | |
| color: #89CFF0 !important; | |
| margin-bottom: 15px !important; | |
| font-weight: 500 !important; | |
| } | |
| .app-description { | |
| font-size: 1.1em !important; | |
| color: #B0C4DE !important; | |
| margin-bottom: 20px !important; | |
| line-height: 1.5 !important; | |
| } | |
| .creator-info { | |
| font-size: 1.2em !important; | |
| color: #3498DB !important; | |
| margin-top: 15px !important; | |
| padding: 10px !important; | |
| border-top: 2px solid rgba(52, 152, 219, 0.3) !important; | |
| font-style: italic !important; | |
| } | |
| .status-box { | |
| background: #363636 !important; | |
| border-left: 4px solid #3498DB !important; | |
| padding: 15px !important; | |
| margin: 10px 0 !important; | |
| border-radius: 0 5px 5px 0 !important; | |
| color: #ffffff !important; | |
| } | |
| .chart-container { | |
| background: #2d2d2d !important; | |
| padding: 20px !important; | |
| border-radius: 10px !important; | |
| box-shadow: 0 2px 4px rgba(0,0,0,0.2) !important; | |
| color: #ffffff !important; | |
| } | |
| .chat-container { | |
| height: 400px !important; | |
| overflow-y: auto !important; | |
| border: 1px solid #404040 !important; | |
| border-radius: 10px !important; | |
| padding: 15px !important; | |
| background: #2d2d2d !important; | |
| color: #ffffff !important; | |
| } | |
| .file-upload { | |
| border: 2px dashed #404040 !important; | |
| border-radius: 10px !important; | |
| padding: 20px !important; | |
| text-align: center !important; | |
| background: #2d2d2d !important; | |
| color: #ffffff !important; | |
| } | |
| .result-box { | |
| background: #363636 !important; | |
| border: 1px solid #404040 !important; | |
| border-radius: 10px !important; | |
| padding: 20px !important; | |
| margin-top: 15px !important; | |
| color: #ffffff !important; | |
| } | |
| .tab-content { | |
| background: #2d2d2d !important; | |
| padding: 20px !important; | |
| border-radius: 10px !important; | |
| box-shadow: 0 2px 4px rgba(0,0,0,0.2) !important; | |
| color: #ffffff !important; | |
| } | |
| input, select, textarea { | |
| background: #363636 !important; | |
| color: #ffffff !important; | |
| border: 1px solid #404040 !important; | |
| } | |
| input:focus, select:focus, textarea:focus { | |
| border-color: #3498DB !important; | |
| box-shadow: 0 0 0 2px rgba(52, 152, 219, 0.2) !important; | |
| } | |
| .action-button { | |
| background: #3498DB !important; | |
| color: white !important; | |
| border: none !important; | |
| padding: 10px 20px !important; | |
| border-radius: 5px !important; | |
| cursor: pointer !important; | |
| transition: all 0.3s ease !important; | |
| } | |
| .action-button:hover { | |
| background: #2980B9 !important; | |
| transform: translateY(-2px) !important; | |
| box-shadow: 0 4px 8px rgba(0,0,0,0.2) !important; | |
| } | |
| .footer { | |
| text-align: center !important; | |
| padding: 20px !important; | |
| margin-top: 40px !important; | |
| border-top: 1px solid #404040 !important; | |
| color: #888888 !important; | |
| } | |
| ''' | |
| class SupplyChainState: | |
| def __init__(self): | |
| self.sales_df = None | |
| self.supplier_df = None | |
| self.text_data = None | |
| self.chat_history = [] | |
| self.analysis_results = {} | |
| self.freight_predictions = [] | |
| try: | |
| self.freight_model = create_initial_model() | |
| except Exception as e: | |
| print(f"Warning: Could not create freight prediction model: {e}") | |
| self.freight_model = None | |
| def process_uploaded_data(state, sales_file, supplier_file, text_data): | |
| """Process uploaded files and store in state""" | |
| try: | |
| if sales_file is not None: | |
| state.sales_df = pd.read_csv(sales_file.name) | |
| if supplier_file is not None: | |
| state.supplier_df = pd.read_excel(supplier_file.name) | |
| state.text_data = text_data | |
| return "✅ Data processed successfully" | |
| except Exception as e: | |
| return f'❌ Error processing data: {str(e)}' | |
| def perform_demand_forecasting(state): | |
| """Perform demand forecasting using Gemini""" | |
| if state.sales_df is None: | |
| return "Error: No sales data provided", None, "Please upload sales data first" | |
| try: | |
| sales_summary = state.sales_df.describe().to_string() | |
| prompt = f"""Analyze the following sales data summary and provide: | |
| 1. A detailed demand forecast for the next quarter | |
| 2. Key trends and seasonality patterns | |
| 3. Actionable recommendations | |
| Data Summary: | |
| {sales_summary} | |
| Please structure your response with clear sections for Forecast, Trends, and Recommendations.""" | |
| response = model.generate_content(prompt) | |
| analysis_text = response.text | |
| fig = px.line(state.sales_df, title='Historical Sales Data and Forecast') | |
| fig.update_layout( | |
| template='plotly_dark', | |
| title_x=0.5, | |
| title_font_size=20, | |
| showlegend=True, | |
| hovermode='x', | |
| paper_bgcolor='#2d2d2d', | |
| plot_bgcolor='#363636', | |
| font=dict(color='white') | |
| ) | |
| return analysis_text, fig, "✅ Analysis completed successfully" | |
| except Exception as e: | |
| return f"❌ Error in demand forecasting: {str(e)}", None, "Analysis failed" | |
| def perform_risk_assessment(state): | |
| """Perform risk assessment using Gemini""" | |
| if state.supplier_df is None: | |
| return "Error: No supplier data provided", None, "Please upload supplier data first" | |
| try: | |
| supplier_summary = state.supplier_df.describe().to_string() | |
| prompt = f"""Perform a comprehensive risk assessment based on: | |
| Supplier Data Summary: | |
| {supplier_summary} | |
| Additional Context: | |
| {state.text_data if state.text_data else 'No additional context provided'} | |
| Please provide: | |
| 1. Risk scoring for each supplier | |
| 2. Identified risk factors | |
| 3. Mitigation recommendations""" | |
| response = model.generate_content(prompt) | |
| analysis_text = response.text | |
| fig = px.scatter(state.supplier_df, title='Supplier Risk Assessment') | |
| fig.update_layout( | |
| template='plotly_dark', | |
| title_x=0.5, | |
| title_font_size=20, | |
| showlegend=True, | |
| hovermode='closest', | |
| paper_bgcolor='#2d2d2d', | |
| plot_bgcolor='#363636', | |
| font=dict(color='white') | |
| ) | |
| return analysis_text, fig, "✅ Risk assessment completed" | |
| except Exception as e: | |
| return f"❌ Error in risk assessment: {str(e)}", None, "Assessment failed" | |
| def perform_inventory_optimization(state): | |
| """Perform inventory optimization analysis""" | |
| if state.sales_df is None: | |
| return "Error: No sales data provided", None, "Please upload sales data first" | |
| if model is None: | |
| return "AI features are currently disabled. Please check your API key configuration.", None, "AI Disabled" | |
| try: | |
| inventory_summary = state.sales_df.describe().to_string() | |
| prompt = f"""Analyze the following inventory data and provide: | |
| 1. Optimal inventory levels | |
| 2. Reorder points | |
| 3. Safety stock recommendations | |
| 4. ABC analysis insights | |
| Data Summary: | |
| {inventory_summary} | |
| Additional Context: | |
| {state.text_data if state.text_data else 'No additional context provided'} | |
| Please structure your response with clear sections for each aspect.""" | |
| response = model.generate_content(prompt) | |
| analysis_text = response.text | |
| # Create inventory level visualization | |
| fig = go.Figure() | |
| if 'quantity' in state.sales_df.columns: | |
| fig.add_trace(go.Scatter( | |
| y=state.sales_df['quantity'], | |
| name='Inventory Level', | |
| line=dict(color='#3498DB') | |
| )) | |
| fig.update_layout( | |
| title='Inventory Level Analysis', | |
| template='plotly_dark', | |
| title_x=0.5, | |
| title_font_size=20, | |
| showlegend=True, | |
| hovermode='x', | |
| paper_bgcolor='#2d2d2d', | |
| plot_bgcolor='#363636', | |
| font=dict(color='white') | |
| ) | |
| return analysis_text, fig, "✅ Inventory optimization completed" | |
| except Exception as e: | |
| return f"❌ Error in inventory optimization: {str(e)}", None, "Analysis failed" | |
| def perform_supplier_performance(state): | |
| """Analyze supplier performance""" | |
| if state.supplier_df is None: | |
| return "Error: No supplier data provided", None, "Please upload supplier data first" | |
| if model is None: | |
| return "AI features are currently disabled. Please check your API key configuration.", None, "AI Disabled" | |
| try: | |
| supplier_summary = state.supplier_df.describe().to_string() | |
| prompt = f"""Analyze supplier performance based on: | |
| Supplier Data Summary: | |
| {supplier_summary} | |
| Additional Context: | |
| {state.text_data if state.text_data else 'No additional context provided'} | |
| Please provide: | |
| 1. Supplier performance metrics | |
| 2. Performance rankings | |
| 3. Areas for improvement | |
| 4. Supplier development recommendations""" | |
| response = model.generate_content(prompt) | |
| analysis_text = response.text | |
| # Create supplier performance visualization | |
| if 'performance_score' in state.supplier_df.columns: | |
| fig = px.box(state.supplier_df, y='performance_score', | |
| title='Supplier Performance Distribution') | |
| else: | |
| # Create a sample visualization if performance_score is not available | |
| fig = go.Figure(data=[ | |
| go.Bar(name='On-Time Delivery', x=['Supplier A', 'Supplier B', 'Supplier C'], | |
| y=[95, 87, 92]), | |
| go.Bar(name='Quality Score', x=['Supplier A', 'Supplier B', 'Supplier C'], | |
| y=[88, 94, 90]) | |
| ]) | |
| fig.update_layout( | |
| template='plotly_dark', | |
| title_x=0.5, | |
| title_font_size=20, | |
| showlegend=True, | |
| paper_bgcolor='#2d2d2d', | |
| plot_bgcolor='#363636', | |
| font=dict(color='white') | |
| ) | |
| return analysis_text, fig, "✅ Supplier performance analysis completed" | |
| except Exception as e: | |
| return f"❌ Error in supplier performance analysis: {str(e)}", None, "Analysis failed" | |
| def perform_sustainability_analysis(state): | |
| """Analyze sustainability metrics""" | |
| if state.supplier_df is None and state.sales_df is None: | |
| return "Error: No data provided", None, "Please upload data first" | |
| if model is None: | |
| return "AI features are currently disabled. Please check your API key configuration.", None, "AI Disabled" | |
| try: | |
| # Combine available data for analysis | |
| data_summary = "" | |
| if state.supplier_df is not None: | |
| data_summary += f"Supplier Data Summary:\n{state.supplier_df.describe().to_string()}\n\n" | |
| if state.sales_df is not None: | |
| data_summary += f"Sales Data Summary:\n{state.sales_df.describe().to_string()}" | |
| prompt = f"""Perform a comprehensive sustainability analysis: | |
| Data Summary: | |
| {data_summary} | |
| Additional Context: | |
| {state.text_data if state.text_data else 'No additional context provided'} | |
| Please provide: | |
| 1. Carbon footprint analysis | |
| 2. Environmental impact metrics | |
| 3. Sustainability recommendations | |
| 4. Green initiative opportunities | |
| 5. ESG performance indicators""" | |
| response = model.generate_content(prompt) | |
| analysis_text = response.text | |
| # Create sustainability visualization | |
| fig = go.Figure() | |
| # Example sustainability metrics | |
| categories = ['Carbon Emissions', 'Water Usage', 'Waste Reduction', | |
| 'Energy Efficiency', 'Green Transportation'] | |
| current_scores = [75, 82, 68, 90, 60] | |
| target_scores = [100, 100, 100, 100, 100] | |
| fig.add_trace(go.Scatterpolar( | |
| r=current_scores, | |
| theta=categories, | |
| fill='toself', | |
| name='Current Performance' | |
| )) | |
| fig.add_trace(go.Scatterpolar( | |
| r=target_scores, | |
| theta=categories, | |
| fill='toself', | |
| name='Target' | |
| )) | |
| fig.update_layout( | |
| polar=dict( | |
| radialaxis=dict( | |
| visible=True, | |
| range=[0, 100] | |
| )), | |
| showlegend=True, | |
| title='Sustainability Performance Metrics', | |
| template='plotly_dark', | |
| title_x=0.5, | |
| title_font_size=20, | |
| paper_bgcolor='#2d2d2d', | |
| plot_bgcolor='#363636', | |
| font=dict(color='white') | |
| ) | |
| return analysis_text, fig, "✅ Sustainability analysis completed" | |
| except Exception as e: | |
| return f"❌ Error in sustainability analysis: {str(e)}", None, "Analysis failed" | |
| def predict_freight_cost(state, weight, line_item_value, cost_per_kg, | |
| shipment_mode, air_charter_weight, ocean_weight, truck_weight, | |
| air_charter_value, ocean_value, truck_value): | |
| """Predict freight cost using the model""" | |
| if state.freight_model is None: | |
| return "Error: Freight prediction model not loaded" | |
| try: | |
| features = { | |
| 'weight (kilograms)': weight, | |
| 'line item value': line_item_value, | |
| 'cost per kilogram': cost_per_kg, | |
| 'shipment mode_Air Charter_weight': air_charter_weight if "Air" in shipment_mode else 0, | |
| 'shipment mode_Ocean_weight': ocean_weight if "Ocean" in shipment_mode else 0, | |
| 'shipment mode_Truck_weight': truck_weight if "Truck" in shipment_mode else 0, | |
| 'shipment mode_Air Charter_line_item_value': air_charter_value if "Air" in shipment_mode else 0, | |
| 'shipment mode_Ocean_line_item_value': ocean_value if "Ocean" in shipment_mode else 0, | |
| 'shipment mode_Truck_line_item_value': truck_value if "Truck" in shipment_mode else 0 | |
| } | |
| input_data = pd.DataFrame([features]) | |
| prediction = state.freight_model.predict(input_data) | |
| return round(float(prediction[0]), 2) | |
| except Exception as e: | |
| return f"Error making prediction: {str(e)}" | |
| def chat_with_navigator(state, message): | |
| """Handle chat interactions""" | |
| try: | |
| context = "Available data and analysis:\n" | |
| if state.sales_df is not None: | |
| context += f"- Sales data with {len(state.sales_df)} records\n" | |
| if state.supplier_df is not None: | |
| context += f"- Supplier data with {len(state.supplier_df)} records\n" | |
| if state.text_data: | |
| context += "- Additional context from text data\n" | |
| if state.freight_predictions: | |
| context += f"- Recent freight predictions: {state.freight_predictions[-5:]}\n" | |
| if state.analysis_results: | |
| context += "\nRecent analysis results:\n" | |
| for analysis_type, results in state.analysis_results.items(): | |
| context += f"- {analysis_type} completed\n" | |
| prompt = f"""You are SupplyChainAI Navigator's assistant. Help the user with supply chain analysis, | |
| including demand forecasting, risk assessment, and freight cost predictions. | |
| Available Context: | |
| {context} | |
| Chat History: | |
| {str(state.chat_history[-3:]) if state.chat_history else 'No previous messages'} | |
| User message: {message} | |
| Provide a helpful response based on the available data and analysis results.""" | |
| response = chat_model.generate_content(prompt) | |
| state.chat_history.append({"role": "user", "content": message}) | |
| state.chat_history.append({"role": "assistant", "content": response.text}) | |
| return state.chat_history | |
| except Exception as e: | |
| return [{"role": "assistant", "content": f"Error: {str(e)}"}] | |
| def generate_pdf_report(state, analysis_options): | |
| """Generate PDF report with analysis results""" | |
| try: | |
| temp_dir = tempfile.mkdtemp() | |
| pdf_path = os.path.join(temp_dir, "supply_chain_report.pdf") | |
| doc = SimpleDocTemplate(pdf_path, pagesize=letter) | |
| styles = getSampleStyleSheet() | |
| story = [] | |
| title_style = ParagraphStyle( | |
| 'CustomTitle', | |
| parent=styles['Heading1'], | |
| fontSize=24, | |
| spaceAfter=30, | |
| textColor=colors.HexColor('#2C3E50') | |
| ) | |
| story.append(Paragraph("SupplyChainAI Navigator Report", title_style)) | |
| story.append(Spacer(1, 12)) | |
| timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") | |
| story.append(Paragraph(f"Generated on: {timestamp}", styles['Normal'])) | |
| story.append(Spacer(1, 20)) | |
| story.append(Paragraph("Executive Summary", styles['Heading2'])) | |
| summary_text = "This report provides a comprehensive analysis of supply chain data, including demand forecasting, risk assessment, and optimization recommendations." | |
| story.append(Paragraph(summary_text, styles['Normal'])) | |
| story.append(Spacer(1, 20)) | |
| if state.analysis_results: | |
| for analysis_type, results in state.analysis_results.items(): | |
| if analysis_type in analysis_options: | |
| story.append(Paragraph(analysis_type, styles['Heading2'])) | |
| story.append(Spacer(1, 12)) | |
| story.append(Paragraph(results['text'], styles['Normal'])) | |
| story.append(Spacer(1, 12)) | |
| if 'figure' in results: | |
| img_path = os.path.join(temp_dir, f"{analysis_type.lower()}_plot.png") | |
| results['figure'].write_image(img_path) | |
| story.append(Image(img_path, width=400, height=300)) | |
| story.append(Spacer(1, 20)) | |
| if state.freight_predictions: | |
| story.append(Paragraph("Recent Freight Cost Predictions", styles['Heading2'])) | |
| story.append(Spacer(1, 12)) | |
| pred_data = [["Prediction #", "Cost (USD)"]] | |
| for i, pred in enumerate(state.freight_predictions[-5:], 1): | |
| pred_data.append([f"Prediction {i}", f"${pred:,.2f}"]) | |
| table = Table(pred_data) | |
| table.setStyle(TableStyle([ | |
| ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#3498DB')), | |
| ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke), | |
| ('ALIGN', (0, 0), (-1, -1), 'CENTER'), | |
| ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'), | |
| ('FONTSIZE', (0, 0), (-1, 0), 14), | |
| ('BOTTOMPADDING', (0, 0), (-1, 0), 12), | |
| ('BACKGROUND', (0, 1), (-1, -1), colors.whitesmoke), | |
| ('TEXTCOLOR', (0, 1), (-1, -1), colors.black), | |
| ('FONTNAME', (0, 1), (-1, -1), 'Helvetica'), | |
| ('FONTSIZE', (0, 1), (-1, -1), 12), | |
| ('GRID', (0, 0), (-1, -1), 1, colors.black) | |
| ])) | |
| story.append(table) | |
| story.append(Spacer(1, 20)) | |
| doc.build(story) | |
| return pdf_path | |
| except Exception as e: | |
| print(f"Error generating PDF: {str(e)}") | |
| return None | |
| def run_analyses(state, choices, sales_file, supplier_file, text_data): | |
| """Run selected analyses""" | |
| results = [] | |
| figures = [] | |
| status_messages = [] | |
| # Process data first | |
| process_status = process_uploaded_data(state, sales_file, supplier_file, text_data) | |
| if "Error" in process_status: | |
| return process_status, None, process_status | |
| for choice in choices: | |
| if "📈 Demand Forecasting" in choice: | |
| text, fig, status = perform_demand_forecasting(state) | |
| results.append(text) | |
| figures.append(fig) | |
| status_messages.append(status) | |
| if text and fig: | |
| state.analysis_results['Demand Forecasting'] = {'text': text, 'figure': fig} | |
| elif "⚠️ Risk Assessment" in choice: | |
| text, fig, status = perform_risk_assessment(state) | |
| results.append(text) | |
| figures.append(fig) | |
| status_messages.append(status) | |
| if text and fig: | |
| state.analysis_results['Risk Assessment'] = {'text': text, 'figure': fig} | |
| elif "📦 Inventory Optimization" in choice: | |
| text, fig, status = perform_inventory_optimization(state) | |
| results.append(text) | |
| figures.append(fig) | |
| status_messages.append(status) | |
| if text and fig: | |
| state.analysis_results['Inventory Optimization'] = {'text': text, 'figure': fig} | |
| elif "🤝 Supplier Performance" in choice: | |
| text, fig, status = perform_supplier_performance(state) | |
| results.append(text) | |
| figures.append(fig) | |
| status_messages.append(status) | |
| if text and fig: | |
| state.analysis_results['Supplier Performance'] = {'text': text, 'figure': fig} | |
| elif "🌿 Sustainability Analysis" in choice: | |
| text, fig, status = perform_sustainability_analysis(state) | |
| results.append(text) | |
| figures.append(fig) | |
| status_messages.append(status) | |
| if text and fig: | |
| state.analysis_results['Sustainability Analysis'] = {'text': text, 'figure': fig} | |
| combined_results = "\n\n".join(results) | |
| combined_status = "\n".join(status_messages) | |
| final_figure = figures[-1] if figures else None | |
| return combined_results, final_figure, combined_status | |
| def predict_and_store_freight(state, *args): | |
| """Predict freight cost and store the result""" | |
| result = predict_freight_cost(state, *args) | |
| if isinstance(result, (int, float)): | |
| state.freight_predictions.append(result) | |
| return result | |
| def create_interface(): | |
| """Create Gradio interface with enhanced UI""" | |
| state = SupplyChainState() | |
| with gr.Blocks(css=CUSTOM_CSS, title="SupplyChainAI Navigator") as demo: | |
| # Header | |
| with gr.Row(elem_classes="main-header"): | |
| with gr.Column(): | |
| gr.Markdown("# 🚢 SupplyChainAI Navigator", elem_classes="app-title") | |
| gr.Markdown("### Intelligent Supply Chain Analysis & Optimization", elem_classes="app-subtitle") | |
| gr.Markdown("An AI-powered platform for comprehensive supply chain analytics", elem_classes="app-description") | |
| gr.Markdown("### Created by Aditya Ratan", elem_classes="creator-info") | |
| # Main Content Tabs | |
| with gr.Tabs() as tabs: | |
| # Data Upload Tab | |
| with gr.Tab("📊 Data Upload", elem_classes="tab-content"): | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| sales_data_upload = gr.File( | |
| file_types=[".csv"], | |
| label="📈 Sales Data (CSV)", | |
| elem_classes="file-upload" | |
| ) | |
| with gr.Column(scale=1): | |
| supplier_data_upload = gr.File( | |
| file_types=[".xlsx", ".xls"], | |
| label="🏭 Supplier Data (Excel)", | |
| elem_classes="file-upload" | |
| ) | |
| text_input_area = gr.Textbox( | |
| label="📝 Additional Context", | |
| placeholder="Add market updates, news, or other relevant information...", | |
| lines=5 | |
| ) | |
| with gr.Row(): | |
| upload_status = gr.Textbox( | |
| label="Status", | |
| elem_classes="status-box" | |
| ) | |
| upload_button = gr.Button( | |
| "🔄 Process Data", | |
| variant="primary", | |
| elem_classes="action-button" | |
| ) | |
| # Analysis Tab | |
| with gr.Tab("🔍 Analysis", elem_classes="tab-content"): | |
| analysis_options = gr.CheckboxGroup( | |
| choices=[ | |
| "📈 Demand Forecasting", | |
| "⚠️ Risk Assessment", | |
| "📦 Inventory Optimization", | |
| "🤝 Supplier Performance", | |
| "🌿 Sustainability Analysis" | |
| ], | |
| label="Choose analyses to perform" | |
| ) | |
| analyze_button = gr.Button( | |
| "🚀 Run Analysis", | |
| variant="primary", | |
| elem_classes="action-button" | |
| ) | |
| with gr.Row(): | |
| with gr.Column(scale=2): | |
| analysis_output = gr.Textbox( | |
| label="Analysis Results", | |
| elem_classes="result-box" | |
| ) | |
| with gr.Column(scale=3): | |
| plot_output = gr.Plot( | |
| label="Visualization", | |
| elem_classes="chart-container" | |
| ) | |
| raw_output = gr.Textbox( | |
| label="Processing Status", | |
| elem_classes="status-box" | |
| ) | |
| # Freight Cost Prediction Tab | |
| with gr.Tab("💰 Cost Prediction", elem_classes="tab-content"): | |
| with gr.Row(): | |
| shipment_mode = gr.Dropdown( | |
| choices=["✈️ Air", "🚢 Ocean", "🚛 Truck"], | |
| label="Transport Mode", | |
| value="✈️ Air" | |
| ) | |
| with gr.Row(): | |
| with gr.Column(): | |
| weight = gr.Slider( | |
| label="📦 Weight (kg)", | |
| minimum=1, | |
| maximum=10000, | |
| step=1, | |
| value=1000 | |
| ) | |
| with gr.Column(): | |
| line_item_value = gr.Slider( | |
| label="💵 Item Value (USD)", | |
| minimum=1, | |
| maximum=1000000, | |
| step=1, | |
| value=10000 | |
| ) | |
| with gr.Column(): | |
| cost_per_kg = gr.Slider( | |
| label="💰 Cost per kg (USD)", | |
| minimum=0, | |
| maximum=500, | |
| step=0.1, | |
| value=50 | |
| ) | |
| # Mode-specific inputs | |
| with gr.Row(visible=False) as air_inputs: | |
| air_charter_weight = gr.Slider( | |
| label="Air Charter Weight", | |
| minimum=0, | |
| maximum=10000 | |
| ) | |
| air_charter_value = gr.Slider( | |
| label="Air Charter Value", | |
| minimum=0, | |
| maximum=1000000 | |
| ) | |
| with gr.Row(visible=False) as ocean_inputs: | |
| ocean_weight = gr.Slider( | |
| label="Ocean Weight", | |
| minimum=0, | |
| maximum=10000 | |
| ) | |
| ocean_value = gr.Slider( | |
| label="Ocean Value", | |
| minimum=0, | |
| maximum=1000000 | |
| ) | |
| with gr.Row(visible=False) as truck_inputs: | |
| truck_weight = gr.Slider( | |
| label="Truck Weight", | |
| minimum=0, | |
| maximum=10000 | |
| ) | |
| truck_value = gr.Slider( | |
| label="Truck Value", | |
| minimum=0, | |
| maximum=1000000 | |
| ) | |
| with gr.Row(): | |
| predict_button = gr.Button( | |
| "🔍 Calculate Cost", | |
| variant="primary", | |
| elem_classes="action-button" | |
| ) | |
| freight_result = gr.Number( | |
| label="Predicted Cost (USD)", | |
| elem_classes="result-box" | |
| ) | |
| # Chat Tab | |
| with gr.Tab("💬 Chat", elem_classes="tab-content"): | |
| chatbot = gr.Chatbot( | |
| label="Chat History", | |
| elem_classes="chat-container", | |
| height=400, | |
| type="messages" | |
| ) | |
| with gr.Row(): | |
| msg = gr.Textbox( | |
| label="Message", | |
| placeholder="Ask about your supply chain data...", | |
| scale=4 | |
| ) | |
| chat_button = gr.Button( | |
| "📤 Send", | |
| variant="primary", | |
| scale=1, | |
| elem_classes="action-button" | |
| ) | |
| # Report Tab | |
| with gr.Tab("📑 Report", elem_classes="tab-content"): | |
| report_button = gr.Button( | |
| "📄 Generate Report", | |
| variant="primary", | |
| elem_classes="action-button" | |
| ) | |
| report_download = gr.File( | |
| label="Download Report" | |
| ) | |
| # Footer | |
| with gr.Row(elem_classes="footer"): | |
| gr.Markdown("Designed and Developed by Aditya Ratan © 2025") | |
| # Event Handlers | |
| def update_mode_inputs(mode): | |
| return { | |
| air_inputs: gr.update(visible=mode=="✈️ Air"), | |
| ocean_inputs: gr.update(visible=mode=="🚢 Ocean"), | |
| truck_inputs: gr.update(visible=mode=="🚛 Truck") | |
| } | |
| upload_button.click( | |
| fn=lambda *args: process_uploaded_data(state, *args), | |
| inputs=[sales_data_upload, supplier_data_upload, text_input_area], | |
| outputs=[upload_status] | |
| ) | |
| analyze_button.click( | |
| fn=lambda *args: run_analyses(state, *args), | |
| inputs=[analysis_options, sales_data_upload, supplier_data_upload, text_input_area], | |
| outputs=[analysis_output, plot_output, raw_output] | |
| ) | |
| shipment_mode.change( | |
| fn=update_mode_inputs, | |
| inputs=[shipment_mode], | |
| outputs=[air_inputs, ocean_inputs, truck_inputs] | |
| ) | |
| predict_button.click( | |
| fn=lambda *args: predict_and_store_freight(state, *args), | |
| inputs=[ | |
| weight, line_item_value, cost_per_kg, | |
| shipment_mode, air_charter_weight, ocean_weight, truck_weight, | |
| air_charter_value, ocean_value, truck_value | |
| ], | |
| outputs=[freight_result] | |
| ) | |
| chat_button.click( | |
| fn=lambda message: chat_with_navigator(state, message), | |
| inputs=[msg], | |
| outputs=[chatbot] | |
| ).then( | |
| fn=lambda: "", | |
| outputs=[msg] | |
| ) | |
| report_button.click( | |
| fn=lambda options: generate_pdf_report(state, options), | |
| inputs=[analysis_options], | |
| outputs=[report_download] | |
| ) | |
| return demo | |
| # Update the launch parameters in __main__: | |
| if __name__ == "__main__": | |
| demo = create_interface() | |
| demo.launch( | |
| server_name="0.0.0.0", # Add this line | |
| server_port=7860, # Add this line | |
| debug=True | |
| ) |