Update app.py

app.py

@@ -15,12 +15,12 @@ from urllib.parse import quote
 import streamlit as st
 import streamlit.components.v1 as components
 
-# huggingface_hub usage if you do model inference
-#from huggingface_hub import InferenceClient
+# 🏰 If you do model inference via huggingface_hub
+# from huggingface_hub import InferenceClient
 
-########################################################################################
-# 1) GLOBAL CONFIG & PLACEHOLDERS
-########################################################################################
+# =====================================================================================
+#  1) GLOBAL CONFIG & PLACEHOLDERS
+# =====================================================================================
 BASE_URL = "https://huggingface.co/spaces/awacke1/MermaidMarkdownDiagramEditor"
 
 PromptPrefix = "AI-Search: "
@@ -42,42 +42,45 @@ transhuman_glossary = {
     "Cybernetics": ["Robotic Limbs", "Augmented Eyes"],
 }
 
-########################################################################################
-# 2) SIMPLE HELPER FUNCS
-########################################################################################
 
 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? For demo, we just log them."""
+    """🗣 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'."""
     return f"[InferenceLLM placeholder response to prompt: {prompt}]"
 
-########################################################################################
-# 3) GLOSSARY & FILE UTILITY
-########################################################################################
 
+# =====================================================================================
+#  2) GLOSSARY & FILE UTILITY
+# =====================================================================================
 @st.cache_resource
 def display_glossary_entity(k):
     """
@@ -98,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',
@@ -116,14 +120,15 @@ def display_content_or_image(query):
     st.warning("No matching content or image found.")
     return False
 
+
 def clear_query_params():
-    """If you want to truly remove them, do a redirect or st.experimental_set_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.")
 
-########################################################################################
-# 4) FILE-HANDLING (MD files, etc.)
-########################################################################################
 
+# =====================================================================================
+#  3) FILE-HANDLING (MD files, etc.)
+# =====================================================================================
 def load_file(file_path):
     """Load file contents as UTF-8 text, or return empty on error."""
     try:
@@ -132,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."""
@@ -141,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)."""
@@ -149,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.
@@ -174,15 +182,18 @@ 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.
     """
     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]
     all_files.sort(key=lambda x: (os.path.splitext(x)[1], x), reverse=True)
 
@@ -202,9 +213,9 @@ def FileSidebar():
     next_action = ''
 
     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'
@@ -212,7 +223,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'
@@ -221,13 +232,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()
 
@@ -237,6 +248,7 @@ def FileSidebar():
             with open1:
                 file_name_input = st.text_input('File Name:', file_name, key='file_name_input')
                 file_content_area = st.text_area('File Contents:', file_contents, height=300, key='file_content_area')
+
                 if st.button('💾 Save File'):
                     with open(file_name_input, 'w', encoding='utf-8') as f:
                         f.write(file_content_area)
@@ -255,15 +267,18 @@ def FileSidebar():
             if st.button("🔍Run"):
                 st.write("Running GPT logic placeholder...")
 
-########################################################################################
-# 5) SCORING / GLOSSARIES
-########################################################################################
+
+# =====================================================================================
+#  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 +293,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 +303,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,10 +342,10 @@ def display_buttons_with_scores(num_columns_text):
                     newscore = update_score(key.replace('?', ''))
                     st.markdown(f"Scored **{category} - {game} - {term}** -> {newscore}")
 
-########################################################################################
-# 6) IMAGES & VIDEOS
-########################################################################################
 
+# =====================================================================================
+#  5) IMAGES & VIDEOS
+# =====================================================================================
 def display_images_and_wikipedia_summaries(num_columns=4):
     """Display .png images in a grid, referencing the name as a 'keyword'."""
     image_files = [f for f in os.listdir('.') if f.endswith('.png')]
@@ -339,6 +356,7 @@ def display_images_and_wikipedia_summaries(num_columns=4):
     image_files_sorted = sorted(image_files, key=lambda x: len(x.split('.')[0]))
     cols = st.columns(num_columns)
     col_index = 0
+
     for image_file in image_files_sorted:
         with cols[col_index % num_columns]:
             try:
@@ -354,6 +372,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'))]
@@ -364,6 +383,7 @@ def display_videos_and_links(num_columns=4):
     video_files_sorted = sorted(video_files, key=lambda x: len(x.split('.')[0]))
     cols = st.columns(num_columns)
     col_index = 0
+
     for video_file in video_files_sorted:
         with cols[col_index % num_columns]:
             k = video_file.split('.')[0]
@@ -378,10 +398,10 @@ def display_videos_and_links(num_columns=4):
                     st.error("Invalid input for seconds per frame!")
         col_index += 1
 
-########################################################################################
-# 7) MERMAID
-########################################################################################
 
+# =====================================================================================
+#  6) MERMAID & PARTIAL SUBGRAPH LOGIC
+# =====================================================================================
 def generate_mermaid_html(mermaid_code: str) -> str:
     """Embed mermaid_code in a minimal HTML snippet, centered."""
     return f"""
