app.py

import os
import pandas as pd
import streamlit as st
import matplotlib.pyplot as plt
import numpy as np

from groq import Groq

# Initialize Groq API using environment variable
GROQ_API_KEY = os.getenv('GROQ_API_KEY')  # The API key should be set as an environment variable
client = Groq(api_key=GROQ_API_KEY)

# Load datasets with the new caching command
@st.cache_data
def load_data():
    inverter_file_path = 'inverters_update.xlsx'  # Path to your inverters dataset
    solar_panel_file_path = 'solar_update.xlsx'  # Path to your updated solar panels dataset
    inverter_dataset = pd.read_excel(inverter_file_path)
    solar_panel_dataset = pd.read_excel(solar_panel_file_path)
    return inverter_dataset, solar_panel_dataset

inverter_dataset, solar_panel_dataset = load_data()

# Clean datasets
inverter_dataset['Cost (PKR)'] = inverter_dataset['Cost (PKR)'].replace(r'\D', '', regex=True).astype(int)
solar_panel_dataset['Cost (PKR)'] = solar_panel_dataset['Cost (PKR)'].replace(r'\D', '', regex=True).astype(int)
solar_panel_dataset['Power Rating (W)'] = solar_panel_dataset['Power Rating (W)'].replace(r'\D', '', regex=True).astype(int)
solar_panel_dataset['Efficiency %'] = solar_panel_dataset['Efficiency %'].replace(r'\D', '', regex=True).astype(float)
solar_panel_dataset['Warranty (Years)'] = solar_panel_dataset['Warranty (Years)'].replace(r'\D', '', regex=True).astype(int)

# Streamlit User Interface for inputs
st.title("Solar System Recommendation Tool")
required_power_kW = st.number_input("Enter Required System Power (kW)", min_value=1.0, step=0.5, value=8.0)
peak_sun_hours = 5  # Fixed value

# Inverter recommendation logic (with Efficiency and Warranty filters)
suitable_inverters = inverter_dataset[
    (inverter_dataset['Power_Rating(kW)'] >= required_power_kW) & 
    (inverter_dataset['Efficiency %'] >= 90)
]

if suitable_inverters.empty:
    recommended_inverter = None
else:
    recommended_inverter = suitable_inverters.sort_values(
        by=['Cost (PKR)', 'Efficiency %', 'Warranty (Years)'], 
        ascending=[True, False, False]
    ).iloc[0]

# Solar Panel Recommendation Logic
if recommended_inverter is not None:
    total_panel_power_watts = recommended_inverter['Power_Rating(kW)'] * 1000  # Inverter's power in W
    solar_panel_dataset['Panels_Required'] = (
        total_panel_power_watts / solar_panel_dataset['Power Rating (W)']
    ).apply(lambda x: int(x) + (x % 1 > 0))  # Ceiling to the next whole number
    solar_panel_dataset['Total_Cost'] = solar_panel_dataset['Panels_Required'] * solar_panel_dataset['Cost (PKR)']

    # Calculate total roof area required based on panel dimensions
    def calculate_roof_area(dimensions, panels_required):
        length, width, _ = map(float, dimensions.replace('×', 'x').split('x'))  # Replace '×' with 'x' and split
        area_per_panel = length * width / 1e6  # Convert mm^2 to m^2
        total_area = area_per_panel * panels_required
        return total_area

    solar_panel_dataset['Total_Area_Required (m^2)'] = solar_panel_dataset.apply(
        lambda row: calculate_roof_area(row['Dimensions'], row['Panels_Required']), axis=1
    )

    # Recommend the most cost-effective solar panel setup
    recommended_solar_panel = solar_panel_dataset.sort_values(by='Total_Cost').iloc[0]
else:
    recommended_solar_panel = None

