Update app.py

app.py

@@ -42,29 +42,36 @@ transhuman_glossary = {
     "Cybernetics": ["Robotic Limbs", "Augmented Eyes"],
 }
 
+
 def process_text(text):
     """🕵️ process_text: detective style—prints lines to Streamlit for debugging."""
     st.write(f"process_text called with: {text}")
 
+
 def search_arxiv(text):
     """🔭 search_arxiv: pretend to search ArXiv, just prints debug for now."""
     st.write(f"search_arxiv called with: {text}")
 
+
 def SpeechSynthesis(text):
     """🗣 SpeechSynthesis: read lines out loud? Here, we log them for demonstration."""
     st.write(f"SpeechSynthesis called with: {text}")
 
+
 def process_image(image_file, prompt):
     """📷 process_image: imagine an AI pipeline for images, here we just log."""
     return f"[process_image placeholder] {image_file} => {prompt}"
 
+
 def process_video(video_file, seconds_per_frame):
     """🎞 process_video: placeholder for video tasks, logs to Streamlit."""
     st.write(f"[process_video placeholder] {video_file}, {seconds_per_frame} sec/frame")
 
+
 API_URL = "https://huggingface-inference-endpoint-placeholder"
 API_KEY = "hf_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
 
+
 @st.cache_resource
 def InferenceLLM(prompt):
     """🔮 InferenceLLM: a stub returning a mock response for 'prompt'."""
