Update app.py

app.py

@@ -8,7 +8,7 @@ from io import BytesIO
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
 from reportlab.lib.styles import getSampleStyleSheet
 from reportlab.lib import colors
-from langchain_community.vectorstores import FAISS  # Updated import for langchain-community
+from langchain_community.vectorstores import FAISS
 from langchain.embeddings import HuggingFaceEmbeddings
 from langchain.document_loaders import DataFrameLoader
 from langchain.chains import RetrievalQA
@@ -27,4 +27,161 @@ llm = HuggingFaceHub(
     huggingfacehub_api_token=hf_api_key
 )
 
-# Rest of your app code...
+def read_data(file):
+    """Read Excel data into a DataFrame."""
+    try:
+        df = pd.read_excel(file)
+        return df
+    except Exception as e:
+        st.error(f"Error reading Excel file: {e}")
+        return None
+
+def analyze_data(df):
+    """Analyze water level depletion and return critical areas."""
+    required_columns = ['Original Water Level in Feet', 'Present Water Level in Feet', 'Depth of Tubewell', 'Latitude', 'Longitude', 'Name of Scheme']
+    missing_columns = [col for col in required_columns if col not in df.columns]
+
+    if missing_columns:
+        raise KeyError(f"The following required columns are missing from the data: {', '.join(missing_columns)}")
+
+    df['Water Depletion'] = df['Original Water Level in Feet'] - df['Present Water Level in Feet']
+    df['Depletion Rate'] = df['Water Depletion'] / df['Depth of Tubewell']
+
+    scaler = MinMaxScaler()
+    df['Normalized Depletion'] = scaler.fit_transform(df[['Depletion Rate']])
+
+    threshold = df['Normalized Depletion'].quantile(0.9)
+    critical_areas = df[df['Normalized Depletion'] >= threshold]
+    return df, critical_areas
+
+def generate_map(df, critical_areas):
+    """Generate an interactive map highlighting critical areas."""
+    try:
+        base_map = folium.Map(location=[df['Latitude'].mean(), df['Longitude'].mean()], zoom_start=10)
+        marker_cluster = MarkerCluster().add_to(base_map)
+
+        for _, row in df.iterrows():
+            folium.Marker(
+                location=[row['Latitude'], row['Longitude']],
+                popup=f"Scheme: {row['Name of Scheme']}\nDepletion: {row['Water Depletion']:.2f} ft",
+                icon=folium.Icon(color='blue')
+            ).add_to(marker_cluster)
+
+        for _, row in critical_areas.iterrows():
+            folium.Marker(
+                location=[row['Latitude'], row['Longitude']],
+                popup=f"Critical: {row['Name of Scheme']}\nDepletion: {row['Water Depletion']:.2f} ft",
+                icon=folium.Icon(color='red')
+            ).add_to(marker_cluster)
+
+        return base_map
+    except Exception as e:
+        st.error(f"Error generating map: {e}")
+        return None
+
+def generate_report(df, critical_areas):
+    """Generate a PDF report."""
+    try:
+        buffer = BytesIO()
+        doc = SimpleDocTemplate(buffer)
+        styles = getSampleStyleSheet()
+        story = []
+
+        story.append(Paragraph("Water Level Depletion Report", styles['Title']))
+        story.append(Spacer(1, 12))
+
+        story.append(Paragraph(f"Total Tubewells Analyzed: {len(df)}", styles['Normal']))
+        story.append(Paragraph(f"Critical Areas Identified: {len(critical_areas)}", styles['Normal']))
+
+        data = [[f"Scheme: {row['Name of Scheme']}", f"Depletion: {row['Water Depletion']:.2f} ft"] for _, row in critical_areas.iterrows()]
+        table = Table(data)
+        table_style = [
+            ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
+            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+            ('FONTNAME', (0, 0), (-1, -1), 'Helvetica'),
+            ('FONTSIZE', (0, 0), (-1, -1), 10),
+            ('BOTTOMPADDING', (0, 0), (-1, -1), 12),
+            ('TOPPADDING', (0, 0), (-1, -1), 12),
+            ('LINEBELOW', (0, 0), (-1, -1), 1, colors.black)
+        ]
+        table.setStyle(TableStyle(table_style))
+        story.append(table)
+
+        doc.build(story)
+        buffer.seek(0)
+        return buffer
+    except Exception as e:
+        st.error(f"An error occurred while generating the report: {e}")
+        return None
+
+def store_data_in_vector_db(df):
+    """Store data in a vector database."""
+    try:
+        loader = DataFrameLoader(df)
+        docs = loader.load()
+        embeddings = HuggingFaceEmbeddings()
+        vectorstore = FAISS.from_documents(docs, embeddings)
+        return vectorstore
+    except Exception as e:
+        st.error(f"Error storing data in vector database: {e}")
+        return None
+
+def question_answer(vectorstore):
+    """Provide a Q&A interface."""
+    try:
+        retriever = vectorstore.as_retriever()
+        qa_chain = RetrievalQA.from_chain_type(llm=llm, retriever=retriever)
+        return qa_chain
+    except Exception as e:
+        st.error(f"Error initializing question-answering chain: {e}")
+        return None
+
+def main():
+    st.title("Water Level Depletion Analysis")
+
+    uploaded_file = st.file_uploader("Upload Excel File", type="xlsx")
+
+    if uploaded_file is not None:
+        try:
+            df = read_data(uploaded_file) 
+            if df is not None:
+                df, critical_areas = analyze_data(df)
+
+                st.subheader("Data Analysis")
+                st.dataframe(df)
+
+                st.subheader("Critical Areas")
+                st.dataframe(critical_areas)
+
+                st.subheader("Interactive Map")
+                map = generate_map(df, critical_areas)
+                if map:
+                    folium_static(map)
+
+                st.subheader("Generate Report")
+                if st.button("Download PDF Report"):
+                    report = generate_report(df, critical_areas)
+                    if report: 
+                        st.download_button(
+                            label="Download Report",
+                            data=report,
+                            file_name="water_depletion_report.pdf",
+                            mime="application/pdf"
+                        )
+
+                vectorstore = store_data_in_vector_db(df) 
+                if vectorstore:
+                    st.subheader("Ask a Question")
+                    user_query = st.text_input("Enter your question:")
+                    if user_query:
+                        qa_chain = question_answer(vectorstore)
+                        if qa_chain:
+                            answer = qa_chain.run(user_query)
+                            st.write("Answer:", answer)
+
+        except Exception as e:
+            st.error(f"An error occurred during data processing: {e}")
+
+if __name__ == "__main__":
+    main()