Update files from private repo

ai_services.py

@@ -0,0 +1,32 @@
+from openai import OpenAI
+
+from dotenv import load_dotenv
+import os
+import streamlit as st
+
+if os.getenv("OPENAI_API_KEY") is None:
+    load_dotenv()
+
+openAIclient = OpenAI()
+
+def get_suggestion_text(closestReadBookData, targetBookData):    
+    closestReadTitle = closestReadBookData['title']
+    closestReadAuthor = closestReadBookData['authors']
+
+    targetBookTitle = targetBookData['title']
+    targetBookAuthor = targetBookData['authors']
+
+    messageContent = "In 2 sentences max, please cheerfully explain why I might enjoy " + targetBookTitle + " by " + targetBookAuthor + " if I liked " + closestReadTitle + " by " + closestReadAuthor + "."
+
+    response = openAIclient.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
+            {"role": "system", "content": "You are an experienced librarian."},
+            {"role": "user", "content": messageContent}
+        ]
+    )
+
+    chatCompletionMessage = response.choices[0].message    
+
+    # return f"Because you liked {closestReadTitle} by {closestReadAuthor}, we think you might like {targetBookTitle} by {targetBookAuthor}."
+    return chatCompletionMessage.content

app.py

@@ -1,10 +1,26 @@
 import pickle
 import streamlit as st
+
+st.set_page_config(layout="wide")
+
+from streamlit_modal import Modal
+
 import numpy as np
 import bookdb
 
+import ai_services
+
 st.header("My Book Buddy 🐛")
 
+if "clicked_book" not in st.session_state:
+    st.session_state["clicked_book"] = {}
+
+if "closestReadBook" not in st.session_state:
+    st.session_state["closestReadBook"] = None
+
+if "suggestedBookText" not in st.session_state:
+    st.session_state["suggestedBookText"] = ""
+
 if "upvoted_book_ids" not in st.session_state:
     st.session_state["upvoted_book_ids"] = []
 
@@ -28,12 +44,21 @@ def update_display(displayData):
     st.session_state["recommendedBooksData"] = displayData["recommendedBooksData"]
     st.session_state["topCorrelatedReadersData"] = displayData["topCorrelatedReadersData"]
 
+    st.session_state["bookByRatingData"] = displayData["bookByRatingData"]
+
 def on_reset_votes():
     st.session_state["upvoted_book_ids"] = []
     st.session_state["downvoted_book_ids"] = []
     st.session_state["numSimilarUsers"] = 0
     st.session_state["recommendedBooksData"] = None
     st.session_state["topCorrelatedReadersData"] = None
+    st.session_state["bookByRatingData"] = None
+
+def on_test_submit_votes():
+    upvotedBookIds =  [104, 103, 102, 110, 113, 124, 129, 135, 141, 142, 155, 161, 165, 176, 181, 974, 4443, 1496, 1003, 974, 2600] # TODO REMOVE
+    downvotedBookIds =  [126, 179, 183, 184, 187, 9076, 960, 5895, 777, 6902, 2084, 584] # TODO REMOVE
+
+    update_display(bookdb.update_user_ratings(upvotedBookIds, downvotedBookIds))
 
 def on_submit_votes():
     upvoteBookTitles = st.session_state["multiselect_upvote"]
@@ -68,36 +93,112 @@ def on_submit_votes():
 
     update_display(bookdb.update_user_ratings(upvotedBookIds, downvotedBookIds))
 
-with st.form(key='upvote_form'):
-    col1, col2 = st.columns(2)
+clickedBook = st.session_state["clicked_book"] if "clicked_book" in st.session_state else {}
 
-    allBookTitles = bookdb.get_all_book_titles()
+modal = Modal(
+    f"📖 {clickedBook['title'] if 'title' in clickedBook else ''}",
+    key="book-modal"
+)
 
-    myRatedBookTitles = bookdb.get_book_titles(st.session_state["upvoted_book_ids"] + st.session_state["downvoted_book_ids"])
+def on_update_recommendations():
+    # iterate through the number of recommendations and check the selected radio button
 
-    # remove myRatedBookTitles from allBookTitles
-    remainingBookTitles = [x for x in allBookTitles if x not in myRatedBookTitles]
+    recommendations = st.session_state["recommendedBooksData"]
 