# Display Recommendations
if recommended_inverter is not None:
    st.subheader("Recommended Inverter:")
    st.write(f"Inverter Name: {recommended_inverter['Inverter']}")
    st.write(f"Power Rating: {recommended_inverter['Power_Rating(kW)']} kW")
    st.write(f"Efficiency: {recommended_inverter['Efficiency %']}%")
    st.write(f"Warranty: {recommended_inverter['Warranty (Years)']} years")
    st.write(f"Cost: {recommended_inverter['Cost (PKR)']:,.0f} PKR")

    st.subheader("Recommended Solar Panel:")
    st.write(f"Solar Panel Model: {recommended_solar_panel['Solar Panel Model']}")
    st.write(f"Power Rating: {recommended_solar_panel['Power Rating (W)']} W")
    st.write(f"Number of Panels Required: {recommended_solar_panel['Panels_Required']}")
    st.write(f"Total Cost: {recommended_solar_panel['Total_Cost']:,.0f} PKR")
    st.write(f"Total Roof Area Required: {recommended_solar_panel['Total_Area_Required (m^2)']:.2f} m²")

    # Total System Cost Calculation
    total_system_cost = recommended_inverter['Cost (PKR)'] + recommended_solar_panel['Total_Cost']
    st.write(f"**Total PV System Cost: {total_system_cost:,.0f} PKR**")

    # Return on Investment (ROI) Estimate (Example: assume yearly savings)
    yearly_savings = 60000  # Placeholder for estimated yearly savings from solar system
    roi = total_system_cost / yearly_savings  # Number of years to recover the cost
    st.write(f"**Estimated Return on Investment (ROI): {roi:.2f} years**")

    # Graphical representation of the total system cost vs yearly savings
    st.subheader("Graphical Analysis of Total System Cost vs. Yearly Savings")
    fig, ax = plt.subplots()
    ax.bar(["Total System Cost", "Yearly Savings"], [total_system_cost, yearly_savings], color=['blue', 'green'])
    ax.set_title("Total System Cost vs Yearly Savings")
    ax.set_ylabel("Amount (PKR)")
    st.pyplot(fig)

    # SolarWise Analysis Section
    st.subheader("SolarWise Summary:")
    analysis_data = {
        "Category": [
            "Inverter Details",
            "Solar Panel Details",
            "Total System Cost",
            "Estimated ROI",
            "Total Roof Area Required"
        ],
        "Details": [
            f"Name: {recommended_inverter['Inverter']}, Power Rating: {recommended_inverter['Power_Rating(kW)']} kW, "
            f"Efficiency: {recommended_inverter['Efficiency %']}%, Warranty: {recommended_inverter['Warranty (Years)']} years, "
            f"Cost: {recommended_inverter['Cost (PKR)']:,.0f} PKR",
            f"Model: {recommended_solar_panel['Solar Panel Model']}, Power Rating: {recommended_solar_panel['Power Rating (W)']} W, "
            f"Number of Panels: {recommended_solar_panel['Panels_Required']}, Total Cost: {recommended_solar_panel['Total_Cost']:,.0f} PKR",
            f"{total_system_cost:,.0f} PKR",
            f"{roi:.2f} years",
            f"{recommended_solar_panel['Total_Area_Required (m^2)']:.2f} m²"
        ]
    }
    analysis_df = pd.DataFrame(analysis_data)
    st.table(analysis_df)

else:
    st.write("No suitable inverter or solar panel found within the specified criteria.")

# Groq API Interaction (Refined Recommendation)
recommendation_message = (
    f"**System Overview:**\n"
    f" - Inverter Name: {recommended_inverter['Inverter'] if recommended_inverter is not None else 'N/A'}\n"
    f" - Inverter Power Rating: {recommended_inverter['Power_Rating(kW)'] if recommended_inverter is not None else 'N/A'} kW\n"
    f" - Inverter Efficiency: {recommended_inverter['Efficiency %'] if recommended_inverter is not None else 'N/A'}%\n"
    f" - Inverter Warranty: {recommended_inverter['Warranty (Years)'] if recommended_inverter is not None else 'N/A'} years\n"
    f" - Solar Panel Model: {recommended_solar_panel['Solar Panel Model'] if recommended_solar_panel is not None else 'N/A'}\n"
    f" - Solar Panel Power Rating: {recommended_solar_panel['Power Rating (W)'] if recommended_solar_panel is not None else 'N/A'} W\n"
    f" - Number of Panels: {recommended_solar_panel['Panels_Required'] if recommended_solar_panel is not None else 'N/A'}\n"
    f" - Total System Cost: {total_system_cost :,.0f} PKR\n\n"
    f"**Estimated Energy Output:**\n"
    f" - Daily Output: ~{int(total_panel_power_watts * peak_sun_hours / 1000)} kWh\n"
    f" - Yearly Output: ~{int(total_panel_power_watts * peak_sun_hours * 365 / 1000)} kWh\n\n"
    f"**Estimated Financial Benefits:**\n"
    f" - Yearly Savings: ~{yearly_savings:,.0f} PKR\n"
    f" - ROI (Payback Period): ~{roi:.2f} years\n\n"
    f"**Environmental Impact:**\n"
    f" - CO2 Emissions Avoided (Yearly): ~{int(total_panel_power_watts * peak_sun_hours * 365 * 0.85 / 1000)} kg\n"
    f"   (Assumes 0.85 kg CO2 per kWh for grid electricity)\n\n"
    f"**Additional Notes:**\n"
    f" - Installation, PV panel structure, Cables, Distribution box, Circuit breakers,Net Metering and labor costs are not included in the total cost.\n"
    f" - These additional costs are estimated to be between 150,000 PKR and 250,000 PKR.\n"
    f" - Ensure compatibility with your local grid and regulations for Net Metereing.\n"
    f" - Verify warranty and after-sales service for components with local vendor.\n\n"
)