@@ -410,82 +430,156 @@ def generate_mermaid_html(mermaid_code: str) -> str:
     </html>
     """
 
+
 def append_model_param(url: str, model_selected: bool) -> str:
-    """If user checks 'model=1', we append &model=1 or ?model=1 if not present."""
+    """If user selects 'model=1', we append &model=1 or ?model=1 if not present."""
     if not model_selected:
         return url
     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}"
 
-########################################################################################
-# 8) NEW MERMAID CODE - NO DOUBLE QUOTES, USE UPPER/LOWER MERGING
-########################################################################################
-
-# The user wants no double quotes, plus a middle word like OpenUser
-# Example usage:
-#   click U /?q=U OpenUser _blank
-#   which might cause syntax issues in older Mermaid, but we'll do it anyway.
 
+# Our default diagram, containing the "click" lines with /?q=...
 DEFAULT_MERMAID = r"""
 flowchart LR
     U((User 😎)) -- "Talk 🗣️" --> LLM[LLM Agent 🤖\nExtract Info]
-    click U "/?q=User%20😎" "Open 'User 😎'" _blank
-    click LLM "/?q=LLM%20Agent%20Extract%20Info" "Open LLM Agent" _blank
+    click U "/?q=User%20😎" "Open 'User 😎'" "_blank"
+    click LLM "/?q=LLM%20Agent%20Extract%20Info" "Open LLM" "_blank"
 
     LLM -- "Query 🔍" --> HS[Hybrid Search 🔎\nVector+NER+Lexical]
-    click HS "/?q=Hybrid%20Search%20Vector+NER+Lexical" "Open Hybrid Search" _blank
+    click HS "/?q=Hybrid%20Search%20Vector+NER+Lexical" "Open HS" "_blank"
 
     HS -- "Reason 🤔" --> RE[Reasoning Engine 🛠️\nNeuralNetwork+Medical]
-    click RE "/?q=Reasoning%20Engine%20NeuralNetwork+Medical" "Open Reasoning" _blank
+    click RE "/?q=Reasoning%20Engine%20NeuralNetwork+Medical" "Open RE" "_blank"
 
     RE -- "Link 📡" --> KG((Knowledge Graph 📚\nOntology+GAR+RAG))
