Update app.py

app.py

@@ -15,12 +15,18 @@ from urllib.parse import quote
 import streamlit as st
 import streamlit.components.v1 as components
 
-# (Optional) If you use huggingface_hub:
+# (Optional) huggingface_hub usage
 from huggingface_hub import InferenceClient
 
 
 # ----------------------------
-# Placeholder data structures
+# Configurable BASE_URL
+# ----------------------------
+BASE_URL = "https://huggingface.co/spaces/awacke1/MermaidMarkdownDiagramEditor"
+
+
+# ----------------------------
+# Placeholder data
 # ----------------------------
 PromptPrefix = "AI-Search: "
 PromptPrefix2 = "AI-Refine: "
@@ -42,15 +48,9 @@ transhuman_glossary = {
 }
 
 
-# ------------------------------------------
-# Example stubs for placeholders
-# ------------------------------------------
 def process_text(text):
     st.write(f"process_text called with: {text}")
 
-def process_text2(text_input):
-    return f"[process_text2 placeholder] Received: {text_input}"
-
 def search_arxiv(text):
     st.write(f"search_arxiv called with: {text}")
 
@@ -63,11 +63,7 @@ def process_image(image_file, prompt):
 def process_video(video_file, seconds_per_frame):
     st.write(f"[process_video placeholder] Video: {video_file}, seconds/frame: {seconds_per_frame}")
 
-def search_glossary(content):
-    st.write(f"search_glossary called with: {content}")
-
-
-# If you have HF Inference endpoints, placeholders here
+# Stub if you have an HF endpoint
 API_URL = "https://huggingface-inference-endpoint-placeholder"
 API_KEY = "hf_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
 
@@ -76,14 +72,11 @@ def InferenceLLM(prompt):
     return f"[InferenceLLM placeholder response to prompt: {prompt}]"
 
 
-# --------------------------------------
-# Display Entities & Glossary Functions
-# --------------------------------------
+# ------------------------------------------
+# Example Glossary & File Utility Functions
+# ------------------------------------------
 @st.cache_resource
 def display_glossary_entity(k):
-    """
-    Creates multiple links (emojis) for a single entity.
-    """
     search_urls = {
         "🚀🌌ArXiv": lambda k: f"/?q={quote(k)}",
         "🃏Analyst": lambda k: f"/?q={quote(k)}-{quote(PromptPrefix)}",
@@ -98,38 +91,27 @@ 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):
+    for category, term_list in transhuman_glossary.items():
+        for term in term_list:
+            if query.lower() in term.lower():
+                st.subheader(f"Found in {category}:")
+                st.write(term)
+                return True
+    image_path = f"images/{query}.png"
+    if os.path.exists(image_path):
+        st.image(image_path, caption=f"Image for {query}")
+        return True
+    st.warning("No matching content or image found.")
+    return False
 
-@st.cache_resource
-def display_glossary_grid(roleplaying_glossary):
-    """
-    Displays a glossary in columns with multiple link emojis.
-    """
-    search_urls = {
-        "🚀🌌ArXiv": lambda k: f"/?q={quote(k)}",
-        "🃏Analyst": lambda k: f"/?q={quote(k)}-{quote(PromptPrefix)}",
-        "📚PyCoder": lambda k: f"/?q={quote(k)}-{quote(PromptPrefix2)}",
-        "🔬JSCoder": lambda k: f"/?q={quote(k)}-{quote(PromptPrefix3)}",
-        "📖": lambda k: f"https://en.wikipedia.org/wiki/{quote(k)}",
-        "🔍": lambda k: f"https://www.google.com/search?q={quote(k)}",
-        "🔎": lambda k: f"https://www.bing.com/search?q={quote(k)}",
-        "🎥": lambda k: f"https://www.youtube.com/results?search_query={quote(k)}",
-        "🐦": lambda k: f"https://twitter.com/search?q={quote(k)}",
-    }
-
-    for category, details in roleplaying_glossary.items():
-        st.write(f"### {category}")
-        cols = st.columns(len(details))
-        for idx, (game, terms) in enumerate(details.items()):
-            with cols[idx]:
-                st.markdown(f"#### {game}")
-                for term in terms:
-                    links_md = ' '.join([f"[{emoji}]({url(term)})" for emoji, url in search_urls.items()])
-                    st.markdown(f"**{term}** <small>{links_md}</small>", unsafe_allow_html=True)
+def clear_query_params():
+    st.warning("Define a redirect or use a link without query params if you want to truly clear them.")
 
 
-# --------------------
-# File-Handling Logic
-# --------------------
+# -----------------------
+# File Handling
+# -----------------------
 def load_file(file_path):
     try:
         with open(file_path, "r", encoding='utf-8') as f:
@@ -153,9 +135,6 @@ def get_zip_download_link(zip_file):
     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.
-    """
     try:
         with open(file_path, 'r', encoding='utf-8') as file:
             data = file.read()
@@ -179,43 +158,17 @@ def get_table_download_link(file_path):
 def get_file_size(file_path):
     return os.path.getsize(file_path)
 
-def compare_and_delete_files(files):
-    """
-    Compare file sizes. If duplicates exist, keep only the latest.
-    """
-    if not files:
-        st.warning("No files to compare.")
-        return
-    file_sizes = {}
-    for file in files:
-        size = os.path.getsize(file)
-        file_sizes.setdefault(size, []).append(file)
-    # Remove all but the latest file for each size group
-    for size, paths in file_sizes.items():
-        if len(paths) > 1:
-            latest_file = max(paths, key=os.path.getmtime)
-            for file in paths:
-                if file != latest_file:
-                    os.remove(file)
-                    st.success(f"Deleted {file} as a duplicate.")
-
-
 def FileSidebar():
-    """
-    Renders the file sidebar with all the open/view/run/delete logic.
-    """
     all_files = glob.glob("*.md")
-    # Filter out short-named or undesired files, if needed:
     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)
 
-    # "Delete All" and "Download" buttons
     Files1, Files2 = st.sidebar.columns(2)
     with Files1:
         if st.button("🗑 Delete All"):
             for file in all_files:
                 os.remove(file)
-            st.experimental_rerun()  # or remove if you prefer no rerun
+            st.rerun()
     with Files2:
         if st.button("⬇️ Download"):
             zip_file = create_zip_of_files(all_files)
@@ -253,29 +206,8 @@ def FileSidebar():
         with col5:
             if st.button("🗑", key="delete_"+file):
                 os.remove(file)
-                st.experimental_rerun()  # or remove if no rerun needed
-
-    # Optional: show file sizes
-    file_sizes = [get_file_size(file) for file in all_files]
-    previous_size = None
-    st.sidebar.title("File Operations")
-    for file, size in zip(all_files, file_sizes):
-        duplicate_flag = "🚩" if size == previous_size else ""
-        with st.sidebar.expander(f"File: {file} {duplicate_flag}"):
-            st.text(f"Size: {size} bytes")
-            if st.button("View", key=f"view_{file}"):
-                try:
-                    with open(file, "r", encoding='utf-8') as f:
-                        file_content = f.read()
-                    st.code(file_content, language="markdown")
-                except UnicodeDecodeError:
-                    st.error("Failed to decode file with UTF-8.")
-            if st.button("Delete", key=f"delete3_{file}"):
-                os.remove(file)
-                st.experimental_rerun()
-        previous_size = size
+                st.rerun()
 
-    # If we've loaded content from a file
     if file_contents:
         if next_action == 'open':
             open1, open2 = st.columns([0.8, 0.2])
@@ -302,9 +234,9 @@ def FileSidebar():
                 st.write("Running GPT logic placeholder...")
 
 
-# -------------------------------------------
+# ---------------------------
 # Basic Scoring / Glossaries
-# -------------------------------------------
+# ---------------------------
 score_dir = "scores"
 os.makedirs(score_dir, exist_ok=True)
 
@@ -333,9 +265,6 @@ def load_score(key):
     return 0
 
 def display_buttons_with_scores(num_columns_text):
-    """
-    Show buttons that track a 'score' from your glossary data.
-    """
     game_emojis = {
         "Dungeons and Dragons": "🐉",
         "Call of Cthulhu": "🐙",
@@ -371,13 +300,10 @@ def display_buttons_with_scores(num_columns_text):
                     st.markdown(f"Scored **{category} - {game} - {term}** -> {newscore}")
 
 
-# --------------------------------------
-# Image & Video Grids
-# --------------------------------------
+# -------------------------------
+# Image & Video Display
+# -------------------------------
 def display_images_and_wikipedia_summaries(num_columns=4):
-    """
-    Display .png images in a grid with text input prompts.
-    """
     image_files = [f for f in os.listdir('.') if f.endswith('.png')]
     if not image_files:
         st.write("No PNG images found in the current directory.")
@@ -394,7 +320,6 @@ def display_images_and_wikipedia_summaries(num_columns=4):
                 st.image(image, use_column_width=True)
                 k = image_file.split('.')[0]
                 display_glossary_entity(k)
-                # Provide a text input for user interactions
                 image_text_input = st.text_input(f"Prompt for {image_file}", key=f"image_prompt_{image_file}")
                 if image_text_input:
                     response = process_image(image_file, image_text_input)
@@ -404,9 +329,6 @@ def display_images_and_wikipedia_summaries(num_columns=4):
         col_index += 1
 
 def display_videos_and_links(num_columns=4):
-    """
-    Displays all .mp4/.webm videos in the directory in a grid, with text input prompts.
-    """
     video_files = [f for f in os.listdir('.') if f.endswith(('.mp4', '.webm'))]
     if not video_files:
         st.write("No MP4 or WEBM videos found in the current directory.")
@@ -424,7 +346,6 @@ def display_videos_and_links(num_columns=4):
             video_text_input = st.text_input(f"Video Prompt for {video_file}", key=f"video_prompt_{video_file}")
             if video_text_input:
                 try:
-                    # For demonstration
                     seconds_per_frame = 10
                     process_video(video_file, seconds_per_frame)
                 except ValueError:
@@ -432,47 +353,10 @@ def display_videos_and_links(num_columns=4):
         col_index += 1
 
 
-# --------------------------------------
-# Query Param Helpers (No experimental)
-# --------------------------------------
-def clear_query_params():
-    """
-    In Streamlit, there's no direct method to "clear" query params 
-    without rewriting the URL. One workaround is to do:
-
-    st.experimental_set_query_params()  # with no arguments
-
-    But if you want to avoid *all* experimental calls,
-    you can provide a link or button that leads to a new URL without params.
-    """
-    st.warning("Use a redirect or link that excludes query parameters.")
-
-
-def display_content_or_image(query):
-    """
-    If a query matches transhuman_glossary or a local image, display it.
-    """
-    for category, term_list in transhuman_glossary.items():
-        for term in term_list:
-            if query.lower() in term.lower():
-                st.subheader(f"Found in {category}:")
-                st.write(term)
-                return True
-    image_path = f"images/{query}.png"
-    if os.path.exists(image_path):
-        st.image(image_path, caption=f"Image for {query}")
-        return True
-    st.warning("No matching content or image found.")
-    return False
-
-
-# ------------------------------------
-# MERMAID DIAGRAM with Clickable Nodes
-# ------------------------------------
+# -------------------------------
+# Mermaid Diagram Logic
+# -------------------------------
 def generate_mermaid_html(mermaid_code: str) -> str:
-    """
-    Embeds a mermaid diagram in HTML, centered.
-    """
     return f"""
     <html>
     <head>
