Update app.py

app.py

@@ -17,7 +17,6 @@ import locale
 try:
     locale.setlocale(locale.LC_ALL, 'en_IN.UTF-8')
 except locale.Error:
-    # fallback if locale not supported on system
     locale.setlocale(locale.LC_ALL, '')
 
 # Configure logging
@@ -54,427 +53,177 @@ equipment_choices = [
     "Bulldozer", "Crane", "Excavator", "Loader", "Forklift",
     "Backhoe", "Grader", "Scraper", "Dump Truck", "Roller"
 ]
-
 project_choices = [
     "Project Alpha", "Project Beta", "Project Gamma", "Project Delta", "Project Epsilon",
     "Project Zeta", "Project Theta", "Project Sigma", "Project Omega", "Project Phoenix"
 ]
-
 ai_suggestion_choices = ["Move", "Pause Rent", "Repair", "Replace"]
 
-# Generate PDF report
-def generate_pdf_report(record_id, data_dict):
-    report_id = str(uuid.uuid4())[:8]
-    report_filename = f"report_{report_id}.pdf"
-    report_path = Path(f"static/reports/{report_filename}")
-    report_path.parent.mkdir(parents=True, exist_ok=True)
-
-    c = canvas.Canvas(str(report_path), pagesize=letter)
+# AI suggestion logic
+def call_ai_model(usage, idle, freq, cost, last):
+    total = usage + idle
+    ratio = usage / total if total > 0 else 0
+    if ratio < 0.3:
+        sug = "Pause Rent"
+    elif ratio < 0.6:
+        sug = "Move"
+    elif ratio < 0.8:
+        sug = "Repair"
+    else:
+        sug = "Replace"
+    conf = min(1.0, ratio + 0.1)
+    score = ratio * 100
+    return sug, conf, score
+
+# Core processing
+def process_equipment_utilization(equip, proj, use_h, idle_h, move_f, cost_h, last_maint, ai_sug):
+    if not ai_sug:
+        ai_sug, conf, score = call_ai_model(use_h, idle_h, move_f, cost_h, last_maint)
+    else:
+        conf, score = 0.9, 85.0
+    summary = {
+        "Equipment Name": equip,
+        "Project": proj,
+        "Usage Hours": use_h,
+        "Idle Hours": idle_h,
+        "Suggestion": ai_sug,
+        "Confidence": conf,
+        "Utilization Score": score,
+        "Cost per Hour": cost_h,
+        "Last Maintenance": last_maint or "N/A"
+    }
+    record_data = {
+        "Equipment_Name__c": equip,
+        "Project_Name__c": proj,
+        "Usage_Hours__c": use_h,
+        "Idle_Hours__c": idle_h,
+        "AI_Suggestion__c": ai_sug,
+        "Suggestion_Confidence__c": conf * 100,
+        "Utilization_Score__c": score,
+        "Cost_per_Hour__c": cost_h,
+        "Report_Link__c": "Pending",
+        "Last_Maintenance__c": last_maint if last_maint != "N/A" else None,
+        "Dashboard_Flag__c": False
+    }
+    resp = sf.Equipment_Utilization_Record__c.create(record_data)
+    rec_id = resp.get("id")
+    # Prepare paths
+    uid = uuid.uuid4().hex[:8]
+    pdf_path = Path(f"static/reports/report_{uid}.pdf")
+    csv_path = Path(f"static/reports/report_{uid}.csv")
+    pdf_path.parent.mkdir(parents=True, exist_ok=True)
+    # Generate PDF
+    c = canvas.Canvas(str(pdf_path), pagesize=letter)
     c.setFont("Helvetica", 12)
-    c.drawString(100, 750, f"Equipment Utilization Report")
-    c.drawString(100, 735, f"Salesforce Record ID: {record_id}")
-
+    c.drawString(100, 750, "Equipment Utilization Report")
+    c.drawString(100, 735, f"Record ID: {rec_id}")
     y = 710
-    for key, val in data_dict.items():
-        c.drawString(100, y, f"{key}: {val}")
-        y -= 20
-
+    for k, v in summary.items(): c.drawString(100, y, f"{k}: {v}"); y -= 20
     c.save()
