Update app.py

app.py

@@ -94,31 +94,17 @@ def generate_embeddings(text_list, model_type):
     embeddings = response.embeddings
     return embeddings
 
-def calculate_relevancy_scores(df, model_type):
-    try:
-        page_contents = [fetch_content(url) for url in df['page']]
-        page_embeddings = generate_embeddings(page_contents, model_type)
-        query_embeddings = generate_embeddings(df['query'].tolist(), model_type)
-        relevancy_scores = cosine_similarity(query_embeddings, page_embeddings).diagonal()
-        df = df.assign(relevancy_score=relevancy_scores)
-    except Exception as e:
-        st.warning(f"Error calculating relevancy scores: {e}")
-        df = df.assign(relevancy_score=0)
-    return df
+def calculate_single_relevancy_score(page_content, query, model_type):
+    page_embedding = generate_embeddings([page_content], model_type)[0]
+    query_embedding = generate_embeddings([query], model_type)[0]
+    relevancy_score = cosine_similarity([query_embedding], [page_embedding])[0][0]
+    return relevancy_score
 
 def process_gsc_data(df):
-    # Remove the filter for queries below position 10
     df_sorted = df.sort_values(['impressions'], ascending=[False])
-    
-    # Keep only the highest impression query for each page
     df_unique = df_sorted.drop_duplicates(subset='page', keep='first')
-    
-    if 'relevancy_score' not in df_unique.columns:
-        df_unique['relevancy_score'] = 0
-    else:
-        df_unique['relevancy_score'] = df_sorted.groupby('page')['relevancy_score'].first().values
-    
-    result = df_unique[['page', 'query', 'clicks', 'impressions', 'ctr', 'position', 'relevancy_score']]
+    result = df_unique[['page', 'query', 'clicks', 'impressions', 'ctr', 'position']]
+    result['relevancy_score'] = None  # Initialize relevancy_score as None
     return result
 
 # -------------
@@ -300,58 +286,52 @@ def show_dimensions_selector(search_type):
         key='dimensions_selector'
     )
 
-def show_paginated_dataframe(report, rows_per_page=20):
-    # Convert 'position' column to integer and 'impressions' to numeric
+def show_paginated_dataframe(report, rows_per_page=20, model_type='english'):
     report['position'] = report['position'].astype(int)
     report['impressions'] = pd.to_numeric(report['impressions'], errors='coerce')
     
-    # Format CTR as percentage and relevancy_score with two decimal places
     def format_ctr(x):
         try:
             return f"{float(x):.2%}"
         except ValueError:
-            return x  # Return the original value if it can't be converted to float
+            return x
     
     def format_relevancy_score(x):
+        if x is None:
+            return "Not calculated"
         try:
             return f"{float(x):.2f}"
         except ValueError:
-            return x  # Return the original value if it can't be converted to float
+            return x
     
     report['ctr'] = report['ctr'].apply(format_ctr)
     report['relevancy_score'] = report['relevancy_score'].apply(format_relevancy_score)
     
-    # Create a clickable URL column
     def make_clickable(url):
         return f'<a href="{url}" target="_blank">{url}</a>'
     
     report['clickable_url'] = report['page'].apply(make_clickable)
     
-    # Reorder columns to put clickable_url first
-    columns = ['clickable_url', 'query', 'impressions', 'clicks', 'ctr', 'position', 'relevancy_score']
-    report = report[columns]
+    columns = ['clickable_url', 'query', 'impressions', 'clicks', 'ctr', 'position', 'relevancy_score', 'action']
+    report = report[columns[:-1]]  # Exclude 'action' from the DataFrame
 
-    # Add sorting functionality
-    sort_column = st.selectbox("Sort by:", columns[1:], index=columns[1:].index('impressions'))  # Set 'impressions' as default
+    sort_column = st.selectbox("Sort by:", columns[1:-1], index=columns[1:-1].index('impressions'))
     sort_order = st.radio("Sort order:", ("Descending", "Ascending"))
     
     ascending = sort_order == "Ascending"
     