@@ -500,14 +384,19 @@ def generate_mermaid_html(mermaid_code: str) -> str:
     """
 
 def append_model_param(url: str, model_selected: bool) -> str:
-    """
-    If 'model=1' is desired, we append it to each URL in the diagram.
-    """
     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 the URL doesn't start with http, we assume it's a relative
+    path like '/?q=...' and prepend the BASE_URL.
+    """
+    if url.startswith("http"):
+        return url
+    return f"{BASE_URL}{url}"
 
 DEFAULT_MERMAID = """
 flowchart LR
@@ -525,31 +414,21 @@ flowchart LR
     click KG "/?q=Knowledge%20Graph%20Ontology+GAR+RAG" _self
 """
 
-
-# ---------------------------
-# Main Streamlit App
-# ---------------------------
 def main():
-    st.set_page_config(page_title="Mermaid + Clickable Links Demo", layout="wide")
+    st.set_page_config(page_title="Mermaid + Clickable Links Demo with Base URL", layout="wide")
 
-    # ---------------------------------------------
-    # Query Parameter Parsing (No experimental usage)
-    # ---------------------------------------------
+    # 1) Query Param Parsing
     try:
         query_params = st.query_params
-
-        # Look for 'q' or 'query'
         query_list = (query_params.get('q') or query_params.get('query') or [''])
-        q_or_query = query_list[0] if len(query_list) > 0 else ''
+        q_or_query = query_list[0] if query_list else ''
         if q_or_query.strip():
             filesearch = PromptPrefix + q_or_query
             st.markdown(filesearch)
             process_text(filesearch)
+    except:
+        pass
 
-    except Exception as e:
-        st.markdown(" ")  # do nothing if there's an error
-
-    # If 'action' in st.query_params
     if 'action' in st.query_params:
         action_list = st.query_params['action']
         if action_list:
@@ -558,51 +437,45 @@ def main():
                 st.success("Showing a message because 'action=show_message' was found in the URL.")
             elif action == 'clear':
                 clear_query_params()
-                # If you wanted a full rerun with no params, you'd do a redirect or
-                # st.experimental_set_query_params() with no arguments (but that's experimental).
 