-    
-    return str(report_path)
-
-# Generate CSV report
-def generate_csv_report(record_id, data_dict):
-    report_id = str(uuid.uuid4())[:8]
-    csv_filename = f"report_{report_id}.csv"
-    csv_path = Path(f"static/reports/{csv_filename}")
-    csv_path.parent.mkdir(parents=True, exist_ok=True)
-
-    with open(csv_path, mode='w', newline='') as f:
-        writer = csv.writer(f)
-        writer.writerow(["Field", "Value"])
-        writer.writerow(["Salesforce Record ID", record_id])
-        for k, v in data_dict.items():
-            writer.writerow([k, v])
-
-    return str(csv_path)
-
-# Upload PDF to Salesforce and get the URL
-def upload_pdf_to_salesforce(pdf_file, record_id=None):
-    try:
-        with open(pdf_file, "rb") as f:
-            file_data = f.read()
-
-        encoded_file_data = base64.b64encode(file_data).decode('utf-8')
-        logger.debug(f"Uploading PDF file for record ID: {record_id}")
-
-        content_version_data = {
-            "Title": f"Equipment Utilization Report",
-            "PathOnClient": f"report_{record_id}.pdf",
-            "VersionData": encoded_file_data,
-        }
-
-        if record_id:
-            content_version_data["FirstPublishLocationId"] = record_id
-
-        content_version = sf.ContentVersion.create(content_version_data)
-        content_version_id = content_version["id"]
-        logger.info(f"PDF uploaded to Salesforce with ContentVersion ID: {content_version_id}")
-
-        # Construct download URL (may need org domain adjustment)
-        file_url = f"https://{sf.sf_instance}/sfc/servlet.shepherd/version/download/{content_version_id}"
-        logger.debug(f"Generated PDF URL: {file_url}")
-        return file_url
-    except Exception as e:
-        logger.error(f"Error uploading PDF to Salesforce: {str(e)}", exc_info=True)
-        return None
-
-def call_ai_model(usage_hours, idle_hours, movement_frequency, cost_per_hour, last_maintenance_str):
-    try:
-        total_time = usage_hours + idle_hours
-        utilization_ratio = usage_hours / total_time if total_time > 0 else 0
-
-        if utilization_ratio < 0.3:
-            suggestion = "Pause Rent"
-        elif utilization_ratio < 0.6:
-            suggestion = "Move"
-        elif utilization_ratio < 0.8:
-            suggestion = "Repair"
-        else:
-            suggestion = "Replace"
-
-        confidence = min(1.0, utilization_ratio + 0.1)
-        utilization_score = utilization_ratio * 100
-
-        logger.info(f"AI Model Prediction: suggestion={suggestion}, confidence={confidence:.2f}, utilization_score={utilization_score:.2f}")
-
-        return suggestion, confidence, utilization_score
-
-    except Exception as e:
-        logger.error(f"Error in AI model prediction: {e}")
-        return "No Action", 0.0, 0.0
-
-def process_equipment_utilization(equipment_name, project_name, usage_hours, idle_hours,
-                                  movement_frequency, cost_per_hour, last_maintenance, ai_suggestion):
-    
-    if not ai_suggestion:
-        last_maintenance_str = last_maintenance.strftime('%Y-%m-%d') if last_maintenance else ""
-        ai_suggestion, suggestion_confidence, utilization_score = call_ai_model(
-            usage_hours, idle_hours, movement_frequency, cost_per_hour, last_maintenance_str
-        )
-    else:
-        suggestion_confidence = 0.9
-        utilization_score = 85.0
-
-    summary_data = {
-        "Equipment Name": equipment_name,
-        "Project": project_name,
-        "Usage Hours": usage_hours,
-        "Idle Hours": idle_hours,
-        "Suggestion": ai_suggestion,
-        "Confidence": suggestion_confidence,
-        "Utilization Score": utilization_score,
-        "Cost per Hour": cost_per_hour,
-        "Last Maintenance": last_maintenance.strftime('%Y-%m-%d') if last_maintenance else "N/A"
-    }
-
-    try:
-        record_data = {
-            "Equipment_Name__c": equipment_name,
-            "Project_Name__c": project_name,
-            "Usage_Hours__c": usage_hours,
-            "Idle_Hours__c": idle_hours,
-            "AI_Suggestion__c": ai_suggestion,
-            "Suggestion_Confidence__c": suggestion_confidence * 100,  # Convert 0–1 to 0–100
-            "Utilization_Score__c": utilization_score,
-            "Cost_per_Hour__c": cost_per_hour,
-            "Report_Link__c": "Pending",
-            "Last_Maintenance__c": last_maintenance.strftime('%Y-%m-%d') if last_maintenance else None,
-            "Dashboard_Flag__c": False
-        }
-        logger.info(f"Creating Salesforce record with data: {record_data}")
-
-        response = sf.Equipment_Utilization_Record__c.create(record_data)
-        record_id = response.get("id")
-        logger.info(f"Successfully created Salesforce record with ID: {record_id}")
-
-        # Generate PDF and CSV reports and upload the PDF to Salesforce
-        pdf_path = generate_pdf_report(record_id, summary_data)
-        pdf_url = upload_pdf_to_salesforce(pdf_path, record_id)
-
-        # Update the Salesforce record with the PDF URL
-        sf.Equipment_Utilization_Record__c.update(record_id, {"Report_Link__c": pdf_url})
-        logger.info(f"Updated Salesforce record {record_id} with Report_Link__c: {pdf_url}")
-
-        return {
-            "Salesforce_Record_Id": record_id,
-            "status": "Success",
-            "AI_Suggestion": ai_suggestion,
-            "Suggestion_Confidence": suggestion_confidence,
-            "Utilization_Score": utilization_score,
-            "Report_Link": pdf_url,
-            "CSV_Report_Link": generate_csv_report(record_id, summary_data),
-            "Summary": summary_data,
-            "Report_File_Path": pdf_path
-        }
-    except Exception as e:
-        logger.error(f"Error creating or updating Salesforce record: {e}")
-        return {"error": str(e)}
-
-def process_csv_upload(csv_file_path):
-    try:
-        expected_columns = [
-            "equipment_name", "project_name", "usage_hours", "idle_hours",
-            "movement_frequency", "cost_per_hour", "last_maintenance", "ai_suggestion"
-        ]
-        
-        df = pd.read_csv(csv_file_path)
-        df.columns = df.columns.str.strip()
-
-        if not df.columns.tolist() or all(col == '' for col in df.columns):
-            return {"error": "CSV file has no header row. Required columns: " + ", ".join(expected_columns)}
-        
-        if not all(col in df.columns for col in expected_columns):
-            missing_cols = [col for col in expected_columns if col not in df.columns]
-            sample_row = ",".join(expected_columns)
-            return {"error": f"Missing columns: {', '.join(missing_cols)}. Expected: {', '.join(expected_columns)}. Sample row: {sample_row}"}
-        
-        results = []
-        for index, row in df.iterrows():
-            try:
-                equipment_name = str(row["equipment_name"]).strip()
-                project_name = str(row["project_name"]).strip()
-                
-                if equipment_name not in equipment_choices:
-                    results.append({"row": index + 1, "status": "Failed", "error": f"Invalid equipment_name: {equipment_name}. Must be one of: {', '.join(equipment_choices)}"})
-                    continue
-                if project_name not in project_choices:
-                    results.append({"row": index + 1, "status": "Failed", "error": f"Invalid project_name: {project_name}. Must be one of: {', '.join(project_choices)}"})
-                    continue
-
-                usage_hours = float(row["usage_hours"])
-                idle_hours = float(row["idle_hours"])
-                movement_frequency = float(row["movement_frequency"])
-                cost_per_hour = float(row["cost_per_hour"])
-                
-                last_maintenance = str(row["last_maintenance"]).strip()
-                if last_maintenance.lower() in ["", "nan", "none"]:
-                    last_maintenance = None
-                else:
-                    last_maintenance = datetime.datetime.strptime(last_maintenance, "%Y-%m-%d")
-
-                ai_suggestion = str(row["ai_suggestion"]).strip()
-                if ai_suggestion.lower() in ["", "nan", "none"]:
-                    ai_suggestion = ""
-                else:
-                    if ai_suggestion not in ai_suggestion_choices:
-                        results.append({"row": index + 1, "status": "Failed", "error": f"Invalid ai_suggestion: {ai_suggestion}. Must be one of: {', '.join(ai_suggestion_choices)}"})
-                        continue
-
-                result = process_equipment_utilization(
-                    equipment_name=equipment_name,
-                    project_name=project_name,
-                    usage_hours=usage_hours,
-                    idle_hours=idle_hours,
-                    movement_frequency=movement_frequency,
-                    cost_per_hour=cost_per_hour,
-                    last_maintenance=last_maintenance,
-                    ai_suggestion=ai_suggestion
-                )
-
-                if "error" in result:
-                    results.append({"row": index + 1, "status": "Failed", "error": result["error"]})
-                else:
-                    results.append({"row": index + 1, "status": "Success", "record_id": result["Salesforce_Record_Id"]})
-
-            except Exception as e:
-                logger.error(f"Error processing row {index + 1}: {str(e)}")
-                results.append({"row": index + 1, "status": "Failed", "error": str(e)})
-
-        return {"results": results, "total_rows": len(df), "processed": len(results)}
-
-    except Exception as e:
-        logger.error(f"Error processing CSV file: {str(e)}")
-        return {"error": f"Failed to process CSV file: {str(e)}"}
-
-def format_output_for_display(result):
-    if "error" in result:
-        return f"❌ Error: {result['error']}"
-
+    # Generate CSV
+    with open(csv_path, "w", newline="") as f:
+        w = csv.writer(f)
+        w.writerow(["Field", "Value"])
+        w.writerow(["Record ID", rec_id])
+        [w.writerow([k, v]) for k, v in summary.items()]
+    # Upload PDF
+    encoded = base64.b64encode(pdf_path.read_bytes()).decode()
+    cv = sf.ContentVersion.create({
+        "Title": "UtilReport",
+        "PathOnClient": os.path.basename(str(pdf_path)),
+        "VersionData": encoded,
+        "FirstPublishLocationId": rec_id
+    })
+    pdf_url = f"https://{sf.sf_instance}/sfc/servlet.shepherd/version/download/{cv['id']}"
+    sf.Equipment_Utilization_Record__c.update(rec_id, {"Report_Link__c": pdf_url})
+    return {"Salesforce_Record_Id": rec_id, "Summary": summary, "Report_Link": pdf_url, "CSV_Report_Link": str(csv_path)}
+
+# Format output
+def format_output(result):
     summary = result.get("Summary", {})