@@ -77,7 +84,7 @@ def InferenceLLM(prompt):
 @st.cache_resource
 def display_glossary_entity(k):
     """
-    Creates multiple link emojis for a single entity. 
+    Creates multiple link emojis for a single entity.
     Each link might point to /?q=..., /?q=<prefix>..., or external sites.
     """
     search_urls = {
@@ -94,6 +101,7 @@ def display_glossary_entity(k):
     links_md = ' '.join([f"[{emoji}]({url(k)})" for emoji, url in search_urls.items()])
     st.markdown(f"**{k}** <small>{links_md}</small>", unsafe_allow_html=True)
 
+
 def display_content_or_image(query):
     """
     If 'query' is in transhuman_glossary or there's an image matching 'images/<query>.png',
@@ -112,6 +120,7 @@ def display_content_or_image(query):
     st.warning("No matching content or image found.")
     return False
 
+
 def clear_query_params():
     """For fully clearing, you'd do a redirect or st.experimental_set_query_params()."""
     st.warning("Define a redirect or link without query params if you want to truly clear them.")
@@ -128,6 +137,7 @@ def load_file(file_path):
     except:
         return ""
 
+
 @st.cache_resource
 def create_zip_of_files(files):
     """Combine multiple local files into a single .zip for user to download."""
@@ -137,6 +147,7 @@ def create_zip_of_files(files):
             zipf.write(file)
     return zip_name
 
+
 @st.cache_resource
 def get_zip_download_link(zip_file):
     """Return an <a> link to download the given zip_file (base64-encoded)."""
@@ -145,6 +156,7 @@ def get_zip_download_link(zip_file):
     b64 = base64.b64encode(data).decode()
     return f'<a href="data:application/zip;base64,{b64}" download="{zip_file}">Download All</a>'
 
+
 def get_table_download_link(file_path):
     """
     Creates a download link for a single file from your snippet.
@@ -170,10 +182,12 @@ def get_table_download_link(file_path):
     except:
         return ''
 
+
 def get_file_size(file_path):
     """Get file size in bytes."""
     return os.path.getsize(file_path)
 
+
 def FileSidebar():
     """
     Renders .md files in the sidebar with open/view/run/delete logic.
@@ -181,6 +195,7 @@ def FileSidebar():
     all_files = glob.glob("*.md")
     # If you want to filter out short-named or special files:
     all_files = [f for f in all_files if len(os.path.splitext(f)[0]) >= 5]
+    # sorting in place
     all_files.sort(key=lambda x: (os.path.splitext(x)[1], x), reverse=True)
 
     # Buttons for "Delete All" and "Download"
@@ -201,9 +216,9 @@ def FileSidebar():
 
     # Each file row
     for file in all_files:
-        col1, col2, col3, col4, col5 = st.sidebar.columns([1,6,1,1,1])
+        col1, col2, col3, col4, col5 = st.sidebar.columns([1, 6, 1, 1, 1])
         with col1:
-            if st.button("🌐", key="md_"+file):
+            if st.button("🌐", key="md_" + file):
                 file_contents = load_file(file)
                 file_name = file
                 next_action = 'md'
@@ -211,7 +226,7 @@ def FileSidebar():
         with col2:
             st.markdown(get_table_download_link(file), unsafe_allow_html=True)
         with col3:
-            if st.button("📂", key="open_"+file):
+            if st.button("📂", key="open_" + file):
                 file_contents = load_file(file)
                 file_name = file
                 next_action = 'open'
@@ -220,13 +235,13 @@ def FileSidebar():
                 st.session_state['filetext'] = file_contents
                 st.session_state['next_action'] = next_action
         with col4:
-            if st.button("▶️", key="read_"+file):
+            if st.button("▶️", key="read_" + file):
                 file_contents = load_file(file)
                 file_name = file
                 next_action = 'search'
                 st.session_state['next_action'] = next_action
         with col5:
-            if st.button("🗑", key="delete_"+file):
+            if st.button("🗑", key="delete_" + file):
                 os.remove(file)
                 st.rerun()
 
@@ -255,15 +270,18 @@ def FileSidebar():
             if st.button("🔍Run"):
                 st.write("Running GPT logic placeholder...")
 
+
 # =====================================================================================
 #  4) SCORING / GLOSSARIES
 # =====================================================================================
 score_dir = "scores"
 os.makedirs(score_dir, exist_ok=True)
 
+
 def generate_key(label, header, idx):
     return f"{header}_{label}_{idx}_key"
 
+
 def update_score(key, increment=1):
     """Increment the 'score' for a glossary item in JSON storage."""
     score_file = os.path.join(score_dir, f"{key}.json")
@@ -278,6 +296,7 @@ def update_score(key, increment=1):
         json.dump(score_data, file)
     return score_data["score"]
 
+
 def load_score(key):
     """Load the stored score from .json if it exists, else 0."""
     file_path = os.path.join(score_dir, f"{key}.json")
@@ -287,6 +306,7 @@ def load_score(key):
         return score_data["score"]
     return 0
 
+
 def display_buttons_with_scores(num_columns_text):
     """
     Show glossary items as clickable buttons, each increments a 'score'.
@@ -325,6 +345,7 @@ def display_buttons_with_scores(num_columns_text):
                     newscore = update_score(key.replace('?', ''))
                     st.markdown(f"Scored **{category} - {game} - {term}** -> {newscore}")
 
+
 # =====================================================================================
 #  5) IMAGES & VIDEOS
 # =====================================================================================
@@ -354,6 +375,7 @@ def display_images_and_wikipedia_summaries(num_columns=4):
                 st.write(f"Could not open {image_file}")
         col_index += 1
 
+
 def display_videos_and_links(num_columns=4):
     """Displays all .mp4/.webm in a grid, plus text input for prompts."""
     video_files = [f for f in os.listdir('.') if f.endswith(('.mp4', '.webm'))]
@@ -379,6 +401,7 @@ def display_videos_and_links(num_columns=4):
                     st.error("Invalid input for seconds per frame!")
         col_index += 1
 
+
 # =====================================================================================
 #  6) MERMAID & PARTIAL SUBGRAPH LOGIC
 # =====================================================================================
@@ -410,6 +433,7 @@ def generate_mermaid_html(mermaid_code: str) -> str:
     </html>
     """
 
+
 def append_model_param(url: str, model_selected: bool) -> str:
     """If user selects 'model=1', we append &model=1 or ?model=1 if not present."""
     if not model_selected:
@@ -417,17 +441,19 @@ def append_model_param(url: str, model_selected: bool) -> str:
     delimiter = "&" if "?" in url else "?"
     return f"{url}{delimiter}model=1"
 
+
 def inject_base_url(url: str) -> str:
     """If link doesn't start with 'http', prepend BASE_URL so it's absolute."""
     if url.startswith("http"):
         return url
     return f"{BASE_URL}{url}"
 
+
 # We'll keep the default mermaid that references /?q=...
 DEFAULT_MERMAID = r"""
 flowchart LR
     U((User 😎)) -- "Talk 🗣️" --> LLM[LLM Agent 🤖\nExtract Info]
-    click U "/?q=User%20😎" "Open 'User 😎'" _blank
+    click U "/?q=U" "Open 'User 😎'" _blank
     click LLM "/?q=LLM%20Agent%20Extract%20Info" "Open LLM Agent" _blank
 
     LLM -- "Query 🔍" --> HS[Hybrid Search 🔎\nVector+NER+Lexical]
@@ -440,10 +466,7 @@ flowchart LR
     click KG "/?q=Knowledge%20Graph%20Ontology+GAR+RAG" "Open Knowledge Graph" _blank
 """
 
-# ------------------------------------------------------------------------------------
-# 🍁 Parsing and building partial subgraphs from lines like "A -- Label --> B"
-#     We'll do BFS so we can gather multiple downstream levels if we want.
-# ------------------------------------------------------------------------------------
+
 def parse_mermaid_edges(mermaid_text: str):
     """
     🍿 parse_mermaid_edges:
@@ -462,12 +485,12 @@ def parse_mermaid_edges(mermaid_text: str):
             adjacency[nodeA].append((label, nodeB))
     return adjacency
 
+
 def bfs_subgraph(adjacency, start_node, depth=1):
     """
     🍎 bfs_subgraph:
       - Gather edges up to 'depth' levels from start_node
       - If depth=1, only direct edges from node
-      - If depth=2, child and grandchild, etc.
     """
     from collections import deque
     visited = set()
@@ -487,13 +510,19 @@ def bfs_subgraph(adjacency, start_node, depth=1):
 
     return edges
 
+
 def create_subgraph_mermaid(sub_edges, start_node):
     """
     🍄 create_subgraph_mermaid:
       - build a smaller flowchart snippet with edges from BFS
     """
     sub_mermaid = "flowchart LR\n"
-    sub_mermaid += f"    %% SearchResult Subgraph starting at {start_node}\n"
+    sub_mermaid += f"    %% SearchResult Subgraph for {start_node}\n"
+    if not sub_edges:
+        # If no edges, show just the node
+        sub_mermaid += f"    {start_node}\n"
+        sub_mermaid += "    %% End of partial subgraph\n"
+        return sub_mermaid
     for (A, label, B) in sub_edges:
         sub_mermaid += f'    {A} -- "{label}" --> {B}\n'
     sub_mermaid += "    %% End of partial subgraph\n"
@@ -537,19 +566,27 @@ def main():
     for line in lines:
         if "click " in line and '"/?' in line:
             # try to parse out the URL
-            parts = re.split(r'click\s+\S+\s+"([^"]+)"\s+"([^"]+)"\s+"([^"]+)"', line)
-            # For example:  parts might be  [prefix, '/?q=User%20😎', 'Open User 😎', '_blank', remainder?]
-            if len(parts) == 5:
+            parts = re.split(r'click\s+\S+\s+"([^"]+)"\s+"([^"]+)"\s+(\S+)', line)
+            # For example: 
+            #  'click U "/?q=U" "Open 'User 😎'" _blank'
+            # might become: 
+            #  parts = [prefix, '/?q=U', "Open 'User 😎'", '_blank', '']
+            if len(parts) >= 4:
                 # Reassemble with base URL + optional model param
                 old_url = parts[1]
                 tooltip = parts[2]
                 target = parts[3]
+
                 # 1) base
                 new_url = inject_base_url(old_url)
                 # 2) model param
                 new_url = append_model_param(new_url, model_selected)
 
-                new_line = f"{parts[0]}\"{new_url}\" \"{tooltip}\" \"{target}\"{parts[4]}"
+                # Rebuild the line
+                new_line = f"{parts[0]}\"{new_url}\" \"{tooltip}\" {target}"
+                # If there's a remainder (parts[4]) it might be an empty string
+                if len(parts) > 4:
+                    new_line += parts[4]
                 new_lines.append(new_line)
             else:
                 new_lines.append(line)
@@ -559,32 +596,35 @@ def main():
     final_mermaid = "\n".join(new_lines)
     adjacency = parse_mermaid_edges(final_mermaid)
 
-    # 4) If user clicked a shape -> we show a partial subgraph as "SearchResult"
-    #    We'll do BFS with depth=1 or 2 for demonstration:
+    # 4) If user clicked a shape => we show a partial subgraph as "SearchResult"
     partial_subgraph_html = ""
     if q_or_query:
-        st.info(f"process_text called with: {PromptPrefix}{q_or_query}")
-        # Attempt to find a node whose ID or label includes q_or_query:
-        # This may require advanced logic if your IDs differ from labels.
-        # We'll do a naive approach: if q_or_query is substring of adjacency keys.
-        possible_keys = []
-        for nodeKey in adjacency.keys():
-            # e.g. nodeKey might be: 'LLM[LLM Agent 🤖\nExtract Info]'
-            # we'll check if q_or_query is substring ignoring spaces
-            simplified_key = nodeKey.replace("\\n", " ").replace("[", "").replace("]", "").lower()
-            simplified_query = q_or_query.lower().replace("%20", " ")
-            if simplified_query in simplified_key:
-                possible_keys.append(nodeKey)
-
-        if possible_keys:
-            chosen_node = possible_keys[0]
-            st.info(f"Chosen node for subgraph: {chosen_node}")
-            sub_edges = bfs_subgraph(adjacency, chosen_node, depth=1)
-            if sub_edges:
-                sub_mermaid = create_subgraph_mermaid(sub_edges, chosen_node)
-                partial_subgraph_html = generate_mermaid_html(sub_mermaid)
+        # Special-case if user clicked "User" => q=U => we know the node is "U((User 😎))"
+        if q_or_query == "U":
+            chosen_node = "U((User 😎))"
+            st.info(f"process_text called with: {PromptPrefix}{q_or_query}  => forcing node U((User 😎))")
         else:
-            st.warning("No adjacency node matched the query param's text. Subgraph is empty.")
+            st.info(f"process_text called with: {PromptPrefix}{q_or_query}")
+            # Attempt to find a node whose ID or label includes q_or_query:
+            possible_keys = []
+            for nodeKey in adjacency.keys():
+                # e.g. nodeKey might be 'U((User 😎))'
+                simplified_key = nodeKey.replace("\\n", " ").replace("[", "").replace("]", "").lower()
+                simplified_query = q_or_query.lower().replace("%20", " ")
+                if simplified_query in simplified_key:
+                    possible_keys.append(nodeKey)
+
+            if possible_keys:
+                chosen_node = possible_keys[0]
+            else:
+                chosen_node = None
+                st.warning("No adjacency node matched the query param's text. Subgraph is empty.")
+
+        if chosen_node:
+            # BFS subgraph for chosen_node with depth=1
+            sub_edges = bfs_subgraph(adjacency, chosen_node, depth=1)
+            sub_mermaid = create_subgraph_mermaid(sub_edges, chosen_node)
+            partial_subgraph_html = generate_mermaid_html(sub_mermaid)
 
     # 5) Show partial subgraph top-center if we have any
     if partial_subgraph_html:
@@ -593,6 +633,7 @@ def main():
 
     # 6) Render the top-centered *full* diagram
     st.title("Full Mermaid Diagram (with Base URL + model=1 logic)")
+
     diagram_html = generate_mermaid_html(final_mermaid)
     components.html(diagram_html, height=400, scrolling=True)