Update app.py

app.py

@@ -109,7 +109,7 @@ with col3:
 
 # Checkbox to control whether to show only exact matches
 show_exact_matches = st.checkbox("Show only exact matches", value=False)
-button = st.button("Refresh Search")
+####L button = st.button("Refresh Search")
 
 def filter_results(results, country_filter, region_filter, end_year_range):
     filtered = []
@@ -143,195 +143,195 @@ def filter_results(results, country_filter, region_filter, end_year_range):
             filtered.append(r)
     return filtered
 
-if button:
-    # 1) Adjust limit so we get more than 15 results
-    results = hybrid_search(client, var, collection_name, limit=500)  # e.g., 100 or 200
-
-    # results is a tuple: (semantic_results, lexical_results)
-    semantic_all = results[0]
-    lexical_all = results[1]
-
-    # 2) Filter out content < 20 chars (as intermediate fix to problem that e.g. super short paragraphs with few chars get high similarity score)
-    semantic_all = [
-        r for r in semantic_all if len(r.payload["page_content"]) >= 70
-    ]
-    lexical_all = [
-        r for r in lexical_all if len(r.payload["page_content"]) >= 70
-    ]
-    
-    # 2) Apply a threshold to SEMANTIC results (score >= 0.4)
-    semantic_thresholded = [r for r in semantic_all if r.score >= 0.4]
-    
-    # 2) Filter the entire sets
-    filtered_semantic = filter_results(semantic_thresholded, country_filter, region_filter, end_year_range)
-    filtered_lexical = filter_results(lexical_all, country_filter, region_filter, end_year_range)
+####Lif button:
+# 1) Adjust limit so we get more than 15 results
+results = hybrid_search(client, var, collection_name, limit=500)  # e.g., 100 or 200
+
+# results is a tuple: (semantic_results, lexical_results)
+semantic_all = results[0]
+lexical_all = results[1]
+
+# 2) Filter out content < 20 chars (as intermediate fix to problem that e.g. super short paragraphs with few chars get high similarity score)
+semantic_all = [
+    r for r in semantic_all if len(r.payload["page_content"]) >= 70
+]
+lexical_all = [
+    r for r in lexical_all if len(r.payload["page_content"]) >= 70
+]
+
+# 2) Apply a threshold to SEMANTIC results (score >= 0.4)
+semantic_thresholded = [r for r in semantic_all if r.score >= 0.4]
+
+# 2) Filter the entire sets
+filtered_semantic = filter_results(semantic_thresholded, country_filter, region_filter, end_year_range)
+filtered_lexical = filter_results(lexical_all, country_filter, region_filter, end_year_range)
+
+filtered_semantic_no_dupe = remove_duplicates(filtered_semantic)
+filtered_lexical_no_dupe = remove_duplicates(filtered_lexical)
+
+
+# 3) Retrieve top 15 *after* filtering
+# Check user preference
+if show_exact_matches:
+    # 1) Display heading
+    st.write(f"Showing **Top 15 Lexical Search results** for query: {var}")
+
+    # 2) Do a simple substring check (case-insensitive)
+    #    We'll create a new list lexical_substring_filtered
+    query_substring = var.strip().lower()
+    lexical_substring_filtered = []
+    for r in lexical_all:
+        # page_content in lowercase
+        page_text_lower = r.payload["page_content"].lower()
+        # Keep this result only if the query substring is found
+        if query_substring in page_text_lower:
+            lexical_substring_filtered.append(r)
+
+    # 3) Now apply your region/country/year filter on that new list
+    filtered_lexical = filter_results(
+        lexical_substring_filtered, country_filter, region_filter, end_year_range
+    )
 
-    filtered_semantic_no_dupe = remove_duplicates(filtered_semantic)
+    # 4) Remove duplicates
     filtered_lexical_no_dupe = remove_duplicates(filtered_lexical)
 