-    
-    # Format cost per hour as Indian currency if present
-    cost_per_hour = summary.get("Cost per Hour", 0)
+    # Cost formatting
+    cost_val = summary.get("Cost per Hour", 0)
     try:
-        cost_per_hour_formatted = locale.currency(cost_per_hour, grouping=True)
-    except Exception:
-        cost_per_hour_formatted = f"₹{cost_per_hour:,.2f}"
-    
-    confidence_percent = result.get('Suggestion_Confidence', 0) * 100
-    utilization_score = result.get('Utilization_Score', 0)
-    # Handle utilization_score: if decimal <= 1, convert to percentage
-    if utilization_score <= 1:
-        utilization_score_percent = utilization_score * 100
-    else:
-        utilization_score_percent = utilization_score
-
+        cost_str = locale.currency(cost_val, grouping=True)
+    except:
+        cost_str = f"₹{cost_val:,.2f}"
+    conf_pct = summary.get("Confidence", 0) * 100
+    util_score = summary.get("Utilization Score", 0)
+    if util_score <= 1: util_score *= 100
     lines = [
         "📋 **Equipment Utilization Record :**",
-        f"• AI Suggestion: {result.get('AI_Suggestion', 'N/A')}",
-        f"• Suggestion Confidence: {confidence_percent:.2f}%",
-        f"• Utilization Score: {utilization_score_percent:.2f}%",
+        f"• AI Suggestion: {summary.get('Suggestion', 'N/A')}",
+        f"• Suggestion Confidence: {conf_pct:.2f}%",
+        f"• Utilization Score: {util_score:.2f}%",
         f"• Report Link: {result.get('Report_Link', 'N/A')}",
-        f"• CSV Report Link: {result.get('CSV_Report_Link', 'N/A')}",
+        f"• CSV Report Link: {result.get('CSV_REPORT_Link', 'N/A')}",
         "",
-        "🔹 "
-        f"   • Equipment Name: {summary.get('Equipment Name', 'N/A')}",
-        f"   • Project: {summary.get('Project', 'N/A')}",
+        "🔹   • Equipment Name: " + summary.get("Equipment Name", "N/A"),
+        "   • Project: "        + summary.get("Project", "N/A"),
         f"   • Usage Hours: {summary.get('Usage Hours', 0):.2f}",
         f"   • Idle Hours: {summary.get('Idle Hours', 0):.2f}",
-        f"   • Cost per Hour: {cost_per_hour_formatted}",
-        f"   • Last Maintenance: {summary.get('Last Maintenance', 'N/A')}"
+        "   • Cost per Hour: " + cost_str,
+        "   • Last Maintenance: " + summary.get("Last Maintenance", "N/A")
     ]