-    click KG "/?q=Knowledge%20Graph%20Ontology+GAR+RAG" "Open Knowledge Graph" _blank
+    click KG "/?q=Knowledge%20Graph%20Ontology+GAR+RAG" "Open KG" "_blank"
 """
 
-########################################################################################
-# 9) MAIN UI
-########################################################################################
 
+# BFS subgraph: we parse lines like A -- "Label" --> B
+def parse_mermaid_edges(mermaid_text: str):
+    """
+    🍿 parse_mermaid_edges:
+      - Find lines like: A -- "Label" --> B
+      - Return adjacency dict: edges[A] = [(label, B), ...]
+    """
+    adjacency = {}
+    # e.g. U((User 😎)) -- "Talk 🗣️" --> LLM[LLM Agent 🤖\nExtract Info]
+    edge_pattern = re.compile(r'(\S+)\s*--\s*"([^"]*)"\s*-->\s*(\S+)')
+    for line in mermaid_text.split('\n'):
+        match = edge_pattern.search(line.strip())
+        if match:
+            nodeA, label, nodeB = match.groups()
+            if nodeA not in adjacency:
+                adjacency[nodeA] = []
+            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
+    """
+    from collections import deque
+    visited = set()
+    queue = deque([(start_node, 0)])
+    edges = []
+
+    while queue:
+        current, lvl = queue.popleft()
+        if current in visited:
+            continue
+        visited.add(current)
+
+        if current in adjacency and lvl < depth:
+            for (label, child) in adjacency[current]:
+                edges.append((current, label, child))
+                queue.append((child, lvl + 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"    %% Subgraph for {start_node}\n"
+    if not sub_edges:
+        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"
+    return sub_mermaid
+
+
+# =====================================================================================
+#  7) MAIN APP
+# =====================================================================================
 def main():
-    st.set_page_config(page_title="Mermaid with No Double Quotes", layout="wide")
+    st.set_page_config(page_title="Mermaid + BFS Subgraph + Full Logic", layout="wide")
 
     # 1) Query param parsing
     query_params = st.query_params
-    query = query_params.get('q', [""])[0].strip()
-    if query:
-        st.write("process_text called with:", PromptPrefix + query)
+    query_list = (query_params.get('q') or query_params.get('query') or [''])
+    q_or_query = query_list[0].strip() if len(query_list) > 0 else ""
+
+    # If 'action' param is present
+    if 'action' in query_params:
+        action_list = query_params['action']
+        if action_list:
+            action = action_list[0]
+            if action == 'show_message':
+                st.success("Showing a message because 'action=show_message' was found in the URL.")
+            elif action == 'clear':
+                clear_query_params()
+
+    # If there's a 'query=' param, display content or image
+    if 'query' in query_params:
+        query_val = query_params['query'][0]
+        display_content_or_image(query_val)
 
     # 2) Let user pick ?model=1
     st.sidebar.write("## Diagram Link Settings")
     model_selected = st.sidebar.checkbox("Append ?model=1 to each link?")
 
-    # 3) We'll do a minimal injection: if line starts with click and has /?q=, we add base & model
+    # 3) We'll parse adjacency from DEFAULT_MERMAID, then do the injection for base URL
+    #    and possible model param. We'll store the final mermaid code in session.
     lines = DEFAULT_MERMAID.strip().split("\n")
     new_lines = []
     for line in lines:
-        # e.g.:  click U /?q=U OpenUser _blank
-        if line.strip().startswith("click ") and "/?q=" in line:
-            parts = line.split()
-            # Example: ["click","U","/?q=U","OpenUser","_blank"]
-            if len(parts) >= 5:
-                node_name = parts[1]   # e.g. U
-                old_url   = parts[2]   # e.g. /?q=U
-                middle    = parts[3]   # e.g. OpenUser
-                target    = parts[4]   # e.g. _blank
-
-                # inject base
+        if "click " in line and '"/?' in line:
+            # Try to parse out the URL via a simpler pattern
+            # e.g. click U "/?q=User%20😎" "Open 'User 😎'" "_blank"
+            # We'll do a quick re.split capturing 4 groups
+            # Example: [prefix, '/?q=User%20😎', "Open 'User 😎'", '_blank', remainder?]
+            pattern = r'(click\s+\S+\s+)"([^"]+)"\s+"([^"]+)"\s+"([^"]+)"'
+            match = re.match(pattern, line.strip())
+            if match:
+                prefix_part = match.group(1)   # e.g. "click U "
+                old_url     = match.group(2)  # e.g. /?q=User%20😎
+                tooltip     = match.group(3)  # e.g. Open 'User 😎'
+                target      = match.group(4)  # e.g. _blank
+
+                # 1) base
                 new_url = inject_base_url(old_url)
-                # append model if chosen
+                # 2) model param
                 new_url = append_model_param(new_url, model_selected)
-                # reassemble line
-                # e.g. "click U <BASEURL> OpenUser _blank"
-                new_line = f"click {node_name} {new_url} {middle} {target}"
+
+                new_line = f'{prefix_part}"{new_url}" "{tooltip}" "{target}"'
                 new_lines.append(new_line)
             else:
                 new_lines.append(line)
@@ -493,25 +587,60 @@ def main():
             new_lines.append(line)
 
     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"
+    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:
+        # We'll do a naive approach: if q_or_query is substring ignoring spaces
+        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)
+
+        chosen_node = None
+        if possible_keys:
+            chosen_node = possible_keys[0]
+        else:
+            st.warning("No adjacency node matched the query param's text. Subgraph is empty.")
+
+        if chosen_node:
+            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:
+        st.subheader("SearchResult Subgraph")
+        components.html(partial_subgraph_html, height=300, scrolling=False)
+
+    # 6) Render the top-centered *full* diagram
+    st.title("Full Mermaid Diagram (with Base URL + BFS partial subgraphs)")
 
-    # 4) Render the top-centered diagram
-    st.title("Mermaid Diagram - No Double Quotes & 'OpenUser'-style Links")
     diagram_html = generate_mermaid_html(final_mermaid)
     components.html(diagram_html, height=400, scrolling=True)
 
-    # 5) Two-column interface: Markdown & (final) Mermaid
+    # 7) Editor columns: Markdown & Mermaid
     left_col, right_col = st.columns(2)
 
     with left_col:
         st.subheader("Markdown Side 📝")
         if "markdown_text" not in st.session_state:
             st.session_state["markdown_text"] = "## Hello!\nYou can type some *Markdown* here.\n"
-
-        markdown_text = st.text_area("Edit Markdown:",
-                                     value=st.session_state["markdown_text"],
-                                     height=300)
+        markdown_text = st.text_area(
+            "Edit Markdown:",
+            value=st.session_state["markdown_text"],
+            height=300
+        )
         st.session_state["markdown_text"] = markdown_text
 
+        # Buttons
         colA, colB = st.columns(2)
         with colA:
             if st.button("🔄 Refresh Markdown"):
@@ -527,14 +656,14 @@ def main():
 
     with right_col:
         st.subheader("Mermaid Side 🧜‍♂️")
-
         if "current_mermaid" not in st.session_state:
             st.session_state["current_mermaid"] = final_mermaid
 
-        mermaid_input = st.text_area("Edit Mermaid Code:",
-                                     value=st.session_state["current_mermaid"],
-                                     height=300)
-
+        mermaid_input = st.text_area(
+            "Edit Mermaid Code:",
+            value=st.session_state["current_mermaid"],
+            height=300
+        )
         colC, colD = st.columns(2)
         with colC:
             if st.button("🎨 Refresh Diagram"):
@@ -550,20 +679,27 @@ def main():
         st.markdown("**Mermaid Source:**")
         st.code(mermaid_input, language="python", line_numbers=True)
 
-    # 6) Media Galleries
+    # 8) Show the galleries
     st.markdown("---")
     st.header("Media Galleries")
-
     num_columns_images = st.slider("Choose Number of Image Columns", 1, 15, 5, key="num_columns_images")
     display_images_and_wikipedia_summaries(num_columns_images)
 
     num_columns_video = st.slider("Choose Number of Video Columns", 1, 15, 5, key="num_columns_video")
     display_videos_and_links(num_columns_video)
 
-    # 7) File Sidebar
+    # 9) Possibly show extended text interface
+    showExtendedTextInterface = False
+    if showExtendedTextInterface:
+        # e.g. display_glossary_grid(roleplaying_glossary)
+        # num_columns_text = st.slider("Choose Number of Text Columns", 1, 15, 4)
+        # display_buttons_with_scores(num_columns_text)
+        pass
+
+    # 10) Render the file sidebar
     FileSidebar()
 
-    # 8) Random Title at bottom
+    # 11) Random title at bottom
     titles = [
         "🧠🎭 Semantic Symphonies & Episodic Encores",
         "🌌🎼 AI Rhythms of Memory Lane",
@@ -576,7 +712,6 @@ def main():
     ]
     st.markdown(f"**{random.choice(titles)}**")
 
-# End of main
 
 if __name__ == "__main__":
     main()