+    # 5) If empty after substring + filters + dedupe, show a custom message
+    if not filtered_lexical_no_dupe:
+        st.write('No exact matches, consider unchecking "Show only exact matches"')
+    else:
+        # 6) Display the first 15 matching results
+        for res in filtered_lexical_no_dupe[:15]:
+            project_name = res.payload['metadata'].get('project_name', 'Project Link')
+            url = res.payload['metadata'].get('url', '#')
+            st.markdown(f"#### [{project_name}]({url})")
+
+            # Snippet logic (80 words)
+            full_text = res.payload['page_content']
+            words = full_text.split()
+            preview_word_count = 80
+            preview_text = " ".join(words[:preview_word_count])
+            remainder_text = " ".join(words[preview_word_count:])
+            st.write(preview_text + ("..." if remainder_text else ""))
+
+            # Keywords
+            top_keywords = extract_top_keywords(full_text, top_n=5)
+            if top_keywords:
+                st.markdown(f"_{' · '.join(top_keywords)}_")
+
+            # Metadata
+            metadata = res.payload.get('metadata', {})
+            countries = metadata.get('countries', "[]")
+            client_name = metadata.get('client', 'Unknown Client')
+            start_year = metadata.get('start_year', None)
+            end_year_ = metadata.get('end_year', None)
+            
+            try:
+                c_list = json.loads(countries.replace("'", '"'))
+            except json.JSONDecodeError:
+                c_list = []
+            
+            # Only keep country names if the region lookup (get_country_name) 
+            # returns something different than the raw code.
+            matched_countries = []
+            for code in c_list:
+                if len(code) == 2:
+                    resolved_name = get_country_name(code.upper(), region_df)
+                    # If get_country_name didn't find a match, 
+                    # it typically just returns the same code (like "XX"). 
+                    # We'll consider "successfully looked up" if 
+                    # resolved_name != code.upper().
+                    if resolved_name.upper() != code.upper():
+                        matched_countries.append(resolved_name)
+            
+            # Format the year range
+            start_year_str = f"{int(round(float(start_year)))}" if start_year else "Unknown"
+            end_year_str = f"{int(round(float(end_year_)))}" if end_year_ else "Unknown"
+            
+            # Build the final string
+            if matched_countries:
+                # We have at least 1 valid country name
+                additional_text = (
+                    f"**{', '.join(matched_countries)}**, commissioned by **{client_name}**, "
+                    f"**{start_year_str}-{end_year_str}**"
+                )
+            else:
+                # No valid countries found
+                additional_text = (
+                    f"Commissioned by **{client_name}**, **{start_year_str}-{end_year_str}**"
+                )
+            
+            st.markdown(additional_text)
+            st.divider()
 