-    # If 'query' param is present, show content or image
     if 'query' in st.query_params:
-        query_list2 = st.query_params['query']
-        if query_list2 and len(query_list2) > 0:
-            query_val = query_list2[0]
-            display_content_or_image(query_val)
-
-    # ---------------------------------------------
-    # Let user pick if they want to add ?model=1
-    # ---------------------------------------------
+        query_val = st.query_params['query'][0]
+        display_content_or_image(query_val)
+
+    # 2) Model param
     st.sidebar.write("## Diagram Link Settings")
     model_selected = st.sidebar.checkbox("Append ?model=1 to each link?")
 
-    # Rebuild the dynamic Mermaid code
+    # 3) Rebuild the clickable lines in the Mermaid code
     base_diagram = DEFAULT_MERMAID
     lines = base_diagram.strip().split("\n")
     new_lines = []
     for line in lines:
         if "click " in line and '"/?' in line:
-            # e.g. click U "/?q=User" _self
+            # We want to parse the line, extract the URL, inject base, then maybe add &model=1
             parts = re.split(r'click\s+\S+\s+"([^"]+)"\s+("_self")', line)
             if len(parts) == 4:
-                url = parts[1]
-                updated_url = append_model_param(url, model_selected)
-                new_line = f"{parts[0]}\"{updated_url}\" {parts[2]}"
+                old_url = parts[1]  # e.g. '/?q=User%20😎'
+                # 1) Prepend base if needed
+                new_url = inject_base_url(old_url)
+                # 2) Possibly add &model=1
+                new_url = append_model_param(new_url, model_selected)
+
+                # Recombine
+                new_line = f"{parts[0]}\"{new_url}\" {parts[2]}"
                 new_lines.append(new_line)
             else:
                 new_lines.append(line)
         else:
             new_lines.append(line)
+
     mermaid_code = "\n".join(new_lines)
 
-    # ---------------------------------------------
-    #  Render top-centered Mermaid diagram
-    # ---------------------------------------------
-    st.sidebar.markdown("Mermaid Diagram Editor with Clickable Links 🏺")
+    st.title("Mermaid Diagram with Base URL + Model Param")
     diagram_html = generate_mermaid_html(mermaid_code)
     components.html(diagram_html, height=400, scrolling=True)
 
-    # ---------------------------------------------
-    # Two-column layout: Markdown & Mermaid Editors
-    # ---------------------------------------------
+    # 4) Two-column interface: Markdown & Mermaid editors
     left_col, right_col = st.columns(2)
 
     # --- Left: Markdown Editor
@@ -624,7 +497,7 @@ def main():
         with colB:
             if st.button("❌ Clear Markdown"):
                 st.session_state["markdown_text"] = ""
-                st.rerun()  # non-experimental re-run if available in your Streamlit version
+                st.rerun()
 
         st.markdown("---")
         st.markdown("**Preview:**")
@@ -658,36 +531,25 @@ def main():
         st.markdown("**Mermaid Source:**")
         st.code(mermaid_input, language="python", line_numbers=True)
 
-    # ---------------------------------------------
-    # Media Galleries
-    # ---------------------------------------------
+    # 5) Media 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)
 
-    # ---------------------------------------------
-    # Optional Extended UI
-    # ---------------------------------------------
+    # 6) Optional UI
     showExtendedTextInterface = False
     if showExtendedTextInterface:
-        display_glossary_grid(roleplaying_glossary)
-        num_columns_text = st.slider("Choose Number of Text Columns", 1, 15, 4, key="num_columns_text")
-        display_buttons_with_scores(num_columns_text)
-        st.markdown("Extended text interface is on...")
-
-    # ---------------------------------------------
-    # File Sidebar
-    # ---------------------------------------------
+        st.write("Extended text interface is ON.")
+        # e.g. display_glossary_grid, display_buttons_with_scores, etc.
+
+    # 7) File Sidebar
     FileSidebar()
 
-    # ---------------------------------------------
-    # Random Title at the bottom
-    # ---------------------------------------------
+    # 8) Random Title
     titles = [
         "🧠🎭 Semantic Symphonies & Episodic Encores",
         "🌌🎼 AI Rhythms of Memory Lane",
@@ -698,8 +560,7 @@ def main():
         "🏰 Semantic Soul & Episodic Essence",
         "🥁🎻 The Music Of AI's Mind"
     ]
-    selected_title = random.choice(titles)
-    st.markdown(f"**{selected_title}**")
+    st.markdown(f"**{random.choice(titles)}**")
 
 
 if __name__ == "__main__":