Update app.py

app.py

@@ -1,7 +1,7 @@
 import streamlit as st
 import pandas as pd
 import os
-import io
+import base64
 
 # Import evaluation modules
 from phoenix_code import phoenix_eval
@@ -16,106 +16,89 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# Function to create sample templates for each evaluation method
-def create_sample_template(evaluation_type):
-    """
-    Create a sample template DataFrame based on the evaluation type
-    """
-    templates = {
-        "Phoenix": pd.DataFrame({
-            'question': ['What is machine learning?', 'Explain Python programming'],
-            'answer': ['Machine learning is...', 'Python is a programming language...'],
-            'cleaned_context': ['Context about machine learning', 'Context about Python programming']
-        }),
-        "RAGAS": pd.DataFrame({
-            'question': ['What is AI?', 'Describe data science'],
-            'answer': ['Artificial Intelligence is...', 'Data science involves...'],
-            'contexts': ['Detailed context about AI', 'Comprehensive context on data science'],
-            'ground_truth': ['Verified definition of AI', 'Verified explanation of data science']
-        }),
-        "Traditional Metrics": pd.DataFrame({
-            'question': ['What is deep learning?', 'Explain neural networks'],
-            'answer': ['Deep learning is...', 'Neural networks are...'],
-            'contexts': ['Context about deep learning', 'Context about neural networks']
-        })
-    }
-    
-    return templates.get(evaluation_type, pd.DataFrame())
+# Custom CSS for improved styling
+def local_css(file_name):
+    with open(file_name) as f:
+        st.markdown(f'<style>{f.read()}</style>', unsafe_allow_html=True)
 
-# Function to create a downloadable Excel file
-def create_downloadable_excel(evaluation_type):
-    """
-    Create and return a downloadable Excel file for the specified evaluation type
-    """
-    # Create a sample template
-    template_df = create_sample_template(evaluation_type)
+# Function to create a more visually appealing file uploader
+def custom_file_uploader():
+    st.markdown("""
+    <div class="file-upload-container">
+        <div class="file-upload-icon">📂</div>
+        <div class="file-upload-text">
+            Drag and Drop or <span class="file-upload-browse">Browse Files</span>
+        </div>
+        <small>Supports CSV, XLS, XLSX</small>
+    </div>
+    """, unsafe_allow_html=True)
     
-    # Save to a bytes buffer
-    output = io.BytesIO()
-    with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
-        template_df.to_excel(writer, index=False, sheet_name='Sample Template')
-        
-        # Add a README sheet with column descriptions
-        workbook = writer.book
-        worksheet = workbook.add_worksheet('README')
-        
-        # Write column descriptions
-        readme_text = [
-            f"Sample Template for {evaluation_type} Evaluation",
-            "",
-            "Column Descriptions:",
-        ]
-        
-        if evaluation_type == "Phoenix":
-            readme_text.extend([
-                "- 'question': The input query or prompt",
-                "- 'answer': The generated response to the question",
-                "- 'cleaned_context': The context used to generate the answer"
-            ])
-        elif evaluation_type == "RAGAS":
-            readme_text.extend([
-                "- 'question': The input query or prompt",
-                "- 'answer': The generated response to the question",
-                "- 'contexts': The context used to generate the answer",
-                "- 'ground_truth': The verified or gold standard answer"
-            ])
-        else:  # Traditional Metrics
-            readme_text.extend([
-                "- 'question': The input query or prompt",
-                "- 'answer': The generated response to the question",
-                "- 'contexts': The context used to generate the answer"
-            ])
-        
-        # Write README text
-        for i, line in enumerate(readme_text):
-            worksheet.write(i, 0, line)
-        
-    output.seek(0)
-    return output
+    uploaded_file = st.file_uploader(
+        "Upload Dataset", 
+        type=["csv", "xls", "xlsx"], 
+        label_visibility="collapsed"
+    )
+    return uploaded_file
 
+# Main Streamlit App
 def main():
-    # Custom CSS (keep the previous CSS from the last implementation)
+    # Custom CSS for enhanced styling
     st.markdown("""
     <style>
-    /* Previous CSS styles remain the same */
-    .template-section {
-        background-color: #F0F4F8;
-        border-radius: 10px;
-        padding: 20px;
-        margin-bottom: 20px;
-        border: 1px solid #E2E8F0;
+    .stApp {
+        background-color: #f0f2f6;
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
     }
-    .template-header {
+    .stTitle {
         color: #2C3E50;
-        margin-bottom: 15px;
+        text-align: center;
+        margin-bottom: 30px;
+    }
+    .stMarkdown {
+        color: #34495E;
     }
-    .download-btn {
-        background-color: #48BB78;
+    .stButton>button {
+        background-color: #3498DB;
         color: white;
         border: none;
         border-radius: 6px;
         padding: 10px 20px;
-        margin: 10px 0;
+        transition: all 0.3s ease;
+    }
+    .stButton>button:hover {
+        background-color: #2980B9;
+        transform: scale(1.05);
+    }
+    .sidebar .sidebar-content {
+        background-color: #FFFFFF;
+        border-radius: 10px;
+        padding: 20px;
+        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+    }
+    .file-upload-container {
+        border: 2px dashed #3498DB;
+        border-radius: 10px;
+        padding: 30px;
+        text-align: center;
+        background-color: #FFFFFF;
+        transition: all 0.3s ease;
+    }
+    .file-upload-container:hover {
+        border-color: #2980B9;
+        background-color: #F1F8FF;
+    }
+    .file-upload-icon {
+        font-size: 50px;
+        color: #3498DB;
+        margin-bottom: 15px;
+    }
+    .file-upload-text {
+        color: #2C3E50;
+        font-size: 18px;
+    }
+    .file-upload-browse {
+        color: #3498DB;
+        font-weight: bold;
     }
     </style>
     """, unsafe_allow_html=True)
@@ -123,49 +106,10 @@ def main():
     # App Title
     st.markdown("<h1 class='stTitle'>🔍 RAG Evaluation Toolkit</h1>", unsafe_allow_html=True)
     
-    # Template Section
-    st.markdown("<div class='template-section'>", unsafe_allow_html=True)
-    st.markdown("<h2 class='template-header'>📝 Data Template Guidelines</h2>", unsafe_allow_html=True)
-    
-    # Expandable sections for each evaluation type
-    with st.expander("📊 Phoenix Evaluation Template"):
-        st.write("Required Columns: 'question', 'answer', 'cleaned_context'")
-        if st.button("Download Phoenix Template", key="phoenix_template"):
-            phoenix_template = create_downloadable_excel("Phoenix")
-            st.download_button(
-                label="Save Phoenix Template",
-                data=phoenix_template,
-                file_name="phoenix_evaluation_template.xlsx",
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-            )
-    
-    with st.expander("📈 RAGAS Evaluation Template"):
-        st.write("Required Columns: 'question', 'answer', 'contexts', 'ground_truth'")
-        if st.button("Download RAGAS Template", key="ragas_template"):
-            ragas_template = create_downloadable_excel("RAGAS")
-            st.download_button(
-                label="Save RAGAS Template",
-                data=ragas_template,
-                file_name="ragas_evaluation_template.xlsx",
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-            )
-    
-    with st.expander("📏 Traditional Metrics Template"):
-        st.write("Required Columns: 'question', 'answer', 'contexts'")
-        if st.button("Download Traditional Metrics Template", key="traditional_template"):
-            traditional_template = create_downloadable_excel("Traditional Metrics")
-            st.download_button(
-                label="Save Traditional Metrics Template",
-                data=traditional_template,
-                file_name="traditional_metrics_template.xlsx",
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-            )
-    st.markdown("</div>", unsafe_allow_html=True)
-    
-    # Sidebar for Configuration (keep previous sidebar code)
+    # Sidebar for Configuration
     st.sidebar.header("📋 Evaluation Configuration")
     
-    # API Key Input
+    # API Key Input with improved styling
     st.sidebar.subheader("OpenAI API Key")
     openai_api_key = st.sidebar.text_input(
         "Enter your OpenAI API Key", 
@@ -175,13 +119,7 @@ def main():
     
     # File Upload Section
     st.markdown("### 📊 Upload Your Dataset")
-    uploaded_file = st.file_uploader(
-        "Upload Dataset", 
-        type=["csv", "xls", "xlsx"]
-    )
-    
-    # Rest of the previous implementation follows...
-    # (Keep the rest of the previous main() function code)
+    uploaded_file = custom_file_uploader()
     
     # Evaluation Type Selection
     st.sidebar.subheader("🛠 Evaluation Methods")
@@ -220,42 +158,72 @@ def main():
                 metrics
             )
     
-    # Validation function for DataFrame columns
-    def validate_dataframe(df, evaluation_type):
-        """
-        Validate DataFrame columns based on the evaluation type
-        """
-        required_columns = {
-            "Phoenix": ['question', 'answer', 'cleaned_context'],
-            "RAGAS": ['question', 'answer', 'contexts', 'ground_truth'],
-            "Traditional Metrics": ['question', 'answer', 'contexts']
-        }
-        
-        # Check columns for the selected evaluation methods
-        for method in selected_metrics.keys():
-            missing_columns = [col for col in required_columns.get(method, []) if col not in df.columns]
-            
-            if missing_columns:
-                st.error(f"Missing required columns for {method}: {', '.join(missing_columns)}")
-                return False
-        
-        return True
-    
     # Evaluation Button
     if uploaded_file and openai_api_key and selected_metrics:
-        # Load data
-        file_extension = os.path.splitext(uploaded_file.name)[1]
-        if file_extension.lower() == ".csv":
-            df = pd.read_csv(uploaded_file)
-        elif file_extension.lower() in [".xls", ".xlsx"]:
-            df = pd.read_excel(uploaded_file)
-        
-        # Validate DataFrame
-        if validate_dataframe(df, selected_metrics):
-            if st.button("🚀 Run Evaluation"):
-                # Rest of the evaluation code remains the same as in the previous implementation
-                # (Keep the existing evaluation logic)
-                pass
+        if st.button("🚀 Run Evaluation"):
+            # Load data
+            file_extension = os.path.splitext(uploaded_file.name)[1]
+            if file_extension.lower() == ".csv":
+                df = pd.read_csv(uploaded_file)
+            elif file_extension.lower() in [".xls", ".xlsx"]:
+                df = pd.read_excel(uploaded_file)
+            
+            # Combine results
+            combined_results = pd.DataFrame()
+            
+            # Progress bar
+            progress_bar = st.progress(0)
+            
+            # Run evaluations
+            with st.spinner("Processing evaluations..."):
+                # Phoenix Evaluation
+                if "Phoenix Evaluation" in selected_metrics:
+                    progress_bar.progress(33)
+                    phoenix_results = phoenix_eval(
+                        selected_metrics.get("Phoenix Evaluation", []), 
+                        openai_api_key, 
+                        df.copy()
+                    )
+                    combined_results = pd.concat([combined_results, phoenix_results], axis=1)
+                
+                # RAGAS Evaluation
+                if "RAGAS Evaluation" in selected_metrics:
+                    progress_bar.progress(66)
+                    ragas_results = ragas_eval(
+                        selected_metrics.get("RAGAS Evaluation", []), 
+                        openai_api_key, 
+                        df.copy()
+                    )
+                    combined_results = pd.concat([combined_results, ragas_results], axis=1)
+                
+                # Traditional Metrics Evaluation
+                if "Traditional Metrics" in selected_metrics:
+                    progress_bar.progress(100)
+                    traditional_results = RAGEvaluator(
+                        df=df.copy(), 
+                        selected_metrics=selected_metrics.get("Traditional Metrics", [])
+                    )
+                    combined_results = pd.concat([combined_results, traditional_results], axis=1)
+                
+                # Save results
+                results_filename = "rag_evaluation_results.xlsx"
+                combined_results.to_excel(results_filename, index=False)
+                
+                # Success message and download button
+                st.success("Evaluation Completed Successfully!")
+                
+                # Create download button with improved styling
+                with open(results_filename, "rb") as file:
+                    btn = st.download_button(
+                        label="📥 Download Evaluation Results",
+                        data=file,
+                        file_name=results_filename,
+                        mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                    )
+                
+                # Display results preview
+                st.markdown("### 📊 Results Preview")
+                st.dataframe(combined_results)
 
 # Run the app
 if __name__ == "__main__":