-    # 3) Retrieve top 15 *after* filtering
-    # Check user preference
-    if show_exact_matches:
-        # 1) Display heading
-        st.write(f"Showing **Top 15 Lexical Search results** for query: {var}")
-    
-        # 2) Do a simple substring check (case-insensitive)
-        #    We'll create a new list lexical_substring_filtered
-        query_substring = var.strip().lower()
-        lexical_substring_filtered = []
-        for r in lexical_all:
-            # page_content in lowercase
-            page_text_lower = r.payload["page_content"].lower()
-            # Keep this result only if the query substring is found
-            if query_substring in page_text_lower:
-                lexical_substring_filtered.append(r)
-    
-        # 3) Now apply your region/country/year filter on that new list
-        filtered_lexical = filter_results(
-            lexical_substring_filtered, country_filter, region_filter, end_year_range
-        )
-    
-        # 4) Remove duplicates
-        filtered_lexical_no_dupe = remove_duplicates(filtered_lexical)
-    
-        # 5) If empty after substring + filters + dedupe, show a custom message
-        if not filtered_lexical_no_dupe:
-            st.write('No exact matches, consider unchecking "Show only exact matches"')
-        else:
-            # 6) Display the first 15 matching results
-            for res in filtered_lexical_no_dupe[:15]:
-                project_name = res.payload['metadata'].get('project_name', 'Project Link')
-                url = res.payload['metadata'].get('url', '#')
-                st.markdown(f"#### [{project_name}]({url})")
-    
-                # Snippet logic (80 words)
-                full_text = res.payload['page_content']
-                words = full_text.split()
-                preview_word_count = 80
-                preview_text = " ".join(words[:preview_word_count])
-                remainder_text = " ".join(words[preview_word_count:])
-                st.write(preview_text + ("..." if remainder_text else ""))
-    
-                # Keywords
-                top_keywords = extract_top_keywords(full_text, top_n=5)
-                if top_keywords:
-                    st.markdown(f"_{' · '.join(top_keywords)}_")
-    
-                # Metadata
-                metadata = res.payload.get('metadata', {})
-                countries = metadata.get('countries', "[]")
-                client_name = metadata.get('client', 'Unknown Client')
-                start_year = metadata.get('start_year', None)
-                end_year_ = metadata.get('end_year', None)
-                
-                try:
-                    c_list = json.loads(countries.replace("'", '"'))
-                except json.JSONDecodeError:
-                    c_list = []
-                
-                # Only keep country names if the region lookup (get_country_name) 
-                # returns something different than the raw code.
-                matched_countries = []
-                for code in c_list:
-                    if len(code) == 2:
-                        resolved_name = get_country_name(code.upper(), region_df)
-                        # If get_country_name didn't find a match, 
-                        # it typically just returns the same code (like "XX"). 
-                        # We'll consider "successfully looked up" if 
-                        # resolved_name != code.upper().
-                        if resolved_name.upper() != code.upper():
-                            matched_countries.append(resolved_name)
-                
-                # Format the year range
-                start_year_str = f"{int(round(float(start_year)))}" if start_year else "Unknown"
-                end_year_str = f"{int(round(float(end_year_)))}" if end_year_ else "Unknown"
-                
-                # Build the final string
-                if matched_countries:
-                    # We have at least 1 valid country name
-                    additional_text = (
-                        f"**{', '.join(matched_countries)}**, commissioned by **{client_name}**, "
-                        f"**{start_year_str}-{end_year_str}**"
-                    )
-                else:
-                    # No valid countries found
-                    additional_text = (
-                        f"Commissioned by **{client_name}**, **{start_year_str}-{end_year_str}**"
-                    )
-                
-                st.markdown(additional_text)
-                st.divider()
+else:
+    st.write(f"Showing **Top 15 Semantic Search results** for query: {var}")
     
+    if not filtered_semantic_no_dupe:
+        st.write("No relevant results found.")
     else:
-        st.write(f"Showing **Top 15 Semantic Search results** for query: {var}")
-        
-        if not filtered_semantic_no_dupe:
-            st.write("No relevant results found.")
-        else:
-            # Show the top 15 from filtered_semantic
-            for res in filtered_semantic_no_dupe[:15]:
-                project_name = res.payload['metadata'].get('project_name', 'Project Link')
-                url = res.payload['metadata'].get('url', '#')
-                st.markdown(f"#### [{project_name}]({url})")
-    
-                # Snippet logic
-                full_text = res.payload['page_content']
-                words = full_text.split()
-                preview_word_count = 80
-                preview_text = " ".join(words[:preview_word_count])
-                remainder_text = " ".join(words[preview_word_count:])
-                st.write(preview_text + ("..." if remainder_text else ""))
-    
-                # Keywords
-                top_keywords = extract_top_keywords(full_text, top_n=5)
-                if top_keywords:
-                    st.markdown(f"_{' · '.join(top_keywords)}_")
-    
-                # Metadata
-                metadata = res.payload.get('metadata', {})
-                countries = metadata.get('countries', "[]")
-                client_name = metadata.get('client', 'Unknown Client')
-                start_year = metadata.get('start_year', None)
-                end_year_ = metadata.get('end_year', None)
-                
-                try:
-                    c_list = json.loads(countries.replace("'", '"'))
-                except json.JSONDecodeError:
-                    c_list = []
-                
-                # Only keep country names if the region lookup (get_country_name) 
-                # returns something different than the raw code.
-                matched_countries = []
-                for code in c_list:
-                    if len(code) == 2:
-                        resolved_name = get_country_name(code.upper(), region_df)
-                        # If get_country_name didn't find a match, 
-                        # it typically just returns the same code (like "XX"). 
-                        # We'll consider "successfully looked up" if 
-                        # resolved_name != code.upper().
-                        if resolved_name.upper() != code.upper():
-                            matched_countries.append(resolved_name)
-                
-                # Format the year range
-                start_year_str = f"{int(round(float(start_year)))}" if start_year else "Unknown"
-                end_year_str = f"{int(round(float(end_year_)))}" if end_year_ else "Unknown"
-                
-                # Build the final string
-                if matched_countries:
-                    # We have at least 1 valid country name
-                    additional_text = (
-                        f"**{', '.join(matched_countries)}**, commissioned by **{client_name}**, "
-                        f"**{start_year_str}-{end_year_str}**"
-                    )
-                else:
-                    # No valid countries found
-                    additional_text = (
-                        f"Commissioned by **{client_name}**, **{start_year_str}-{end_year_str}**"
-                    )
-                
-                st.markdown(additional_text)
-                st.divider()
+        # Show the top 15 from filtered_semantic
+        for res in filtered_semantic_no_dupe[:15]:
+            project_name = res.payload['metadata'].get('project_name', 'Project Link')
+            url = res.payload['metadata'].get('url', '#')
+            st.markdown(f"#### [{project_name}]({url})")
+
+            # Snippet logic
+            full_text = res.payload['page_content']
+            words = full_text.split()
+            preview_word_count = 80
+            preview_text = " ".join(words[:preview_word_count])
+            remainder_text = " ".join(words[preview_word_count:])
+            st.write(preview_text + ("..." if remainder_text else ""))
+
+            # Keywords
+            top_keywords = extract_top_keywords(full_text, top_n=5)
+            if top_keywords:
+                st.markdown(f"_{' · '.join(top_keywords)}_")
+
+            # Metadata
+            metadata = res.payload.get('metadata', {})
+            countries = metadata.get('countries', "[]")
+            client_name = metadata.get('client', 'Unknown Client')
+            start_year = metadata.get('start_year', None)
+            end_year_ = metadata.get('end_year', None)
+            
+            try:
+                c_list = json.loads(countries.replace("'", '"'))
+            except json.JSONDecodeError:
+                c_list = []
+            
+            # Only keep country names if the region lookup (get_country_name) 
+            # returns something different than the raw code.
+            matched_countries = []
+            for code in c_list:
+                if len(code) == 2:
+                    resolved_name = get_country_name(code.upper(), region_df)
+                    # If get_country_name didn't find a match, 
+                    # it typically just returns the same code (like "XX"). 
+                    # We'll consider "successfully looked up" if 
+                    # resolved_name != code.upper().
+                    if resolved_name.upper() != code.upper():
+                        matched_countries.append(resolved_name)
+            
+            # Format the year range
+            start_year_str = f"{int(round(float(start_year)))}" if start_year else "Unknown"
+            end_year_str = f"{int(round(float(end_year_)))}" if end_year_ else "Unknown"
+            
+            # Build the final string
+            if matched_countries:
+                # We have at least 1 valid country name
+                additional_text = (
+                    f"**{', '.join(matched_countries)}**, commissioned by **{client_name}**, "
+                    f"**{start_year_str}-{end_year_str}**"
+                )
+            else:
+                # No valid countries found
+                additional_text = (
+                    f"Commissioned by **{client_name}**, **{start_year_str}-{end_year_str}**"
+                )
+            
+            st.markdown(additional_text)
+            st.divider()
 
 
     #  for i in results: