Create app.py

app.py

@@ -0,0 +1,152 @@
+# === Import Required Libraries ===
+import pandas as pd
+import numpy as np
+from sentence_transformers import SentenceTransformer
+import faiss
+import streamlit as st
+import gradio as gr
+import os
+
+# === Dataset Loading Function ===
+def load_dataset():
+    """
+    Provides multiple options to load the dataset: manual upload, Kaggle download, or specifying a local path.
+    """
+    st.write("### Dataset Upload Options")
+    upload_option = st.radio(
+        "Choose how to provide the dataset:",
+        ("Manual Upload", "Download from Kaggle", "Specify Local Path")
+    )
+
+    # Manual Upload
+    if upload_option == "Manual Upload":
+        st.write("#### Upload the file below:")
+        uploaded_file = st.file_uploader("Upload your CSV file", type="csv")
+        if uploaded_file is not None:
+            st.success("File uploaded successfully!")
+            return pd.read_csv(uploaded_file)
+
+    # Kaggle Download
+    elif upload_option == "Download from Kaggle":
+        st.write("#### Enter your Kaggle Dataset Path and API Key")
+        kaggle_dataset = st.text_input("Kaggle Dataset Path (e.g., `thedevastator/hydra-movies-dataset-directors-writers-cast-and`):")
+        kaggle_api_key = st.text_area("Enter your Kaggle API Key JSON content:")
+        if st.button("Download Dataset"):
+            if kaggle_dataset and kaggle_api_key:
+                # Set up Kaggle API
+                os.makedirs(os.path.expanduser("~/.kaggle"), exist_ok=True)
+                with open(os.path.expanduser("~/.kaggle/kaggle.json"), "w") as f:
+                    f.write(kaggle_api_key)
+                os.chmod(os.path.expanduser("~/.kaggle/kaggle.json"), 0o600)
+
+                # Download dataset
+                os.system(f"!kaggle datasets download -d {kaggle_dataset} --unzip")
+                dataset_name = kaggle_dataset.split("/")[-1] + ".csv"
+                if os.path.exists(dataset_name):
+                    st.success(f"Dataset {dataset_name} downloaded successfully!")
+                    return pd.read_csv(dataset_name)
+                else:
+                    st.error("Failed to download dataset. Please check your inputs.")
+            else:
+                st.warning("Please provide both the dataset path and your API key.")
+
+    # Specify Local Path
+    elif upload_option == "Specify Local Path":
+        local_path = st.text_input("Specify the full local path of your CSV file:")
+        if st.button("Load Dataset"):
+            if os.path.exists(local_path):
+                st.success("Dataset loaded successfully from the specified path!")
+                return pd.read_csv(local_path)
+            else:
+                st.error("File not found. Please check the path and try again.")
+
+    return None
+
+# === Preprocess Data ===
+def preprocess_data(df):
+    """
+    Normalizes column names and prepares text for embeddings. Adds placeholders for missing columns if needed.
+    """
+    # Normalize column names
+    df.columns = df.columns.str.strip().str.lower()
+
+    # Verify and handle missing 'genres' column
+    if 'genres' not in df.columns:
+        print("Warning: 'genres' column missing! Adding a placeholder.")
+        df['genres'] = "Unknown"
+
+    # Check if columns like 'title', 'summary', 'cast' exist and handle possible NaN/invalid values
+    df['text'] = df['title'].fillna('') + " " + df['summary'].fillna('') + " " + df['genres'] + " " + df['cast'].fillna('')
+    
+    return df
+
+# === Create Embeddings and FAISS Index ===
+def create_faiss_index(df, model):
+    """
+    Generates embeddings using a sentence-transformer model and creates a FAISS index.
+    """
+    embeddings = model.encode(df['text'].tolist(), show_progress_bar=True)
+    dimension = embeddings.shape[1]
+    index = faiss.IndexFlatL2(dimension)
+    index.add(embeddings)
+    return index
+
+# === Define Retrieval Function ===
+def retrieve(query, model, index, df, top_k=5):
+    """
+    Retrieves top-k results for a given query using FAISS index.
+    """
+    query_embedding = model.encode([query])
+    distances, indices = index.search(query_embedding, top_k)
+    results = df.iloc[indices[0]].to_dict(orient="records")
+    return results
+
+# === Define Gradio Interface ===
+def movie_query_app(query, model, index, df):
+    """
+    Gradio interface function to retrieve and display movie recommendations based on a query.
+    """
+    results = retrieve(query, model, index, df)
+    response = ""
+    for i, res in enumerate(results):
+        response += f"**{i+1}. {res['title']} ({res['year']})**\n"
+        response += f"- **Genres**: {res['genres']}\n"
+        response += f"- **Summary**: {res['short summary']}\n"
+        response += f"- **Director**: {res['director']}\n"
+        response += f"- **Cast**: {res['cast']}\n"
+        response += f"- **Rating**: {res['rating']}\n\n"
+    return response
+
+# === Main Function ===
+if __name__ == "__main__":
+    # Streamlit Setup
+    st.title("RAG Application with Integrated Dataset Loading")
+
+    # Step 1: Load dataset
+    df = load_dataset()
+
+    if df is not None:
+        st.write("### Preview of Loaded Dataset")
+        st.dataframe(df.head())
+
+        # Step 2: Preprocess data
+        df = preprocess_data(df)
+
+        # Step 3: Create embeddings and FAISS index
+        st.write("### Creating Embeddings and Index...")
+        model = SentenceTransformer('all-MiniLM-L6-v2')
+        index = create_faiss_index(df, model)
+
+        # Step 4: Set up Gradio interface
+        iface = gr.Interface(
+            fn=lambda query: movie_query_app(query, model, index, df),
+            inputs="text",
+            outputs="text",
+            title="Movie Recommendation App",
+        )
+
+        # Step 5: Launch the app
+        st.write("### Launching Gradio App...")
+        iface.launch()
+    else:
+        st.write("### Please load the dataset to proceed.")