Update app.py

app.py

@@ -1,126 +1,95 @@
 import gradio as gr
 import pandas as pd
 import numpy as np
-from sklearn.linear_model import LinearRegression
-from PIL import Image
+from fpdf import FPDF
 import datetime
+import os
 
-# --- 2026 DYNAMIC MARKET DATA & CONFIG ---
-MARKET_DATA = {
-    "panel_pkr_per_watt": 32,      # Tier-1 N-Type/Bifacial
-    "avg_sun_hours": 5.2,          # Pakistan Yearly Average
-    "import_rate": 55.0,           # PKR/unit including taxes
-    "export_rate": 11.0,           # NEPRA Prosumer Regs 2026
-    "li_battery_pkr_kwh": 48000,   # LiFePO4 pricing
-    "installation_fee": 0.15,      # 15% markup for BOS
-    "bank_rate": 0.14              # 14% Solar Financing Rate
+# --- 2026 MARKET DATA CONFIG ---
+CONFIG = {
+    "panel_pkr_watt": 32,
+    "sun_hours": 5.2,
+    "grid_rate": 55.0,
+    "buyback_rate": 11.0,
+    "li_battery_kwh": 48000,
+    "markup": 0.15,
 }
 
-APPLIANCES = {
-    "LED Bulb (12W)": 12, "Ceiling Fan (80W)": 80, "Inverter AC (1.5 Ton)": 1500,
-    "Refrigerator": 250, "Water Pump (1HP)": 746, "Washing Machine": 500
-}
-
-# --- MODULE 1: ML-BASED LOAD PREDICTION (V2) ---
-def predict_seasonal_load(avg_monthly_units):
-    """Simple ML model to predict peak summer load based on average units."""
-    # Dummy data: Training correlation between avg units and peak monthly units
-    X = np.array([[200], [400], [600], [800], [1000]])
-    y = np.array([[310], [580], [890], [1150], [1400]]) # Summer peaks
-    model = LinearRegression().fit(X, y)
-    prediction = model.predict([[avg_monthly_units]])
-    return float(prediction[0][0])
+# --- MODULE: BANK API INTEGRATION ---
+def fetch_bank_rates():
+    """
+    Simulated API call to Bank Alfalah/JS Bank for 2026 Solar Financing.
+    In production, use: requests.get('https://api.bankalfalah.com/rates')
+    """
+    return {"interest_rate": 0.14, "tenure_months": 60, "bank_name": "Bank Alfalah"}
 
-# --- MODULE 2: CORE ENGINEERING LOGIC ---
-def calculate_solar_system(selected_apps, app_counts, system_type, backup_hrs, units_input):
-    # Calculate Load
-    total_watts = sum([APPLIANCES[app] * count for app, count in zip(selected_apps, app_counts) if app])
-    daily_kwh = (total_watts * 8) / 1000  # Default 8h usage if no bill provided
+# --- MODULE: PDF GENERATOR ---
+def generate_report(load, size, cost, emi, roi):
+    pdf = FPDF()
+    pdf.add_page()
+    pdf.set_font("Arial", 'B', 16)
+    pdf.cell(200, 10, "Solar Solution Report - Pakistan 2026", ln=True, align='C')
     
-    if units_input > 0:
-        peak_monthly = predict_seasonal_load(units_input)
-        daily_kwh = peak_monthly / 30
-
-    # System Size (20% losses)
-    required_kw = (daily_kwh / MARKET_DATA["avg_sun_hours"]) * 1.2
-    required_kw = round(max(required_kw, 3.0), 1) # Min 3kW for net billing logic
+    pdf.set_font("Arial", size=12)
+    pdf.ln(10)
+    pdf.cell(200, 10, f"Date: {datetime.datetime.now().strftime('%Y-%m-%d')}", ln=True)
+    pdf.cell(200, 10, f"Total Connected Load: {load} Watts", ln=True)
+    pdf.cell(200, 10, f"Recommended System Size: {size} kW", ln=True)
+    pdf.cell(200, 10, f"Estimated Total Investment: PKR {cost:,}", ln=True)
+    pdf.cell(200, 10, f"Monthly EMI Plan: PKR {emi:,}/month", ln=True)
+    pdf.cell(200, 10, f"Estimated Payback Period: {roi} Years", ln=True)
+    
+    report_path = "Solar_Report_PK.pdf"
+    pdf.output(report_path)
+    return report_path
 
+# --- CORE LOGIC ---
+def solar_engine(app_selection, counts, sys_type, backup_hrs):
+    # Load math (20% losses included)
+    watts_map = {"AC": 1500, "Fan": 80, "Fridge": 250, "Lights": 12}
+    total_watts = sum([watts_map[k] for k in app_selection])
+    
+    daily_units = (total_watts * 10) / 1000 # Avg 10h usage
+    sys_size = round((daily_units / CONFIG["sun_hours"]) * 1.2, 1)
+    
+    panel_cost = sys_size * 1000 * CONFIG["panel_pkr_watt"]
+    battery_cost = (daily_units * (backup_hrs/24) * CONFIG["li_battery_kwh"])
+    
+    total_cost = int((panel_cost + battery_cost + 200000) * (1 + CONFIG["markup"]))
+    
     # Financials
-    panel_cost = required_kw * 1000 * MARKET_DATA["panel_pkr_per_watt"]
-    inverter_costs = {"On-Grid": 150000, "Hybrid": 280000, "Off-Grid": 220000}
-    inv_cost = inverter_costs[system_type] * (required_kw / 5) # Scaled to 5kW base
+    bank = fetch_bank_rates()
+    p = total_cost * 0.8
+    r = bank["interest_rate"] / 12
+    n = bank["tenure_months"]
+    emi = int(p * (r * (1+r)**n) / ((1+r)**n - 1))
     
-    battery_cost = (daily_kwh * (backup_hrs/24) * MARKET_DATA["li_battery_pkr_kwh"]) if backup_hrs > 0 else 0
+    roi = round(total_cost / (daily_units * 365 * 45), 1)
     
-    total_investment = (panel_cost + inv_cost + battery_cost) * (1 + MARKET_DATA["installation_fee"])
+    pdf_file = generate_report(total_watts, sys_size, total_cost, emi, roi)
     
-    # ROI (Net Billing Logic)
-    # Savings = (Generated Units * Grid Rate) - (Adjustment for Export rate diff)
-    annual_gen = required_kw * MARKET_DATA["avg_sun_hours"] * 365
-    annual_savings = annual_gen * (MARKET_DATA["import_rate"] * 0.7 + MARKET_DATA["export_rate"] * 0.3)
-    payback = total_investment / annual_savings
-
-    # EMI (5 Year Tenure)
-    p = total_investment * 0.8 # 20% Downpayment
-    r = MARKET_DATA["bank_rate"] / 12
-    n = 60
-    emi = p * (r * (1+r)**n) / ((1+r)**n - 1)
-
-    return total_watts, required_kw, int(total_investment), round(payback, 1), int(emi)
-
-# --- MODULE 3: ADMIN & OCR (STUBS) ---
-def ocr_bill(image):
-    return 450 # Mocking 450 units detected from bill image
+    summary = f"""### 📋 System Insights
+    - **Size:** {sys_size} kW
+    - **Total Cost:** PKR {total_cost:,}
+    - **EMI:** PKR {emi:,}/mo ({bank['bank_name']})
+    """
+    return summary, pdf_file
 
 # --- GRADIO UI ---
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# ☀️ SolarExpert PK v2.0 (2026 Edition)\n### AI-Powered Solar Estimation & Net Billing Analysis")
+with gr.Blocks(theme=gr.themes.Default()) as demo:
+    gr.Markdown("# ☀️ Solar Consultant Pro (Pakistan)")
     
-    with gr.Tab("1. Consumption Analysis"):
-        with gr.Row():
-            bill_img = gr.Image(label="Upload Last Month's Bill (OCR)", type="pil")
-            units_in = gr.Number(label="Or Enter Monthly Units (kWh)", value=300)
-        
-        app_select = gr.CheckboxGroup(choices=list(APPLIANCES.keys()), label="Select Priority Appliances")
-        app_counts = gr.Dataframe(headers=["Quantity"], row_count=len(APPLIANCES), col_count=1, interactive=True, value=[[1]]*len(APPLIANCES))
-
-    with gr.Tab("2. System Configuration"):
-        sys_type = gr.Radio(["On-Grid", "Hybrid", "Off-Grid"], label="System Architecture", value="Hybrid")
-        backup = gr.Slider(0, 12, step=1, label="Battery Backup (Hours)")
-        calc_btn = gr.Button("Generate Production Report", variant="primary")
-
-    with gr.Tab("3. Results & Financials"):
-        with gr.Row():
-            res_kw = gr.Label(label="Required System Size (kW)")
-            res_cost = gr.Label(label="Estimated Price (PKR)")
-            res_emi = gr.Label(label="Monthly EMI (Bank Alfalah/JS)")
-        
-        roi_plot = gr.Markdown()
-        
-    with gr.Accordion("Admin Dashboard & Installer Contact", open=False):
-        gr.Markdown("Contacting nearest AEDB Certified Installers...")
-        name = gr.Textbox(label="Full Name")
-        phone = gr.Textbox(label="WhatsApp Number")
-        gr.Button("Request Official Quote")
-
-    # Mapping Logic
-    def run_engine(img, units, apps, counts, stype, bkp):
-        if img: units = ocr_bill(img)
-        counts_list = [row[0] for row in counts]
-        load, kw, cost, roi, emi = calculate_solar_system(apps, counts_list, stype, bkp, units)
-        
-        roi_report = f"""
-        ### Financial Feasibility
-        * **Payback Period:** {roi} Years
-        * **Annual Energy Yield:** ~{int(kw * 1500)} Units
-        * **Monthly Savings:** PKR {int((kw * 1500 * 45)/12):,}
-        
-        > **Note:** Calculations include a 20% system loss factor and 2026 Net Billing buyback rates.
-        """
-        return f"{kw} kW", f"PKR {cost:,}", f"PKR {emi:,}/mo", roi_report
+    with gr.Row():
+        with gr.Column():
+            apps = gr.CheckboxGroup(["AC", "Fan", "Fridge", "Lights"], label="Appliances")
+            sys = gr.Dropdown(["On-Grid", "Hybrid", "Off-Grid"], label="System Type", value="Hybrid")
+            bkp = gr.Slider(0, 12, value=4, label="Battery Backup (Hours)")
+            btn = gr.Button("Analyze & Generate PDF", variant="primary")
+            
+        with gr.Column():
+            out_md = gr.Markdown()
+            out_pdf = gr.File(label="Download Full Report")
 
-    calc_btn.click(run_engine, 
-                  inputs=[bill_img, units_in, app_select, app_counts, sys_type, backup], 
-                  outputs=[res_kw, res_cost, res_emi, roi_plot])
+    btn.click(solar_engine, inputs=[apps, gr.State(1), sys, bkp], outputs=[out_md, out_pdf])
 
 demo.launch()