-    col1.multiselect(
-        'Upvote Books 👍', 
-        remainingBookTitles,
-        key='multiselect_upvote'
-    )
-    col2.multiselect(
-        'Downvote Books 👎', 
-        remainingBookTitles,
-        key='multiselect_downvote'
-    )
-    st.form_submit_button(label='Submit', type="primary", on_click=on_submit_votes)
+    bookIdsToUpvote = []
+    bookIdsToDownvote = []
+
+    for counter in range(len(recommendations)):
+        radioKey = f"update_recommendation_{counter}"
+
+        radioValue = st.session_state[radioKey]
+
+        if radioValue == "👍":
+            bookIdsToUpvote.append(recommendations[counter]["book_id"])
+        elif radioValue == "👎":
+            bookIdsToDownvote.append(recommendations[counter]["book_id"])
+
+        # reset the radio button
+        st.session_state[radioKey] = None
+
+    if len(bookIdsToUpvote) == 0 and len(bookIdsToDownvote) == 0:
+        st.warning("Please select at least one book to upvote or downvote")
+        return
+    
+    # append booksToUpvote to upvotedBookIds
+    upvotedBookIds = st.session_state["upvoted_book_ids"]
+    downvotedBookIds = st.session_state["downvoted_book_ids"]
+
+    upvotedBookIds.extend(bookIdsToUpvote)
+    downvotedBookIds.extend(bookIdsToDownvote)
+
+    # remove any upvoted books from downvotedBookIds if they are in there
+    downvotedBookIds = [x for x in downvotedBookIds if x not in upvotedBookIds]
+
+    update_display(bookdb.update_user_ratings(upvotedBookIds, downvotedBookIds))
 
 if st.session_state["recommendedBooksData"] is not None:
-    df = st.session_state["recommendedBooksData"]
+    recommendations = st.session_state["recommendedBooksData"]
 
     st.subheader("Recommendations")
 
-    st.dataframe(df, hide_index=True, use_container_width=True)
+    recommendationsCol1, recommendationsCol2, recommendationsCol3 = st.columns(3)
 
-    st.button('Reset All Ratings', type="secondary", on_click=on_reset_votes)
+    for counter in range(len(recommendations)):
+        bookData = recommendations[counter]
+
+        bookMetadata = bookdb.get_book_metadata_by_id(bookData["book_id"])
+
+        # print(bookMetadata)
+    
+        if counter % 3 == 0:
+            container = recommendationsCol1.container(border=True)
+        elif counter % 3 == 1:
+            container = recommendationsCol2.container(border=True)
+        else:
+            container = recommendationsCol3.container(border=True)
+
+        bookAuthor = bookData["authors"]
+        bookTitle = bookData["title"]
+        bookPubYear = bookData["original_publication_year"]
+
+        containerCol1, containerCol2, containerCol3  = container.columns([5, 10, 2])
+
+        containerCol1.html(f"<img width='100%' src='{bookMetadata['thumbnail']}'>")
+    
+        textContainer = containerCol2.container()
+
+        titleClicked = textContainer.button(f"{bookTitle}", use_container_width=True)
+
+        if titleClicked:
+            bookByRatingData = st.session_state["bookByRatingData"] 
+            upvotedBookIds = st.session_state["upvoted_book_ids"]
+            targetBookId = bookData["book_id"]
+
+            closestReadBookData = bookdb.find_closest_read_title(bookByRatingData, upvotedBookIds, targetBookId)
+
+            targetBookData = bookdb.get_book_data_by_id(targetBookId)
+
+            st.session_state["closestReadBook"] = closestReadBookData
+            st.session_state["clicked_book"] = bookData
+
+            st.session_state["suggestedBookText"] = ai_services.get_suggestion_text(closestReadBookData, targetBookData)
+
+            modal.open()            
+        
+        textContainer.markdown(f"*{bookAuthor}*")
+
+        textContainer.markdown(f"Published: {int(bookPubYear)}")
+                             
+        # containerCol2.markdown(textHTMLcontent, unsafe_allow_html=True)
+        # containerCol2.markdown(f"[{bookTitle}](https://streamlit.io)\n\n*{bookAuthor}*\n\nPublished: {int(bookPubYear)}")
+        # radioContainer = containerCol3.container()
+
+        containerCol3.radio(label="Upvote/Downvote", label_visibility="hidden", options=["👍", "👎"], key=f"update_recommendation_{counter}", index=None)        
+
+        # radioContainer.button('Why This Book?', type="secondary", key=f"submit_{counter}")
+
+    st.button('Update Recommendations', type="primary", on_click=on_update_recommendations)
 
     st.subheader("Your Ratings")
 
@@ -119,7 +220,7 @@ if st.session_state["recommendedBooksData"] is not None:
         for bookId in downvotedBookIds:
             displayCol2.markdown(f'  - {bookId}-{bookdb.get_book_title(bookId)}')
 
