Update app.py

app.py

@@ -2,17 +2,14 @@ import streamlit as st
 import requests
 import pandas as pd
 import numpy as np
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.metrics.pairwise import cosine_similarity
 from sklearn.preprocessing import MultiLabelBinarizer
-from gensim import corpora
-from gensim.models import LdaModel
+from sklearn.metrics.pairwise import cosine_similarity
 import nltk
-from nltk.corpus import stopwords
 import re
 
 # Download NLTK stopwords
 nltk.download("stopwords")
+from nltk.corpus import stopwords
 stop_words = set(stopwords.words("english"))
 
 # Constants
@@ -49,10 +46,8 @@ def fetch_books(query, limit=100):
             book = {
                 "title": doc.get("title", ""),
                 "author": doc.get("author_name", [""])[0],
-                "author_image": None,  # Open Library doesn't provide author images directly
                 "genre": doc.get("subject", []),
                 "year": doc.get("first_publish_year", None),
-                "description": doc.get("first_sentence", [""])[0] if doc.get("first_sentence") else "",
                 "cover_image": cover_image
             }
             books.append(book)
@@ -61,65 +56,24 @@ def fetch_books(query, limit=100):
         st.error("Failed to fetch data from Open Library.")
         return []
 
-def preprocess_text(text):
-    """Preprocess text by removing special characters, stopwords, and lowercasing."""
-    text = re.sub(r"\W", " ", text.lower())  # Remove special characters and lowercase
-    tokens = text.split()
-    tokens = [word for word in tokens if word not in stop_words]  # Remove stopwords
-    return " ".join(tokens)
-
-def extract_topics(descriptions, num_topics=5):
-    """Extract topics from book descriptions using LDA."""
-    processed_texts = [preprocess_text(desc) for desc in descriptions if desc.strip()]
-    if not processed_texts:
-        return [0] * len(descriptions)  # Return default topic if no valid descriptions
-
-    tokenized_texts = [text.split() for text in processed_texts]
-    if not any(tokenized_texts):
-        return [0] * len(descriptions)  # Return default topic if no valid tokens
-
-    dictionary = corpora.Dictionary(tokenized_texts)
-    if not dictionary:
-        return [0] * len(descriptions)  # Return default topic if dictionary is empty
-
-    corpus = [dictionary.doc2bow(text) for text in tokenized_texts]
-    if not any(corpus):
-        return [0] * len(descriptions)  # Return default topic if corpus is empty
-
-    lda_model = LdaModel(corpus, num_topics=num_topics, id2word=dictionary, passes=15)
-    topics = []
-    for text in tokenized_texts:
-        if not text:
-            topics.append(0)
-            continue
-        bow = dictionary.doc2bow(text)
-        if not bow:
-            topics.append(0)
-            continue
-        topic_distribution = lda_model.get_document_topics(bow)
-        topics.append(max(topic_distribution, key=lambda x: x[1])[0])
-    return topics
+def preprocess_genres_and_topics(genres, topics):
+    """Preprocess genre and topic lists to create a combined feature."""
+    combined = genres + topics
+    return combined
 
 def recommend_books(input_books, all_books, top_n=20):
-    """Recommend books based on similarity of descriptions, genres, and topics."""
-    input_descriptions = [book["description"] for book in input_books]
-    all_descriptions = [book["description"] for book in all_books]
+    """Recommend books based on selected topics, genres, and year."""
     input_genres = [book["genre"] for book in input_books]
     all_genres = [book["genre"] for book in all_books]
-
-    input_topics = extract_topics(input_descriptions)
-    all_topics = extract_topics(all_descriptions)
+    input_topics = [book["topics"] for book in input_books]
+    all_topics = [book["topics"] for book in all_books]
 
     mlb = MultiLabelBinarizer()
     input_genres_encoded = mlb.fit_transform(input_genres)
     all_genres_encoded = mlb.transform(all_genres)
 
-    vectorizer = TfidfVectorizer()
-    input_tfidf = vectorizer.fit_transform(input_descriptions)
-    all_tfidf = vectorizer.transform(all_descriptions)
-
-    input_features = np.hstack((input_tfidf.toarray(), input_genres_encoded, np.array(input_topics).reshape(-1, 1)))
-    all_features = np.hstack((all_tfidf.toarray(), all_genres_encoded, np.array(all_topics).reshape(-1, 1)))
+    input_features = np.hstack((input_genres_encoded, np.array(input_topics).reshape(-1, 1)))
+    all_features = np.hstack((all_genres_encoded, np.array(all_topics).reshape(-1, 1)))
 
     similarity_scores = cosine_similarity(input_features, all_features)
     avg_similarity = similarity_scores.mean(axis=0)
@@ -157,10 +111,10 @@ def main():
         filtered_books = [book for book in books if book["year"] and start_year <= book["year"] <= end_year]
         st.write(f"Found {len(filtered_books)} books between {start_year} and {end_year}.")
 
-        # Filter books with valid descriptions
-        valid_books = [book for book in filtered_books if book["description"].strip()]
+        # Filter books with valid genres and topics
+        valid_books = [book for book in filtered_books if book["genre"] and book["topics"]]
         if not valid_books:
-            st.warning("No books with valid descriptions found. Try a different query or adjust filters.")
+            st.warning("No books with valid genres and topics found. Try a different query or adjust filters.")
             st.stop()
 
         # Display filtered books
@@ -171,7 +125,8 @@ def main():
                 st.write(f"**Author:** {book['author']}")
                 if book["cover_image"]:
                     st.image(book["cover_image"], caption=book["title"], width=150)
-                st.write(f"**Description:** {book['description']}")
+                st.write(f"**Genres:** {', '.join(book['genre'])}")
+                st.write(f"**Published Year:** {book['year']}")
                 st.write("---")
 
         # Generate recommendations
@@ -183,8 +138,9 @@ def main():
             st.write(f"**Author:** {book['author']}")
             if book["cover_image"]:
                 st.image(book["cover_image"], caption=book["title"], width=150)
-            st.write(f"**Description:** {book['description']}")
+            st.write(f"**Genres:** {', '.join(book['genre'])}")
+            st.write(f"**Published Year:** {book['year']}")
             st.write("---")
 
 if __name__ == "__main__":
-    main()
+    main()