# Check if the Groq request limit is reached
try:
    chat_completion = client.chat.completions.create(
        messages=[{"role": "user", "content": recommendation_message}],
        model="llama3-8b-8192",
    )

    groq_response = chat_completion.choices[0].message.content
    st.subheader("SolarWise AI-powered Analysis:")
    st.write(groq_response)

    # Generating alternative options based on power ratings, cost, and efficiency
    alternative_inverters = inverter_dataset[
        (inverter_dataset['Power_Rating(kW)'] == recommended_inverter['Power_Rating(kW)']) &
        (inverter_dataset['Cost (PKR)'] < recommended_inverter['Cost (PKR)']) &
        (inverter_dataset['Efficiency %'] >= 90)
    ]
    alternative_panels = solar_panel_dataset[
        (solar_panel_dataset['Power Rating (W)'] == recommended_solar_panel['Power Rating (W)']) &
        (solar_panel_dataset['Cost (PKR)'] < recommended_solar_panel['Cost (PKR)']) &
        (solar_panel_dataset['Efficiency %'] >= 18)
    ]

    # Generate alternative options with relaxed filtering criteria if no exact matches are found
    alternative_inverters = inverter_dataset[
        (inverter_dataset['Power_Rating(kW)'] >= recommended_inverter['Power_Rating(kW)'] * 0.9) & 
        (inverter_dataset['Power_Rating(kW)'] <= recommended_inverter['Power_Rating(kW)'] * 1.1) & 
        (inverter_dataset['Cost (PKR)'] <= recommended_inverter['Cost (PKR)'] * 1.1) & 
        (inverter_dataset['Efficiency %'] >= recommended_inverter['Efficiency %'] * 0.95)
    ]

    alternative_panels = solar_panel_dataset[
        (solar_panel_dataset['Power Rating (W)'] >= recommended_solar_panel['Power Rating (W)'] * 0.9) & 
        (solar_panel_dataset['Power Rating (W)'] <= recommended_solar_panel['Power Rating (W)'] * 1.1) & 
        (solar_panel_dataset['Cost (PKR)'] <= recommended_solar_panel['Cost (PKR)'] * 1.1) & 
        (solar_panel_dataset['Efficiency %'] >= recommended_solar_panel['Efficiency %'] * 0.95)
    ]

    # Display alternative options with relaxed criteria if strict criteria yield no results
    st.subheader("Alternative Options:")

    # Alternative Inverters
    if not alternative_inverters.empty:
        st.write("Alternative Inverters:")
        for _, row in alternative_inverters.iterrows():
            cost_difference = recommended_inverter['Cost (PKR)'] - row['Cost (PKR)']
            st.write(
                f"- {row['Inverter']} (Power: {row['Power_Rating(kW)']} kW, Efficiency: {row['Efficiency %']}%, "
                f"Warranty: {row['Warranty (Years)']} years, Cost: {row['Cost (PKR)']:,} PKR, "
                f"Cost Difference: {cost_difference:,} PKR)"
            )
    else:
        st.write("No alternative inverters found within relaxed criteria.")

    # Alternative Solar Panels
    if not alternative_panels.empty:
        st.write("Alternative Solar Panels:")
        for _, row in alternative_panels.iterrows():
            cost_difference = recommended_solar_panel['Cost (PKR)'] - row['Cost (PKR)']
            st.write(
                f"- {row['Solar Panel Model']} (Power: {row['Power Rating (W)']} W, Efficiency: {row['Efficiency %']}%, "
                f"Cost: {row['Cost (PKR)']:,} PKR, Cost Difference: {cost_difference:,} PKR)"
            )
    else:
        st.write("No alternative solar panels found within relaxed criteria.")


except Exception as e:
    st.error(f"Error communicating with Groq API: {e}")