-    st.divider()
+    st.button('Reset All Ratings', type="secondary", on_click=on_reset_votes)
 
     # st.write(f"Similar User Min Percent Shared Books = {round(bookdb.SIMILAR_USER_MIN_PERCENT_SHARED_BOOKS * 100)}%")
     # st.write(f"Similar User Min Correlation = {bookdb.SIMILAR_USER_MIN_CORRELATION}")
@@ -127,9 +228,66 @@ if st.session_state["recommendedBooksData"] is not None:
     # if "numSimilarUsers" in st.session_state:
         # st.write(f"{st.session_state['numSimilarUsers']} similar users")
 
-    if st.session_state["topCorrelatedReadersData"] is not None:
-        df = st.session_state["topCorrelatedReadersData"]
+with st.form(key='upvote_form'):
+    col1, col2 = st.columns(2)
+
+    allBookTitles = bookdb.get_all_book_titles()
+
+    myRatedBookTitles = bookdb.get_book_titles(st.session_state["upvoted_book_ids"] + st.session_state["downvoted_book_ids"])
+
+    # remove myRatedBookTitles from allBookTitles
+    remainingBookTitles = [x for x in allBookTitles if x not in myRatedBookTitles]
+
+    col1.multiselect(
+        'Upvote Books 👍', 
+        remainingBookTitles,
+        key='multiselect_upvote'
+    )
+    col2.multiselect(
+        'Downvote Books 👎', 
+        remainingBookTitles,
+        key='multiselect_downvote'
+    )
+    st.form_submit_button(label='Submit', type="primary", on_click=on_submit_votes)
+
+    st.form_submit_button(label='Test', type="secondary", on_click=on_test_submit_votes)
+
+if st.session_state["topCorrelatedReadersData"] is not None:
+    df = st.session_state["topCorrelatedReadersData"]
+
+    st.subheader("Top Correlated Readers")
+
+    st.dataframe(df, use_container_width=True)
+
+if modal.is_open():
+    with modal.container():
+        clickedBook = st.session_state["clicked_book"]
+
+        clickedBookMetadata = bookdb.get_book_metadata_by_id(clickedBook["book_id"])
+
+        clickedBookDescription = clickedBookMetadata["description"]
+
+        st.html(f"{clickedBookDescription}")
+        
+        aiSuggestContainer = st.container(border=True)
+
+        closestReadBook = st.session_state["closestReadBook"]
+
+        suggestedBookText = st.session_state["suggestedBookText"]
+
+        aiSuggestContainer.html(f"<p style=\"color:#DA70D6;\">💫 Because you liked <i><b>{closestReadBook['title']}</b></i> by <b>{closestReadBook['authors']}</b>...</p>")
+        
+        aiSuggestContainer.html(f"<p style=\"color:#DA70D6;\">{suggestedBookText}</p>")
+
+        buttonCol1, buttonCol2, buttonCol3, buttonCol4  = st.columns(4)
+
+        clickedBookTitle = clickedBook["title"]
+        clickedBookAuthor = clickedBook["authors"]
+        clickedBookISBN = clickedBook["isbn"]
 
-        st.subheader("Top Correlated Readers")
+        outboundLinkSuffix = f"{clickedBookTitle} {clickedBookAuthor}"
 
-        st.dataframe(df, use_container_width=True)
+        buttonCol1.link_button('🛒 Bookshop', f'https://bookshop.org/search?keywords={outboundLinkSuffix}')
+        buttonCol2.link_button('📚 Biblio', f'https://www.biblio.com/search.php?stage=1&result_type=works&keyisbn={outboundLinkSuffix}')
+        buttonCol3.link_button('🎧 Libro', f'https://libro.fm/search?utf8=%E2%9C%93&q={outboundLinkSuffix}')
+        buttonCol4.link_button('💬 Hardcover', f'https://hardcover.app/search?q={outboundLinkSuffix}')

bookdb.py

@@ -1,17 +1,48 @@
 import pandas as pd
+import json
+import streamlit as st
 
 SIMILAR_USER_MIN_PERCENT_SHARED_BOOKS = 0.30
 SIMILAR_USER_MIN_CORRELATION = 0.25
 