-
     return "\n".join(lines)
 
-def gradio_upload_process(equipment_name, project_name, usage_hours, idle_hours,
-                         movement_frequency, cost_per_hour, last_maintenance, ai_suggestion):
-    try:
-        usage_hours = float(usage_hours)
-        idle_hours = float(idle_hours)
-        movement_frequency = float(movement_frequency)
-        cost_per_hour = float(cost_per_hour)
-    except Exception as e:
-        return {"error": f"Invalid numeric input: {str(e)}"}, None
-
-    try:
-        last_maintenance_dt = datetime.datetime.strptime(last_maintenance, "%Y-%m-%d") if last_maintenance else None
-    except Exception as e:
-        return {"error": f"Invalid date format for Last Maintenance (expected YYYY-MM-DD): {str(e)}"}, None
-
-    result = process_equipment_utilization(
-        equipment_name,
-        project_name,
-        usage_hours,
-        idle_hours,
-        movement_frequency,
-        cost_per_hour,
-        last_maintenance_dt,
-        ai_suggestion
-    )
-    
-    formatted_output = format_output_for_display(result)
-    # Return the formatted output and generated PDF file path
-    report_file_path = result.get("Report_File_Path")
-    return formatted_output, report_file_path
-
-# Gradio Interface
-with gr.Blocks() as app:
-    gr.Markdown("## 📋 Equipment Utilization Record Uploader")
-    gr.Markdown("Fill in the details below to generate AI suggestions and save them to Salesforce.")
-
-    with gr.Group():
-        with gr.Row():
-            equipment_dropdown = gr.Dropdown(choices=equipment_choices, label="🔧 Equipment Name", interactive=True)
-            project_dropdown = gr.Dropdown(choices=project_choices, label="🏍️ Project Name", interactive=True)
-            ai_suggestion_dropdown = gr.Dropdown(choices=[""] + ai_suggestion_choices, label="🧐 AI Suggestion", interactive=True)
-
-        gr.Markdown("---")
-
-        with gr.Row():
-            usage_hours = gr.Number(label="⏱️ Usage Hours", value=0, minimum=0)
-            idle_hours = gr.Number(label="🕒 Idle Hours", value=0, minimum=0)
-
-        with gr.Row():
-            movement_frequency = gr.Number(label="📈 Movement Frequency", value=0, minimum=0)
-            cost_per_hour = gr.Number(label="💰 Cost per Hour", value=0, minimum=0)
-
-        with gr.Row():
-            last_maintenance = gr.Textbox(label="🛠️ Last Maintenance Date (YYYY-MM-DD)", placeholder="Optional")
-
-        gr.Markdown("---")
-
-        with gr.Row():
-            submit_button = gr.Button("🚀 Submit", variant="primary")
-            clear_button = gr.Button("🧹 Clear")
-
-        # Add a headline separate from results box
-        result_headline = gr.Markdown("### 📝 Equipment Record Details", elem_id="result-headline")
-
-        # Result box with border lines
-        output = gr.Markdown(label="📄 Equipment Record Data", elem_id="result-box")
-
-        report_file_output = gr.File(label="📃 Download PDF Report", interactive=False)
-
-        submit_button.click(
-            fn=gradio_upload_process,
-            inputs=[
-                equipment_dropdown, project_dropdown,
-                usage_hours, idle_hours,
-                movement_frequency, cost_per_hour,
-                last_maintenance, ai_suggestion_dropdown
-            ],
-            outputs=[output, report_file_output]
-        )
-        clear_button.click(
-            fn=lambda: ("", None),
-            inputs=[],
-            outputs=[output, report_file_output]
-        )
-
-        # CSV Upload
-        csv_upload = gr.File(label="📂 Upload CSV file", file_types=[".csv"])
-        csv_output = gr.JSON(label="📄 Batch Upload Results")
-
-        csv_upload.change(
-            fn=lambda file: process_csv_upload(file.name) if file else {},
-            inputs=csv_upload,
-            outputs=csv_output
+# Gradio callbacks
+
+def manual_input(equipment, project, usage, idle, freq, cost, last, ai_suggestion):
+    last_val = last or "N/A"
+    res = process_equipment_utilization(equipment, project, usage, idle, freq, cost, last_val, ai_suggestion)
+    formatted = format_output(res)
+    return formatted, res.get("Report_Link")
+
+def batch_upload(csv_file):
+    if not csv_file: return {}
+    df = pd.read_csv(csv_file.name)
+    ids = []
+    for _, row in df.iterrows():
+        rec = process_equipment_utilization(
+            row['equipment_name'], row['project_name'],
+            float(row['usage_hours']), float(row['idle_hours']),
+            float(row['movement_frequency']), float(row['cost_per_hour']),
+            row.get('last_maintenance','N/A'), row.get('ai_suggestion','')
         )
+        ids.append(rec['Salesforce_Record_Id'])
+    return {"records": ids}
 
+# Interface
+with gr.Blocks() as app:
+    gr.Markdown("## 📋 Equipment Utilization Record Uploader", elem_id="app-title")
+    with gr.Tabs():
+        with gr.TabItem("Manual Input"):
+            with gr.Group():
+                equipment_dropdown = gr.Dropdown(equipment_choices, label="🔧 Equipment Name")
+                project_dropdown   = gr.Dropdown(project_choices,  label="🏍️ Project Name")
+                ai_dropdown        = gr.Dropdown([""] + ai_suggestion_choices, label="🧐 AI Suggestion")
+            with gr.Group():
+                with gr.Row():
+                    usage = gr.Number(label="⏱️ Usage Hours", value=0, minimum=0)
+                    idle  = gr.Number(label="🕒 Idle Hours", value=0, minimum=0)
+                with gr.Row():
+                    freq = gr.Number(label="📈 Movement Frequency", value=0, minimum=0)
+                    cost = gr.Number(label="💰 Cost per Hour",     value=0, minimum=0)
+                last           = gr.Textbox(label="🛠️ Last Maintenance Date (YYYY-MM-DD)", placeholder="Optional")
+                submit_btn     = gr.Button("🚀 Submit", variant="primary")
+                result_txt     = gr.Markdown(elem_id="result-box")
+                report_file    = gr.File(label="📃 Download PDF Report")
+                submit_btn.click(
+                    fn=manual_input,
+                    inputs=[equipment_dropdown, project_dropdown, usage, idle, freq, cost, last, ai_dropdown],
+                    outputs=[result_txt, report_file]
+                )
+        with gr.TabItem("CSV Upload"):
+            with gr.Group():
+                csv_file   = gr.File(label="📂 Upload CSV file", file_types=[".csv"])
+                csv_output = gr.JSON(label="📄 Batch Upload Results")
+                csv_file.change(fn=batch_upload, inputs=csv_file, outputs=csv_output)
     app.css = """
-        .gradio-container {
-            background-color: #000000 !important;
-            padding: 20px;
-            color: #ffffff !important;
-        }
-        .gr-button-primary {
-            background-color: #1e90ff !important;
-            color: white !important;
-        }
-        .gr-button-primary:hover {
-            background-color: #0d6efd !important;
-        }
-        #result-headline {
-            margin-top: 25px;
-            margin-bottom: 8px;
-            color: #1e90ff;
-            font-weight: 700;
-            font-size: 22px;
-            border-bottom: 2px solid #1e90ff;
-            padding-bottom: 6px;
-        }
-        #result-box {
-            font-size: 16px;
-            font-weight: 600;
-            color: #ffffff !important;
-            border: 3px solid #1e90ff;
-            border-radius: 10px;
-            padding: 20px;
-            background-color: #141414;
-            white-space: pre-line;
-            min-height: 200px;
-        }
-        label {
-            font-weight: 500;
-            color: #ffffff !important;
-        }
-        input, textarea, select {
-            background-color: #1c1c1c !important;
-            color: #ffffff !important;
-            border: 1px solid #444 !important;
-        }
-    """
-
+.gradio-container { background-color: #ffffff !important; }
+#app-title { text-align: center !important; }
+.gradio-container .gr-group { background-color: #d3d3d3 !important; padding: 20px; border: 3px solid #d3d3d3 !important; border-radius: 10px; }
+#result-box { border: 3px solid #d3d3d3 !important; border-radius: 10px; padding: 10px; background: #f9f9f9; }
+"""
 if __name__ == "__main__":
     app.launch()