Create app.py

app.py

@@ -0,0 +1,231 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from ydata_profiling import ProfileReport
+import json
+import os
+from langchain.llms import HuggingFaceHub
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain.tools.python.tool import PythonAstREPLTool
+from langchain.agents import AgentExecutor, create_react_agent
+from langchain_experimental.agents.agent_toolkits.pandas.base import create_pandas_dataframe_agent
+from langchain.agents.agent_types import AgentType
+
+# Set page configuration
+st.set_page_config(page_title="Interactive Data Profiler & Chat", layout="wide", page_icon="📊")
+
+# Create session states for DataFrame and chat history if they don't exist
+if 'df' not in st.session_state:
+    st.session_state.df = None
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
+if 'suggestions' not in st.session_state:
+    st.session_state.suggestions = []
+
+# Initialize Hugging Face API
+def get_llm():
+    # Using a small but capable open-source model
+    llm = HuggingFaceHub(
+        repo_id="google/flan-t5-large",
+        model_kwargs={"temperature": 0.1, "max_length": 512},
+        huggingfacehub_api_token=os.environ.get("HUGGINGFACE_API_TOKEN", "")
+    )
+    return llm
+
+# Function to generate report
+def generate_profile_report(df):
+    with st.spinner("Generating profile report..."):
+        profile = ProfileReport(df, 
+                               title="Profiling Report", 
+                               explorative=True,
+                               minimal=True)  # Minimal for faster processing
+        return profile
+
+# Function to generate query suggestions
+def generate_suggestions(df):
+    # Get basic info about the dataframe
+    num_rows = df.shape[0]
+    num_cols = df.shape[1]
+    column_names = df.columns.tolist()
+    data_types = df.dtypes.astype(str).tolist()
+    
+    # Sample suggestions based on dataframe structure
+    suggestions = [
+        f"How many rows are in this dataset?",
+        f"What are all the column names?",
+        f"Show me the first 5 rows",
+        f"What is the average of {column_names[0] if len(column_names) > 0 else 'column'}"
+    ]
+    
+    # Add column-specific suggestions
+    for col, dtype in zip(column_names[:min(3, len(column_names))], data_types[:min(3, len(data_types))]):
+        if 'int' in dtype or 'float' in dtype:
+            suggestions.append(f"What is the mean value of {col}?")
+            suggestions.append(f"What is the maximum value of {col}?")
+        elif 'object' in dtype or 'str' in dtype:
+            suggestions.append(f"What are the unique values in {col}?")
+            suggestions.append(f"How many missing values in {col}?")
+    
+    return suggestions
+
+# Function to execute pandas operations safely
+def execute_pandas_query(df, query):
+    try:
+        # Create pandas agent
+        agent = create_pandas_dataframe_agent(
+            llm=get_llm(),
+            df=df,
+            agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+            verbose=True
+        )
+        
+        # Execute query
+        result = agent.run(query)
+        return result
+    except Exception as e:
+        # Fallback to basic operations if agent fails
+        if "rows" in query.lower() and "how many" in query.lower():
+            return f"The dataset has {df.shape[0]} rows."
+        elif "columns" in query.lower() and "how many" in query.lower():
+            return f"The dataset has {df.shape[1]} columns."
+        elif "column names" in query.lower():
+            return f"The column names are: {', '.join(df.columns.tolist())}"
+        elif "first" in query.lower() and "rows" in query.lower():
+            num = 5  # Default
+            for word in query.split():
+                if word.isdigit():
+                    num = int(word)
+                    break
+            return df.head(num).to_string()
+        elif "describe" in query.lower():
+            return df.describe().to_string()
+        else:
+            return f"I couldn't process that query. Error: {str(e)}"
+
+# Main app header
+st.title("🔍 Interactive Data Profiler & Chat")
+st.markdown("""
+Upload your CSV file to get detailed profiling and ask questions about your data!
+This app combines interactive data profiling with a chat interface for data exploration.
+""")
+
+# File uploader
+uploaded_file = st.file_uploader("Upload a CSV file", type="csv")
+
+# Process uploaded file
+if uploaded_file is not None:
+    try:
+        # Read CSV into DataFrame
+        df = pd.read_csv(uploaded_file)
+        st.session_state.df = df
+        st.success(f"✅ File uploaded successfully! Found {df.shape[0]} rows and {df.shape[1]} columns.")
+        
+        # Generate suggestions when a new file is uploaded
+        if len(st.session_state.suggestions) == 0:
+            st.session_state.suggestions = generate_suggestions(df)
+        
+        # Create tabs for different functionalities
+        tab1, tab2 = st.tabs(["📊 Data Profiling", "💬 Data Chat"])
+        
+        # Tab 1: Data Profiling
+        with tab1:
+            st.header("Data Profiling")
+            
+            # Basic info
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Rows", df.shape[0])
+            with col2:
+                st.metric("Columns", df.shape[1])
+            with col3:
+                st.metric("Missing Values", df.isna().sum().sum())
+            
+            # Show raw data sample
+            with st.expander("Preview Data"):
+                st.dataframe(df.head(10))
+            
+            # Generate the profile report
+            profile = generate_profile_report(df)
+            
+            # Convert report to HTML and display
+            report_html = profile.to_html()
+            st.components.v1.html(report_html, height=1000, scrolling=True)
+            
+            # Provide download button
+            st.write("### Download the Profiling Report")
+            report_bytes = report_html.encode('utf-8')
+            st.download_button(
+                label="Download Report (HTML)",
+                data=report_bytes,
+                file_name="profiling_report.html",
+                mime="text/html"
+            )
+            
+        # Tab 2: Interactive Chat
+        with tab2:
+            st.header("Chat with Your Data")
+            st.info("Ask questions about your data and get instant answers!")
+            
+            # Chat input and suggested questions
+            user_question = st.text_input("Your question:", key="question_input")
+            
+            # Show suggestion chips
+            st.write("Suggested questions:")
+            cols = st.columns(2)
+            for i, suggestion in enumerate(st.session_state.suggestions):
+                col_idx = i % 2
+                with cols[col_idx]:
+                    if st.button(suggestion, key=f"suggestion_{i}"):
+                        user_question = suggestion
+                        st.session_state.question_input = suggestion
+                        st.experimental_rerun()
+            
+            # Process question
+            if user_question:
+                st.session_state.chat_history.append({"role": "user", "content": user_question})
+                
+                # Get answer
+                with st.spinner("Thinking..."):
+                    answer = execute_pandas_query(df, user_question)
+                
+                # Add answer to chat history
+                st.session_state.chat_history.append({"role": "assistant", "content": answer})
+            
+            # Display chat history
+            st.write("### Conversation History")
+            for message in st.session_state.chat_history:
+                if message["role"] == "user":
+                    st.markdown(f"**You:** {message['content']}")
+                else:
+                    st.markdown(f"**Assistant:** {message['content']}")
+                st.markdown("---")
+            
+            # Clear chat button
+            if st.button("Clear Chat History"):
+                st.session_state.chat_history = []
+                st.experimental_rerun()
+                
+    except Exception as e:
+        st.error(f"An error occurred: {str(e)}")
+else:
+    st.info("👆 Please upload a CSV file to begin.")
+    
+    # Placeholder visuals
+    st.markdown("### What you can do with this app:")
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown("**📊 Data Profiling**")
+        st.markdown("- Automatic data quality assessment")
+        st.markdown("- Column statistics and distributions")
+        st.markdown("- Correlation analysis")
+        st.markdown("- Missing values analysis")
+    with col2:
+        st.markdown("**💬 Interactive Data Chat**")
+        st.markdown("- Ask natural language questions")
+        st.markdown("- Get instant insights")
+        st.markdown("- Suggested questions for quick exploration")
+        st.markdown("- No coding required!")