-books = pd.read_csv("./goodreads/books.csv", 
+MAX_MIN_BOOK_COUNT_FOR_SIMILAR_USER = 10 # the maximum amount of books required for a user to be considered a similar user
+
+DEFAULT_BOOK_COVER_URL = "https://m.media-amazon.com/images/I/81QPHl7zgbL._AC_UF1000,1000_QL80_.jpg"
+
+@st.cache
+def get_dataframes():
+    booksDf = pd.read_csv("./goodreads/books.csv", 
                  usecols=["book_id",
-                        #   "original_publication_year",
+                            "original_publication_year",
                         #   "average_rating",
-                          "title",
-                          "average_rating"])
-books['book_id'] = range(1, len(books) + 1)
+                            "isbn",
+                            "authors",
+                            "title",
+                            "average_rating"])
+    booksDf['book_id'] = range(1, len(booksDf) + 1)
+
+    baseRatingsDf = pd.read_csv("./goodreads/ratings.csv")    
+    
+    bookMetadataJSON = json.load(open("./goodreads/book_metadata.json"))
 
-baseRatings = pd.read_csv("./goodreads/ratings.csv")
+    return booksDf, baseRatingsDf, bookMetadataJSON
+
+books, baseRatings, bookMetadata = get_dataframes()
+
+targetUserId = baseRatings['user_id'].max() + 1
+
+def get_book_metadata_by_id(book_id):
+    book_id = str(book_id)
+    
+    data = {
+        "description" : "n/a",
+        "thumbnail" : DEFAULT_BOOK_COVER_URL
+    }
+
+    if book_id in bookMetadata:
+        data = bookMetadata[book_id]
+
+    return data
 
 def get_book_ids_by_title(book_titles):
     return books[books["title"].isin(book_titles)]["book_id"].values
@@ -19,19 +50,36 @@ def get_book_ids_by_title(book_titles):
 def get_all_book_titles():
     return books["title"].values
 
+def get_book_data_by_id(book_id):
+    return books[books["book_id"] == book_id].to_dict(orient="records")[0]
+
 def get_book_title(book_id):
     return books[books["book_id"] == book_id]["title"].values[0]
 
 def get_book_titles(book_ids):
     return books[books["book_id"].isin(book_ids)]["title"].values
 
-def update_user_ratings(upvotedBookIds, downvotedBookIds):
-    # upvotedBookIds =  [104, 103, 102, 110, 113, 124, 129, 135, 141, 142, 155, 161, 165, 176, 181, 974, 4443, 1496, 1003, 974, 2600] # TODO REMOVE
-    # downvotedBookIds =  [126, 179, 183, 184, 187, 9076, 960, 5895, 777, 6902, 2084, 584] # TODO REMOVE
+def find_closest_read_title(bookByRatingData, upvotedBookIds, targetBookId):
+    user_df = bookByRatingData.groupby(["user_id","book_id"])["rating"].mean().unstack()
 
-    # get the max user id in baseRatings
-    newUserId = baseRatings['user_id'].max() + 1
+    # drop all columns except the upvotedBookIds and the targetBookId
+    book_read_df = user_df[upvotedBookIds + [targetBookId]]    
 
+    # replace NaNs with 0
+    book_read_df = book_read_df.fillna(0)
+
+    # find the correlation between the targetBookId and the upvotedBookIds
+    corr_df = book_read_df.corr().unstack()
+
+    # find the closest book to the targetBookId that is NOT the targetBookId
+    closestBookId = corr_df[targetBookId][corr_df[targetBookId] < 1].idxmax()
+
+    # get the title of the closest book
+    closestReadBookData = get_book_data_by_id(closestBookId)
+
+    return closestReadBookData
+
+def update_user_ratings(upvotedBookIds, downvotedBookIds):
     RATING_FOR_UPVOTE = 5
     RATING_FOR_DOWNVOTE = 1
 
@@ -42,12 +90,12 @@ def update_user_ratings(upvotedBookIds, downvotedBookIds):
     for bookId in upvotedBookIds:
         appendBookIds.append(bookId)
         appendBookRatings.append(RATING_FOR_UPVOTE)
-        appendUserIds.append(newUserId)
+        appendUserIds.append(targetUserId)
 
     for bookId in downvotedBookIds:
         appendBookIds.append(bookId)
         appendBookRatings.append(RATING_FOR_DOWNVOTE)
-        appendUserIds.append(newUserId)
+        appendUserIds.append(targetUserId)
 
     newUserData = {
         'book_id': appendBookIds,
@@ -59,11 +107,11 @@ def update_user_ratings(upvotedBookIds, downvotedBookIds):
 
     ratings = pd.concat([baseRatings, newRows], ignore_index=True)
 
-    df = pd.merge(books, ratings, on="book_id", how="inner")
+    book_by_rating_df = pd.merge(books, ratings, on="book_id", how="inner")    
 
-    user_df = df.groupby(["user_id","title"])["rating"].mean().unstack()
+    user_df = book_by_rating_df.groupby(["user_id","title"])["rating"].mean().unstack()
     
-    targetUserDf = user_df[user_df.index == newUserId]
+    targetUserDf = user_df[user_df.index == targetUserId]
 
     targetBooksRead = targetUserDf.dropna(axis=1).columns.tolist()
 
@@ -78,9 +126,11 @@ def update_user_ratings(upvotedBookIds, downvotedBookIds):
     print(userBookCount)
 
     # from there get users who've read at least X percent of the main user
-    minBookCount = book_read_df.shape[1] * SIMILAR_USER_MIN_PERCENT_SHARED_BOOKS
+    minBookCount = int(book_read_df.shape[1] * SIMILAR_USER_MIN_PERCENT_SHARED_BOOKS)
+
+    minBookCount = min(minBookCount, MAX_MIN_BOOK_COUNT_FOR_SIMILAR_USER)
 
-    # print(minBookCount)
+    print(f'Min book count for Similar User: {minBookCount}')
 
     usersSameBooks = userBookCount[userBookCount > minBookCount].index
 
@@ -94,15 +144,25 @@ def update_user_ratings(upvotedBookIds, downvotedBookIds):
 
     corr_df = filted_df.T.corr().unstack()
 
-    top_readers = pd.DataFrame(corr_df[newUserId][corr_df[newUserId] > SIMILAR_USER_MIN_CORRELATION], columns=["corr"])
+    top_readers = None
 
+    minTopReaderCorrelation = SIMILAR_USER_MIN_CORRELATION
+    
+    while top_readers is None:
+        top_readers = pd.DataFrame(corr_df[targetUserId][corr_df[targetUserId] > minTopReaderCorrelation], columns=["corr"])
+
+        # if top_readers only has 1 row, then we need to lower the correlation threshold
+        if len(top_readers) <= 1:
+            minTopReaderCorrelation -= 0.05
+            top_readers = None
+    
     print(top_readers)
 
-    if (newUserId in top_readers.index):
-        top_readers = top_readers.drop(newUserId)    
+    if (targetUserId in top_readers.index):
+        top_readers = top_readers.drop(targetUserId)    
 
     # get the ratings for the top readers
-    top_readers_ratings = pd.merge(top_readers, df[["user_id", "book_id", "rating"]], how='inner', on="user_id")
+    top_readers_ratings = pd.merge(top_readers, book_by_rating_df[["user_id", "book_id", "rating"]], how='inner', on="user_id")
 
     # weight their ratings by how correlated they are with the user
     top_readers_ratings['weighted_rating'] = top_readers_ratings['corr'] * top_readers_ratings['rating']
@@ -118,15 +178,24 @@ def update_user_ratings(upvotedBookIds, downvotedBookIds):
     books_recommend = recommendation_df[recommendation_df["weighted_rating"] > 1].sort_values(by="weighted_rating", ascending=False).head(20)
 
     # get the recommended books (and sort by average_rating)
-    recommendedBooks = books[books["book_id"].isin(books_recommend.index)].sort_values(by="average_rating", ascending=False)
+    recommendedBooks = books[books["book_id"].isin(books_recommend.index)]
+
+    # sort recommended books by the weighted_rating in books_recommend
+    recommendedBooks = recommendedBooks.merge(books_recommend, on="book_id").sort_values(by="weighted_rating", ascending=False)
+
     # drop book_id column
-    recommendedBooks = recommendedBooks.drop(columns=["book_id"])
+    recommendedBooks = recommendedBooks.drop(columns=["average_rating"])
+
+    # get each row in the recommendedBooks dataframe as a dictionary
+    recommendedBooksRowsAsDicts = recommendedBooks.to_dict(orient="records")
 
     return {
         "upvotedBookIds": upvotedBookIds,
         "downvotedBookIds": downvotedBookIds,
         "numSimilarUsers" : len(usersSameBooks),
-        "recommendedBooksData": recommendedBooks,
+        "recommendedBooksData": recommendedBooksRowsAsDicts,
+        "bookByRatingData": book_by_rating_df,
+        
         # sort by correlation
         "topCorrelatedReadersData" : top_readers.sort_values(by="corr", ascending=False)
     }

requirements.txt

@@ -1 +1,10 @@
-scikit-learn
+streamlit
+numpy
+scikit-learn
+openai
+tqdm
+streamlit_modal
+python-dotenv
+
+# local packages
+-e .