-    # Convert back to numeric for sorting
     def safe_float_convert(x):
         try:
             return float(x.rstrip('%')) / 100 if isinstance(x, str) and x.endswith('%') else float(x)
         except ValueError:
-            return 0  # Return 0 or another default value if conversion fails
+            return 0
     
     report['ctr_numeric'] = report['ctr'].apply(safe_float_convert)
-    report['relevancy_score_numeric'] = report['relevancy_score'].apply(safe_float_convert)
+    report['relevancy_score_numeric'] = report['relevancy_score'].apply(lambda x: safe_float_convert(x) if x != "Not calculated" else -1)
     
-    # Sort using the numeric columns
     sort_column_numeric = sort_column + '_numeric' if sort_column in ['ctr', 'relevancy_score'] else sort_column
     report = report.sort_values(by=sort_column_numeric, ascending=ascending)
     
-    # Remove the temporary numeric columns
     report = report.drop(columns=['ctr_numeric', 'relevancy_score_numeric'])
 
     total_rows = len(report)
@@ -373,8 +353,42 @@ def show_paginated_dataframe(report, rows_per_page=20):
     start_idx = (st.session_state.current_page - 1) * rows_per_page
     end_idx = start_idx + rows_per_page
     
-    # Use st.markdown to display the dataframe with clickable links
-    st.markdown(report.iloc[start_idx:end_idx].to_html(escape=False, index=False), unsafe_allow_html=True)
+    # Create a placeholder for the dataframe
+    dataframe_placeholder = st.empty()
+    
+    # Function to update the dataframe
+    def update_dataframe():
+        df_html = report.iloc[start_idx:end_idx].to_html(escape=False, index=False)
+        df_html = df_html.replace('</table>', ''.join([
+            '<th>Action</th></tr>',
+            *[f'<tr><td colspan="7"></td><td><button onclick="calculate_relevancy({i})">Calculate Relevancy</button></td></tr>'
+              for i in range(start_idx, min(end_idx, len(report)))]
+        ]) + '</table>')
+        dataframe_placeholder.markdown(df_html, unsafe_allow_html=True)
+    
+    # Initial dataframe display
+    update_dataframe()
+    
+    # JavaScript to handle button clicks
+    st.markdown("""
+    <script>
+    function calculate_relevancy(row_index) {
+        Streamlit.setComponentValue('calculate_relevancy', row_index);
+    }
+    </script>
+    """, unsafe_allow_html=True)
+    
+    # Handle relevancy calculation
+    if st.session_state.get('calculate_relevancy'):
+        row_index = st.session_state.calculate_relevancy
+        page_content = fetch_content(report.iloc[row_index]['page'])
+        query = report.iloc[row_index]['query']
+        relevancy_score = calculate_single_relevancy_score(page_content, query, model_type)
+        report.at[row_index, 'relevancy_score'] = relevancy_score
+        st.session_state.calculate_relevancy = None  # Reset the state
+        update_dataframe()  # Update the dataframe display
+
+    return report
 # -------------
 # Main Streamlit App Function
 # -------------
@@ -425,11 +439,8 @@ def main():
                     st.session_state.report_data = fetch_gsc_data(webproperty, search_type, start_date, end_date, selected_dimensions)
 
             if st.session_state.report_data is not None and not st.session_state.report_data.empty:
-                st.write("Data fetched successfully. Click the button below to calculate relevancy scores.")
-            
-                if st.button("Calculate Relevancy Scores"):
-                    st.session_state.report_data = calculate_relevancy_scores(st.session_state.report_data, model_type)
-                show_paginated_dataframe(st.session_state.report_data)
+                st.write("Data fetched successfully. Click the 'Calculate Relevancy' button in each row to calculate its relevancy score.")
+                st.session_state.report_data = show_paginated_dataframe(st.session_state.report_data, model_type=model_type)
                 download_csv_link(st.session_state.report_data)
             elif st.session_state.report_data is not None:
                 st.warning("No data found for the selected criteria.")