Create backup14.app.py

backup14.app.py

@@ -0,0 +1,1674 @@
+# Import libraries and references:
+import anthropic
+import base64
+import glob
+import hashlib
+import json
+import os
+import pandas as pd
+import pytz
+
+
+
+
+
+import random
+import re
+import shutil
+import streamlit as st
+import time
+import traceback
+import uuid
+import zipfile
+from PIL import Image
+from azure.cosmos import CosmosClient, exceptions
+from datetime import datetime
+from git import Repo
+from github import Github
+
+from gradio_client import Client
+from urllib.parse import quote
+
+
+# Add these imports at the top of your file
+from gradio_client import Client, handle_file
+import tempfile
+from PIL import Image
+import io
+import requests
+import numpy as np
+
+
+
+# 🎭 App Configuration - Because every app needs a good costume!
+Site_Name = '🐙GitCosmos🌌 - AI Azure Cosmos DB and Github Agent'
+title = "🐙GitCosmos🌌 - AI Azure Cosmos DB and Github Agent"
+helpURL = 'https://huggingface.co/awacke1'
+bugURL = 'https://huggingface.co/spaces/awacke1/AzureCosmosDBUI/'
+icons = '🐙🌌💫'
+st.set_page_config(
+    page_title=title,
+    page_icon=icons,
+    layout="wide",
+    initial_sidebar_state="auto",
+    menu_items={
+        'Get Help': helpURL,
+        'Report a bug': bugURL,
+        'About': title
+    }
+)
+
+
+# 🌌 Cosmos DB configuration - Where data goes to party!
+ENDPOINT = "https://acae-afd.documents.azure.com:443/"
+DATABASE_NAME = os.environ.get("COSMOS_DATABASE_NAME")
+CONTAINER_NAME = os.environ.get("COSMOS_CONTAINER_NAME")
+Key = os.environ.get("Key")
+
+# 🌐 Your local app URL - Home sweet home
+LOCAL_APP_URL = "https://huggingface.co/spaces/awacke1/AzureCosmosDBUI"
+CosmosDBUrl = 'https://portal.azure.com/#@AaronCWackergmail.onmicrosoft.com/resource/subscriptions/003fba60-5b3f-48f4-ab36-3ed11bc40816/resourceGroups/datasets/providers/Microsoft.DocumentDB/databaseAccounts/acae-afd/dataExplorer'
+
+# 🤖 Anthropic configuration - Teaching machines to be more human (and funnier)
+anthropicclient = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
+
+# 🧠 Initialize session state - Because even apps need a good memory
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+
+
+
+# 🛠️ Helper Functions - The unsung heroes of our code
+
+# 📎 Get a file download link - Making file sharing as easy as stealing candy from a baby
+def get_download_link(file_path):
+    with open(file_path, "rb") as file:
+        contents = file.read()
+        b64 = base64.b64encode(contents).decode()
+        file_name = os.path.basename(file_path)
+        return f'<a href="data:file/txt;base64,{b64}" download="{file_name}">Download {file_name}📂</a>'
+
+# 🎲 Generate a unique ID - Because being unique is important (just ask your mother)
+def generate_unique_id():
+    timestamp = datetime.utcnow().strftime('%Y%m%d%H%M%S%f')
+    unique_uuid = str(uuid.uuid4())
+    returnValue = f"{timestamp}-{unique_uuid}"
+    st.write('New Unique ID:' + returnValue)
+    return 
+
+# 📝 Generate a filename - Naming files like a pro (or a very confused librarian)
+def generate_filename(prompt, file_type):
+    central = pytz.timezone('US/Central')
+    safe_date_time = datetime.now(central).strftime("%m%d_%H%M")
+    safe_prompt = re.sub(r'\W+', '', prompt)[:90]
+    return f"{safe_date_time}{safe_prompt}.{file_type}"
+
+# 💾 Create and save a file - Because data hoarding is a legitimate hobby
+def create_file(filename, prompt, response, should_save=True):
+    if not should_save:
+        return
+    with open(filename, 'w', encoding='utf-8') as file:
+        file.write(prompt + "\n\n" + response)
+
+# 📖 Load file content - Bringing words back from the digital grave
+def load_file(file_name):
+    with open(file_name, "r", encoding='utf-8') as file:
+        content = file.read()
+    return content
+
+# 🔍 Display glossary entity - Making search fun again (as if it ever was)
+def display_glossary_entity(k):
+    search_urls = {
+        "🚀🌌ArXiv": lambda k: f"/?q={quote(k)}",
+        "📖": 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.youtube.com/results?search_query={quote(k)}",
+    }
+    links_md = ' '.join([f"<a href='{url(k)}' target='_blank'>{emoji}</a>" for emoji, url in search_urls.items()])
+    st.markdown(f"{k} {links_md}", unsafe_allow_html=True)
+
+# 🗜️ Create zip of files - Squeezing files together like sardines in a can
+def create_zip_of_files(files):
+    zip_name = "all_files.zip"
+    with zipfile.ZipFile(zip_name, 'w') as zipf:
+        for file in files:
+            zipf.write(file)
+    return zip_name
+
+# 🎬 Get video HTML - Making videos play nice (or at least trying to)
+def get_video_html(video_path, width="100%"):
+    video_url = f"data:video/mp4;base64,{base64.b64encode(open(video_path, 'rb').read()).decode()}"
+    return f'''
+    <video width="{width}" controls autoplay loop>
+        <source src="{video_url}" type="video/mp4">
+        Your browser does not support the video tag.
+    </video>
+    '''
+
+# 🎵 Get audio HTML - Let the music play (and hope it's not Baby Shark)
+def get_audio_html(audio_path, width="100%"):
+    audio_url = f"data:audio/mpeg;base64,{base64.b64encode(open(audio_path, 'rb').read()).decode()}"
+    return f'''
+    <audio controls style="width:{width}">
+        <source src="{audio_url}" type="audio/mpeg">
+        Your browser does not support the audio element.
+    </audio>
+    '''
+
+# 🌌 Cosmos DB functions - Where data goes to live its best life
+
+# 📚 Get databases - Collecting databases like Pokemon cards
+def get_databases(client):
+    return [db['id'] for db in client.list_databases()]
+
+# 📦 Get containers - Finding where all the good stuff is hidden
+def get_containers(database):
+    return [container['id'] for container in database.list_containers()]
+
+# 📄 Get documents - Retrieving the sacred texts (or just some JSON)
+def get_documents(container, limit=None):
+    query = "SELECT * FROM c ORDER BY c._ts DESC"
+    items = list(container.query_items(query=query, enable_cross_partition_query=True, max_item_count=limit))
+    return items
+
+# 📥 Insert record - Adding new data (and crossing fingers it doesn't break anything)
+def insert_record(container, record):
+    try:
+        container.create_item(body=record)
+        return True, "Record inserted successfully! 🎉"
+    except exceptions.CosmosHttpResponseError as e:
+        return False, f"HTTP error occurred: {str(e)} 🚨"
+    except Exception as e:
+        return False, f"An unexpected error occurred: {str(e)} 😱"
+
+# 🔄 Update record - Giving data a makeover
+def update_record(container, updated_record):
+    try:
+        container.upsert_item(body=updated_record)
+        return True, f"Record with id {updated_record['id']} successfully updated. 🛠️"
+    except exceptions.CosmosHttpResponseError as e:
+        return False, f"HTTP error occurred: {str(e)} 🚨"
+    except Exception as e:
+        return False, f"An unexpected error occurred: {traceback.format_exc()} 😱"
+
+# 🗑️ Delete record - Saying goodbye to data (it's not you, it's me)
+def delete_record(container, record):
+    try:
+        container.delete_item(item=record['id'], partition_key=record['id'])
+        return True, f"Record with id {record['id']} successfully deleted. 🗑️"
+    except exceptions.CosmosHttpResponseError as e:
+        return False, f"HTTP error occurred: {str(e)} 🚨"
+    except Exception as e:
+        return False, f"An unexpected error occurred: {traceback.format_exc()} 😱"
+
+        
+# 💾 Save to Cosmos DB - Preserving data for future generations (or just until the next update)
+def save_to_cosmos_db(container, query, response1, response2):
+    try:
+        if container:
+            # Generate a unique ID that includes a timestamp
+            timestamp = datetime.utcnow().strftime('%Y%m%d%H%M%S%f')
+            unique_uuid = str(uuid.uuid4())
+            new_id = f"{timestamp}-{unique_uuid}"
+            
+            # Create new document with proper name field
+            record = {
+                "id": new_id,
+                "name": new_id,  # Set name equal to ID to avoid null name error
+                "query": query,
+                "response1": response1,
+                "response2": response2,
+                "timestamp": datetime.utcnow().isoformat(),
+                "type": "ai_response",  # Add document type for better organization
+                "version": "1.0"
+            }
+            
+            try:
+                # Create the new document
+                container.create_item(body=record)
+                st.success(f"Record saved successfully with ID: {record['id']}")
+                # Refresh the documents display
+                st.session_state.documents = get_documents(container)
+            except exceptions.CosmosHttpResponseError as e:
+                st.error(f"Error saving record to Cosmos DB: {e}")
+        else:
+            st.error("Cosmos DB container is not initialized.")
+    except Exception as e:
+        st.error(f"An unexpected error occurred: {str(e)}")
+
+
+
+
+
+
+
+
+def save_to_cosmos_db_old(container, query, response1, response2):
+
+    try:
+        if container:
+            record = {
+                "id": generate_unique_id(),
+                "query": query,
+                "response1": response1,
+                "response2": response2,
+                "timestamp": datetime.utcnow().isoformat()
+            }
+            try:
+                container.create_item(body=record)
+                st.success(f"Record saved successfully with ID: {record['id']}")
+                # Refresh the documents display
+                st.session_state.documents = get_documents(container)
+            except exceptions.CosmosHttpResponseError as e:
+                st.error(f"Error saving record to Cosmos DB: {e}")
+        else:
+            st.error("Cosmos DB container is not initialized.")
+    except Exception as e:
+        st.error(f"An unexpected error occurred: {str(e)}")
+
+
+
+# 🐙 GitHub functions - Where code goes to socialize
+
+# 📥 Download GitHub repo - Cloning repos like it's going out of style
+def download_github_repo(url, local_path):
+    if os.path.exists(local_path):
+        shutil.rmtree(local_path)
+    Repo.clone_from(url, local_path)
+
+# 🗜️ Create zip file - Squeezing files tighter than your budget
+def create_zip_file(source_dir, output_filename):
+    shutil.make_archive(output_filename, 'zip', source_dir)
+
+# 🏗️ Create repo - Building digital homes for lonely code
+def create_repo(g, repo_name):
+    user = g.get_user()
+    return user.create_repo(repo_name)
+
+# 🚀 Push to GitHub - Sending code to the cloud (hopefully not the rainy kind)
+def push_to_github(local_path, repo, github_token):
+    repo_url = f"https://{github_token}@github.com/{repo.full_name}.git"
+    local_repo = Repo(local_path)
+    if 'origin' in [remote.name for remote in local_repo.remotes]:
+        origin = local_repo.remote('origin')
+        origin.set_url(repo_url)
+    else:
+        origin = local_repo.create_remote('origin', repo_url)
+    if not local_repo.heads:
+        local_repo.git.checkout('-b', 'main')
+        current_branch = 'main'
+    else:
+        current_branch = local_repo.active_branch.name
+    local_repo.git.add(A=True)
+    if local_repo.is_dirty():
+        local_repo.git.commit('-m', 'Initial commit')
+    origin.push(refspec=f'{current_branch}:{current_branch}')
+
+
+def save_or_clone_to_cosmos_db(container, document=None, clone_id=None):
+    def generate_complex_unique_id():
+        timestamp = datetime.utcnow().strftime('%Y%m%d%H%M%S%f')
+        random_component = ''.join(random.choices('abcdefghijklmnopqrstuvwxyz0123456789', k=8))
+        return f"{timestamp}-{random_component}-{str(uuid.uuid4())}"
+    max_retries = 10
+    base_delay = 0.1
+    for attempt in range(max_retries):
+        try:
+            new_id = generate_complex_unique_id()
+            if clone_id:
+                try:
+                    existing_doc = container.read_item(item=clone_id, partition_key=clone_id)
+                    new_doc = {
+                        'id': new_id,
+                        'originalText': existing_doc.get('originalText', ''),
+                        'qtPrompts': existing_doc.get('qtPrompts', []),
+                        'cloned_from': clone_id,
+                        'cloned_at': datetime.utcnow().isoformat()
+                    }
+                except exceptions.CosmosResourceNotFoundError:
+                    return False, f"Document with ID {clone_id} not found for cloning."
+            else:
+                if document is None:
+                    return False, "No document provided for saving"      
+                document['id'] = new_id
+                document['created_at'] = datetime.utcnow().isoformat()
+                new_doc = document
+            response = container.create_item(body=new_doc)
+            return True, f"{'Cloned' if clone_id else 'New'} document saved successfully with ID: {response['id']}"
+        except exceptions.CosmosHttpResponseError as e:
+            if e.status_code == 409:
+                delay = base_delay * (2 ** attempt) + random.uniform(0, 0.1)
+                time.sleep(delay)
+                continue
+            return False, f"Error saving to Cosmos DB: {str(e)}"
+        except Exception as e:
+            return False, f"An unexpected error occurred: {str(e)}"
+    return False, "Failed to save document after maximum retries."
+
+    
+# 📦 Archive current container - Packing up data like you're moving to a new digital house
+def archive_current_container(database_name, container_name, client):
+    try:
+        base_dir = "./cosmos_archive_current_container"
+        if os.path.exists(base_dir):
+            shutil.rmtree(base_dir)
+        os.makedirs(base_dir)
+        db_client = client.get_database_client(database_name)
+        container_client = db_client.get_container_client(container_name)
+        items = list(container_client.read_all_items())
+        container_dir = os.path.join(base_dir, container_name)
+        os.makedirs(container_dir)
+        for item in items:
+            item_id = item.get('id', f"unknown_{datetime.now().strftime('%Y%m%d%H%M%S')}")
+            with open(os.path.join(container_dir, f"{item_id}.json"), 'w') as f:
+                json.dump(item, f, indent=2)
+        archive_name = f"{container_name}_archive_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+        shutil.make_archive(archive_name, 'zip', base_dir)
+        return get_download_link(f"{archive_name}.zip")
+    except Exception as e:
+        return f"An error occurred while archiving data: {str(e)} 😢"
+
+def gen_AI_IO_filename(display_query, output):
+    # Get current time in Central Time Zone with milliseconds
+    now_central = datetime.now(pytz.timezone("America/Chicago"))
+    timestamp = now_central.strftime("%Y-%m-%d-%I-%M-%S-%f-%p")
+    
+    # Limit components to prevent excessive filename length
+    display_query = display_query[:50]  # Truncate display_query to 50 chars
+    output_snippet = re.sub(r'[^A-Za-z0-9]+', '_', output[:100])  # Truncate output_snippet to 100 chars
+
+    filename = f"{timestamp} - {display_query} - {output_snippet}.md"
+    return filename
+        
+# 🔍 Search glossary - Finding needles in digital haystacks
+def search_glossary(query):
+    st.markdown(f"### 🔍 SearchGlossary for: {query}")
+    model_options = ['mistralai/Mixtral-8x7B-Instruct-v0.1', 'mistralai/Mistral-7B-Instruct-v0.2']
+    model_choice = st.selectbox('🧠 Select LLM Model', options=model_options, index=1, key=f"model_choice_{id(query)}")
+    database_options = ['Semantic Search', 'Arxiv Search - Latest - (EXPERIMENTAL)']
+    database_choice = st.selectbox('📚 Select Database', options=database_options, index=0, key=f"database_choice_{id(query)}")
+    
+    # 🕵️‍♂️ Searching the glossary for: query
+    all_results = ""
+    # Limit the query display to 80 characters
+    display_query = query[:80] + "..." if len(query) > 80 else query
+    st.markdown(f"🕵️‍♂️ Running ArXiV AI Analysis with Query: {display_query} - ML model: {model_choice} and Option: {database_options}")
+    
+    # 🔍 ArXiV RAG researcher expert ~-<>-~ Paper Summary & Ask LLM
+    client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
+    # 🔍 ArXiv RAG researcher expert ~-<>-~ Paper Summary & Ask LLM - api_name: /ask_llm
+    result = client.predict(
+        prompt=query,
+        llm_model_picked="mistralai/Mixtral-8x7B-Instruct-v0.1",
+        stream_outputs=True,
+        api_name="/ask_llm"
+    )
+    st.markdown("# Mixtral-8x7B-Instruct-v0.1")
+    st.markdown(result)
+    #st.code(result, language="python", line_numbers=True)
+
+    
+    # 🔍 ArXiv RAG researcher expert ~-<>-~ Paper Summary & Ask LLM - api_name: /ask_llm
+    result2 = client.predict(
+        prompt=query,
+        llm_model_picked="mistralai/Mistral-7B-Instruct-v0.2",
+        stream_outputs=True,
+        api_name="/ask_llm"
+    )
+    st.markdown("# Mistral-7B-Instruct-v0.2")
+    st.markdown(result2)
+    #st.code(result2, language="python", line_numbers=True)
+
+    # 🔍 ArXiv RAG researcher expert ~-<>-~ Paper Summary & Ask LLM - api_name: /update_with_rag_md
+    response2 = client.predict(
+        message=query,	# str  in 'parameter_13' Textbox component
+        llm_results_use=10,
+        database_choice="Semantic Search",
+        llm_model_picked="mistralai/Mistral-7B-Instruct-v0.2",
+        api_name="/update_with_rag_md"
+    )
+    st.markdown("# Mistral-7B-Instruct-v0.2 update_with_rag_md 0")
+    st.markdown(response2[0])
+    #st.code(response2[0], language="python", line_numbers=True, wrap_lines=True) 
+    
+    st.markdown("# Mistral-7B-Instruct-v0.2 update_with_rag_md 1")
+    st.markdown(response2[1])
+    #st.code(response2[1], language="python", line_numbers=True, wrap_lines=True)
+
+
+    # ✅ Persist AI Results to Markdown Files
+    filename = gen_AI_IO_filename(display_query, result)
+    create_file(filename, query, result)
+    st.markdown(f"✅ File saved as: `{filename}`")
+
+    filename = gen_AI_IO_filename(display_query, result2)
+    create_file(filename, query, result2)
+    st.markdown(f"✅ File saved as: `{filename}`")
+
+    filename = gen_AI_IO_filename(display_query, response2[0])
+    create_file(filename, query, response2[0])
+    st.markdown(f"✅ File saved as: `{filename}`")
+
+    filename = gen_AI_IO_filename(display_query, response2[1])
+    create_file(filename, query, response2[1])
+    st.markdown(f"✅ File saved as: `{filename}`")
+
+    return result, result2, response2
+
+
+# 📝 Generate a safe filename from the first few lines of content
+def generate_filename_from_content(content, file_type="md"):
+    # Extract the first few lines or sentences
+    first_sentence = content.split('\n', 1)[0][:90]  # Limit the length to 90 characters
+    # Remove special characters to make it a valid filename
+    safe_name = re.sub(r'[^\w\s-]', '', first_sentence)
+    # Limit length to be compatible with Windows and Linux
+    safe_name = safe_name[:50].strip()  # Adjust length limit
+    return f"{safe_name}.{file_type}"
+
+
+# 💾 Create and save a file
+def create_file_from_content(content, should_save=True):
+    if not should_save:
+        return
+    filename = generate_filename_from_content(content)
+    with open(filename, 'w', encoding='utf-8') as file:
+        file.write(content)
+    return filename
+
+
+# 📂 Display list of saved .md files in the sidebar
+def display_saved_files_in_sidebar():
+    all_files = glob.glob("*.md")
+    all_files.sort(reverse=True)
+    all_files = [file for file in all_files if not file.lower().startswith('readme')]  # Exclude README.md
+    st.sidebar.markdown("## 📁 Saved Markdown Files")
+    for file in all_files:
+        col1, col2, col3 = st.sidebar.columns([6, 2, 1])
+        with col1:
+            st.markdown(f"📄 {file}")
+        with col2:
+            st.sidebar.download_button(
+                label="⬇️ Download",
+                data=open(file, 'rb').read(),
+                file_name=file
+            )
+        with col3:
+            if st.sidebar.button("🗑", key=f"delete_{file}"):
+                os.remove(file)
+                st.rerun()
+
+def clone_record(container, clone_id):
+    try:
+        existing_doc = container.read_item(item=clone_id, partition_key=clone_id)
+        new_doc = existing_doc.copy()
+        new_doc['id'] = generate_unique_id()  # Generate new unique ID with timestamp
+        new_doc['name'] = new_doc['id']  # Generate new unique ID with timestamp
+        new_doc['createdAt'] = datetime.utcnow().isoformat()  # Update the creation time
+        new_doc['_rid'] = None  # Reset _rid or any system-managed fields
+        new_doc['_self'] = None
+        new_doc['_etag'] = None
+        new_doc['_attachments'] = None
+        new_doc['_ts'] = None  # Reset timestamp to be updated by Cosmos DB automatically
+        # Insert the cloned document
+        response = container.create_item(body=new_doc)
+        st.success(f"Cloned document saved successfully with ID: {new_doc['id']} 🎉")
+        # Refresh the documents in session state
+        st.session_state.documents = list(container.query_items(
+            query="SELECT * FROM c ORDER BY c._ts DESC",
+            enable_cross_partition_query=True
+        ))
+    except exceptions.CosmosResourceNotFoundError:
+        st.error(f"Document with ID {clone_id} not found for cloning.")
+    except exceptions.CosmosHttpResponseError as e:
+        st.error(f"HTTP error occurred: {str(e)} 🚨")
+    except Exception as e:
+        st.error(f"An unexpected error occurred: {str(e)} 😱")
+
+
+def create_new_blank_record(container):
+    try:
+        # Get the structure of the latest document (to preserve schema)
+        latest_doc = container.query_items(query="SELECT * FROM c ORDER BY c._ts DESC", enable_cross_partition_query=True, max_item_count=1)
+        if latest_doc:
+            new_doc_structure = latest_doc[0].copy()
+        else:
+            new_doc_structure = {}
+        new_doc = {key: "" for key in new_doc_structure.keys()}  # Set all fields to blank
+        new_doc['id'] = generate_unique_id()  # Generate new unique ID
+        new_doc['createdAt'] = datetime.utcnow().isoformat()  # Set creation time
+        # Insert the new blank document
+        response = container.create_item(body=new_doc)
+        st.success(f"New blank document saved successfully with ID: {new_doc['id']} 🎉")
+        # Refresh the documents in session state
+        st.session_state.documents = list(container.query_items(
+            query="SELECT * FROM c ORDER BY c._ts DESC",
+            enable_cross_partition_query=True
+        ))
+    except exceptions.CosmosHttpResponseError as e:
+        st.error(f"HTTP error occurred: {str(e)} 🚨")
+    except Exception as e:
+        st.error(f"An unexpected error occurred: {str(e)} 😱")
+
+
+# Function to preprocess the pasted content
+def preprocess_text(text):
+    # Replace CRLF and other newline variations with the JSON newline escape sequence
+    text = text.replace('\r\n', '\\n')
+    text = text.replace('\r', '\\n')
+    text = text.replace('\n', '\\n')
+    # Escape double quotes inside the text
+    text = text.replace('"', '\\"')
+    # Optionally remove or handle other special characters that might not be JSON-safe
+    # Here, we remove characters like tabs or non-ASCII characters (as an example)
+    text = re.sub(r'[\t]', ' ', text)  # Replace tabs with spaces
+    text = re.sub(r'[^\x00-\x7F]+', '', text)  # Remove non-ASCII characters
+    # Normalize spaces (strip leading/trailing whitespace)
+    text = text.strip()
+    return text
+
+
+
+def load_file_content(file_path):
+    """Load and return file content with error handling"""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as file:
+            return file.read()
+
+
+
+    except Exception as e:
+        st.error(f"Error loading file: {str(e)}")
+        return None
+
+def save_file_content(file_path, content):
+    """Save file content with error handling"""
+    try:
+        with open(file_path, 'w', encoding='utf-8') as file:
+            file.write(content)
+        return True
+    except Exception as e:
+        st.error(f"Error saving file: {str(e)}")
+        return False
+
+def display_file_viewer(file_path):
+    """Display file content in markdown viewer"""
+    content = load_file_content(file_path)
+    if content:
+        st.markdown("### 📄 File Viewer")
+        st.markdown(f"**Viewing:** {file_path}")
+        
+        # Add file metadata
+        file_stats = os.stat(file_path)
+        st.markdown(f"**Last modified:** {datetime.fromtimestamp(file_stats.st_mtime).strftime('%Y-%m-%d %H:%M:%S')}")
+        st.markdown(f"**Size:** {file_stats.st_size} bytes")
+        
+        # Display content in markdown
+        st.markdown("---")
+        st.markdown(content)
+        
+        # Add download button
+        st.download_button(
+            label="⬇️ Download File",
+            data=content,
+            file_name=os.path.basename(file_path),
+            mime="text/markdown"
+        )
+
+
+
+def display_file_editor(file_path):
+    """Display file content in both Markdown and Code Editor views"""
+    # Initialize file content in session state if not already present
+    if 'file_content' not in st.session_state:
+        st.session_state.file_content = {}
+    
+    # Load content if not in session state or if it's a different file
+    if file_path not in st.session_state.file_content:
+        content = load_file_content(file_path)
+        if content is not None:
+            st.session_state.file_content[file_path] = content
+        else:
+            return
+    
+    st.markdown("### ✏️ File Editor")
+    st.markdown(f"**Editing:** {file_path}")
+    
+    # Create tabs for different views
+    markdown_tab, code_tab = st.tabs(["Markdown View", "Code Editor"])
+    
+    with markdown_tab:
+        st.markdown("### 📄 Markdown Preview")
+        st.markdown(st.session_state.file_content[file_path])
+    
+    with code_tab:
+        st.markdown("### 💻 Code Editor")
+        # Create a unique key for the text area
+        editor_key = f"editor_{hash(file_path)}"
+        
+        # Editor with syntax highlighting for markdown
+        new_content = st.text_area(
+            "Edit content below:",
+            value=st.session_state.file_content[file_path],
+            height=400,
+            key=editor_key
+        )
+    
+    # Add save and download buttons below both views
+    col1, col2 = st.columns([1, 5])
+    with col1:
+        if st.button("💾 Save Changes"):
+            if save_file_content(file_path, new_content):
+                st.session_state.file_content[file_path] = new_content
+                st.success("File saved successfully! 🎉")
+                time.sleep(1)
+                st.rerun()
+    
+    with col2:
+        st.download_button(
+            label="⬇️ Download File",
+            data=new_content,
+            file_name=os.path.basename(file_path),
+            mime="text/markdown"
+        )
+
+
+
+
+def display_file_editor_old(file_path):
+    """Display file content in editor with save functionality"""
+    # Initialize file content in session state if not already present
+    if 'file_content' not in st.session_state:
+        st.session_state.file_content = {}
+    
+    # Load content if not in session state or if it's a different file
+    if file_path not in st.session_state.file_content:
+        content = load_file_content(file_path)
+        if content is not None:
+            st.session_state.file_content[file_path] = content
+        else:
+            return
+    
+    st.markdown("### ✏️ File Editor")
+    st.markdown(f"**Editing:** {file_path}")
+    
+    # Create a unique key for the text area
+    editor_key = f"editor_{hash(file_path)}"
+    
+    # Editor with syntax highlighting for markdown
+    new_content = st.text_area(
+        "Edit content below:",
+        value=st.session_state.file_content[file_path],
+        height=400,
+        key=editor_key
+    )
+    
+    col1, col2 = st.columns([1, 5])
+    with col1:
+        if st.button("💾 Save Changes"):
+            if save_file_content(file_path, new_content):
+                st.session_state.file_content[file_path] = new_content
+                st.success("File saved successfully! 🎉")
+                time.sleep(1)
+                st.rerun()
+    
+    with col2:
+        st.download_button(
+            label="⬇️ Download File",
+            data=new_content,
+            file_name=os.path.basename(file_path),
+            mime="text/markdown"
+        )
+
+def update_file_management_section():
+    # Initialize session state variables
+    if 'file_view_mode' not in st.session_state:
+        st.session_state.file_view_mode = None
+    if 'current_file' not in st.session_state:
+        st.session_state.current_file = None
+    if 'file_content' not in st.session_state:
+        st.session_state.file_content = {}
+
+    all_files = glob.glob("*.md")
+    all_files.sort(reverse=True)
+
+    # File management buttons in sidebar
+    st.sidebar.title("📁 File Management")
+    
+    if st.sidebar.button("🗑 Delete All Files"):
+        for file in all_files:
+            os.remove(file)
+        st.session_state.file_content = {}  # Clear the file content cache
+        st.session_state.current_file = None
+        st.session_state.file_view_mode = None
+        st.rerun()
+
+    if st.sidebar.button("⬇️ Download All Files"):
+        zip_file = create_zip_of_files(all_files)
+        st.sidebar.markdown(get_download_link(zip_file), unsafe_allow_html=True)
+
+    # Display files in sidebar with action buttons
+    for file in all_files:
+        col1, col2, col3, col4 = st.sidebar.columns([1,3,1,1])
+        
+        with col1:
+            if st.button("🌐", key=f"view_{file}"):
+                st.session_state.current_file = file
+                st.session_state.file_view_mode = 'view'
+                if file not in st.session_state.file_content:
+                    content = load_file_content(file)
+                    if content is not None:
+                        st.session_state.file_content[file] = content
+                st.rerun()
+                
+        with col2:
+            st.markdown(get_download_link(file), unsafe_allow_html=True)
+
+
+
+
+
+            
+        with col3:
+            if st.button("📂", key=f"edit_{file}"):
+                st.session_state.current_file = file
+                st.session_state.file_view_mode = 'edit'
+                if file not in st.session_state.file_content:
+                    content = load_file_content(file)
+                    if content is not None:
+                        st.session_state.file_content[file] = content
+                st.rerun()
+                
+        with col4:
+            if st.button("🗑", key=f"delete_{file}"):
+                os.remove(file)
+                if file in st.session_state.file_content:
+                    del st.session_state.file_content[file]
+                if st.session_state.current_file == file:
+                    st.session_state.current_file = None
+                    st.session_state.file_view_mode = None
+                st.rerun()
+
+    # Display viewer or editor in main area based on mode
+    if st.session_state.current_file:
+        if st.session_state.file_view_mode == 'view':
+            display_file_viewer(st.session_state.current_file)
+        elif st.session_state.file_view_mode == 'edit':
+            display_file_editor(st.session_state.current_file)
+
+
+# Function to create HTML for autoplaying and looping video (for the full cinematic effect 🎥)
+def get_video_html(video_path, width="100%"):
+    video_url = f"data:video/mp4;base64,{base64.b64encode(open(video_path, 'rb').read()).decode()}"
+    return f'''
+    <video width="{width}" controls autoplay muted loop>
+        <source src="{video_url}" type="video/mp4">
+        Your browser does not support the video tag.
+    </video>
+    '''
+
+
+
+
+# *********
+def validate_and_preprocess_image(file_data, target_size=(576, 1024)):
+    """Validate and preprocess image for video generation with improved BytesIO handling"""
+    try:
+        st.write("Starting image preprocessing...")
+        
+        # Handle different input types
+        if isinstance(file_data, bytes):
+            st.write("Processing bytes input")
+            img = Image.open(io.BytesIO(file_data))
+        elif hasattr(file_data, 'read'):
+            st.write("Processing file-like object")
+            # Reset file pointer if possible
+            if hasattr(file_data, 'seek'):
+                file_data.seek(0)
+            img = Image.open(file_data)
+        elif isinstance(file_data, Image.Image):
+            st.write("Processing PIL Image input")
+            img = file_data
+        else:
+            raise ValueError(f"Unsupported input type: {type(file_data)}")
+        
+        st.write(f"Successfully loaded image: {img.format}, size={img.size}, mode={img.mode}")
+        
+        # Convert to RGB if necessary
+        if img.mode != 'RGB':
+            st.write(f"Converting image from {img.mode} to RGB")
+            img = img.convert('RGB')
+        
+        # Calculate aspect ratio
+        aspect_ratio = img.size[0] / img.size[1]
+        st.write(f"Original aspect ratio: {aspect_ratio:.2f}")
+        
+        # Determine target dimensions maintaining aspect ratio
+        if aspect_ratio > target_size[0]/target_size[1]:  # Wider than target
+            new_width = target_size[0]
+            new_height = int(new_width / aspect_ratio)
+        else:  # Taller than target
+            new_height = target_size[1]
+            new_width = int(new_height * aspect_ratio)
+            
+        # Ensure dimensions are even numbers
+        new_width = (new_width // 2) * 2
+        new_height = (new_height // 2) * 2
+        
+        st.write(f"Resizing to: {new_width}x{new_height}")
+        
+        # Resize image using high-quality downsampling
+        resized_img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        
+        # Create white background image of target size
+        final_img = Image.new('RGB', target_size, (255, 255, 255))
+        
+        # Calculate position to paste resized image (center)
+        paste_x = (target_size[0] - new_width) // 2
+        paste_y = (target_size[1] - new_height) // 2
+        
+        # Paste resized image onto white background
+        final_img.paste(resized_img, (paste_x, paste_y))
+        
+        st.write(f"Final image size: {final_img.size}")
+        return final_img
+        
+    except Exception as e:
+        st.error(f"Error in image preprocessing: {str(e)}\nType of input: {type(file_data)}")
+        return None
+
+def add_video_generation_ui(container):
+    """Enhanced video generation UI with improved file handling"""
+    st.markdown("### 🎥 Video Generation")
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        uploaded_file = st.file_uploader(
+            "Upload Image for Video Generation 🖼️",
+            type=['png', 'jpg', 'jpeg'],
+            help="Upload a clear, well-lit image. Recommended size: 576x1024 pixels."
+        )
+    
+    with col2:
+        st.markdown("#### Generation Parameters")
+        motion_bucket_id = st.slider(
+            "Motion Intensity 🌊",
+            min_value=1,
+            max_value=255,
+            value=127,
+            help="Lower values create subtle movement, higher values create more dramatic motion"
+        )
+        fps_id = st.slider(
+            "Frames per Second 🎬",
+            min_value=1,
+            max_value=30,
+            value=6,
+            help="Higher values create smoother but potentially less stable videos"
+        )
+        
+        with st.expander("Advanced Options"):
+            use_custom_seed = st.checkbox("Use Custom Seed")
+            if use_custom_seed:
+                seed = st.number_input("Seed Value", value=int(time.time() * 1000))
+            else:
+                seed = None
+
+    if uploaded_file is not None:
+        try:
+            # Read file data
+            file_data = uploaded_file.read()
+            
+            # Preview original image
+            preview_col1, preview_col2 = st.columns(2)
+            with preview_col1:
+                st.write("Original Image:")
+                original_img = Image.open(io.BytesIO(file_data))
+                st.image(original_img, caption="Original", use_column_width=True)
+            
+            # Preview preprocessed image
+            with preview_col2:
+                # Create a new BytesIO object with the file data
+                preprocessed = validate_and_preprocess_image(io.BytesIO(file_data))
+                if preprocessed:
+                    st.write("Preprocessed Image:")
+                    st.image(preprocessed, caption="Preprocessed", use_column_width=True)
+                else:
+                    st.error("Failed to preprocess image")
+                    return
+            
+            if st.button("🎥 Generate Video", help="Start video generation process"):
+                with st.spinner("Processing your video... This may take a few minutes 🎬"):
+                    # Save preprocessed image to temporary file
+                    with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as temp_file:
+                        preprocessed.save(temp_file.name, format='PNG')
+                        st.write(f"Saved preprocessed image to temporary file: {temp_file.name}")
+                        
+                        try:
+                            # Initialize the Gradio client
+                            client = Client(
+                                "awacke1/stable-video-diffusion",
+                                hf_token=os.environ.get("HUGGINGFACE_TOKEN")
+                            )
+                            
+                            # Generate video
+                            result = client.predict(
+                                image=temp_file.name,
+                                seed=seed if seed is not None else int(time.time() * 1000),
+                                randomize_seed=seed is None,
+                                motion_bucket_id=motion_bucket_id,
+                                fps_id=fps_id,
+                                api_name="/video"
+                            )
+                            
+                            if result and isinstance(result, tuple) and len(result) >= 1:
+                                video_path = result[0].get('video') if isinstance(result[0], dict) else None
+                                if video_path and os.path.exists(video_path):
+                                    # Save video locally
+                                    video_filename = f"generated_video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+                                    shutil.copy(video_path, video_filename)
+                                    
+                                    st.success(f"""
+                                    Video generated successfully! 🎉
+                                    - Seed: {seed if seed is not None else 'Random'}
+                                    - Motion Intensity: {motion_bucket_id}
+                                    - FPS: {fps_id}
+                                    """)
+                                    
+                                    st.video(video_filename)
+                                    
+                                    # Save to Cosmos DB
+                                    if container:
+                                        video_record = {
+                                            "id": generate_unique_id(),
+                                            "type": "generated_video",
+                                            "filename": video_filename,
+                                            "seed": seed if seed is not None else "random",
+                                            "motion_bucket_id": motion_bucket_id,
+                                            "fps_id": fps_id,
+                                            "timestamp": datetime.now().isoformat()
+                                        }
+                                        success, message = insert_record(container, video_record)
+                                        if success:
+                                            st.success("Video record saved to database!")
+                                        else:
+                                            st.error(f"Error saving video record: {message}")
+                                else:
+                                    st.error("Failed to generate video: Invalid result format")
+                            else:
+                                st.error("Failed to generate video: No result returned")
+                            
+                        except Exception as e:
+                            st.error(f"Error generating video: {str(e)}")
+                        finally:
+                            # Cleanup temporary file
+                            try:
+                                os.unlink(temp_file.name)
+                                st.write("Cleaned up temporary file")
+                            except Exception as e:
+                                st.warning(f"Error cleaning up temporary file: {str(e)}")
+                
+        except Exception as e:
+            st.error(f"Error processing uploaded file: {str(e)}")
+
+
+# ******************************************
+
+# Function to create HTML for audio player (when life needs a soundtrack 🎶)
+def get_audio_html(audio_path, width="100%"):
+    audio_url = f"data:audio/mpeg;base64,{base64.b64encode(open(audio_path, 'rb').read()).decode()}"
+    return f'''
+    <audio controls style="width: {width};">
+        <source src="{audio_url}" type="audio/mpeg">
+        Your browser does not support the audio element.
+    </audio>
+    '''
+        
+# 🎭 Main function - "All the world's a stage, and all the code merely players" -Shakespeare, probably
+def main():
+    st.markdown("### 🐙Git🌌Cosmos💫 - Azure Cosmos DB and Github Agent")
+
+    # 🎲 Session state vars - "Life is like a session state, you never know what you're gonna get"
+    if 'logged_in' not in st.session_state:
+        st.session_state.logged_in = False
+    if 'selected_records' not in st.session_state:
+        st.session_state.selected_records = []
+    if 'client' not in st.session_state:
+        st.session_state.client = None
+    if 'selected_database' not in st.session_state:
+        st.session_state.selected_database = None
+    if 'selected_container' not in st.session_state:
+        st.session_state.selected_container = None
+    if 'selected_document_id' not in st.session_state:
+        st.session_state.selected_document_id = None
+    if 'current_index' not in st.session_state:
+        st.session_state.current_index = 0
+    if 'cloned_doc' not in st.session_state:
+        st.session_state.cloned_doc = None
+
+    # 🔍 Query processing - "To search or not to search, that is the query" 
+    try:
+        query_params = st.query_params
+        query = query_params.get('q') or query_params.get('query') or ''
+        if query:
+            result, result2, result3, response2 = search_glossary(query)
+            
+            # 💾 Save results - "Every file you save is a future you pave"
+            try:
+                if st.button("Save AI Output"):
+                    filename = create_file_from_content(result)
+                    st.success(f"File saved: {filename}")                    
+                    filename = create_file_from_content(result2)
+                    st.success(f"File saved: {filename}")
+                    filename = create_file_from_content(result3)
+                    st.success(f"File saved: {filename}")
+                    filename = create_file_from_content(response2)
+                    st.success(f"File saved: {filename}")
+                    
+                display_saved_files_in_sidebar()
+            except Exception as e:
+                st.error(f"An unexpected error occurred: {str(e)} 😱")
+
+            # 🌟 Cosmos DB operations - "In Cosmos DB we trust, but we still handle errors we must"
+            try:
+                save_to_cosmos_db(st.session_state.cosmos_container, query, result, result)
+                save_to_cosmos_db(st.session_state.cosmos_container, query, result2, result2)
+                save_to_cosmos_db(st.session_state.cosmos_container, query, result3, result3)
+                save_to_cosmos_db(st.session_state.cosmos_container, query, response2[0], response2[0])
+                save_to_cosmos_db(st.session_state.cosmos_container, query, response2[1], response2[1])
+            except exceptions.CosmosHttpResponseError as e:
+                st.error(f"HTTP error occurred: {str(e)} 🚨")
+            except Exception as e:
+                st.error(f"An unexpected error occurred: {str(e)} 😱")
+            st.stop()
+    except Exception as e:
+        st.markdown(' ')
+
+    # 🔐 Auth check - "With great keys come great connectivity"
+    if Key:
+        st.session_state.primary_key = Key
+        st.session_state.logged_in = True
+    else:
+        st.error("Cosmos DB Key is not set in environment variables. 🔑❌")
+        return
+
+    if st.session_state.logged_in:
+        # 🌌 DB initialization - "In the beginning, there was connection string..."
+        try:
+            if st.session_state.client is None:
+                st.session_state.client = CosmosClient(ENDPOINT, credential=st.session_state.primary_key)
+            # 📚 Navigation setup - "Navigation is not about where you are, but where you're going"
+            st.sidebar.title("🐙Git🌌Cosmos💫🗄️Navigator")
+            databases = get_databases(st.session_state.client)
+            selected_db = st.sidebar.selectbox("🗃️ Select Database", databases)
+            st.markdown(CosmosDBUrl)
+
+            # 🔄 State management - "Change is the only constant in state management"
+            if selected_db != st.session_state.selected_database:
+                st.session_state.selected_database = selected_db
+                st.session_state.selected_container = None
+                st.session_state.selected_document_id = None
+                st.session_state.current_index = 0
+                st.rerun()
+                
+            if st.session_state.selected_database:
+                database = st.session_state.client.get_database_client(st.session_state.selected_database)
+                containers = get_containers(database)
+                selected_container = st.sidebar.selectbox("📁 Select Container", containers)
+                
+                # 🔄 Container state handling - "Container changes, state arranges"
+                if selected_container != st.session_state.selected_container:
+                    st.session_state.selected_container = selected_container
+                    st.session_state.selected_document_id = None
+                    st.session_state.current_index = 0
+                    st.rerun()
+                
+                if st.session_state.selected_container:
+                    container = database.get_container_client(st.session_state.selected_container)
+                    # 📦 Export functionality - "Pack it, zip it, ship it"
+                    if st.sidebar.button("📦 Export Container Data"):
+                        download_link = archive_current_container(st.session_state.selected_database, 
+                                                               st.session_state.selected_container, 
+                                                               st.session_state.client)
+                        if download_link.startswith('<a'):
+                            st.markdown(download_link, unsafe_allow_html=True)
+                        else:
+                            st.error(download_link)
+
+                    # 📝 Document handling - "Document, document, on the wall, who's the most recent of them all?"
+                    documents = get_documents(container)
+                    total_docs = len(documents)
+                    # Add a slider to let the user choose how many documents to display
+                    num_docs_to_display = st.slider(
+                        "Select number of documents to display", 1, 20, 1
+                    )
+                    # Adjust the document display logic based on the slider value
+                    if total_docs > num_docs_to_display:
+                        documents_to_display = documents[:num_docs_to_display]
+                        st.sidebar.info(f"Showing top {num_docs_to_display} most recent documents.")
+                    else:
+                        documents_to_display = documents
+                        st.sidebar.info(f"Showing all {len(documents_to_display)} documents.")
+
+                    if documents_to_display:
+                        # 🎨 View options - "Different strokes for different folks"
+                        view_options = ['Show as Markdown', 'Show as Code Editor', 'Show as Run AI', 'Clone Document', 'New Record']
+                        selected_view = st.sidebar.selectbox("Select Viewer/Editor", view_options, index=2)
+
+                        
+                        if selected_view == 'Show as Markdown':
+                            Label = '#### 📄 Markdown view - Mark it down, mark it up'
+                            st.markdown(Label)
+                            total_docs = len(documents)
+                            doc = documents[st.session_state.current_index]
+                            # st.markdown(f"#### Document ID: {doc.get('id', '')}")
+
+                            # 🕵️ Value extraction - "Finding spaces in all the right places"
+                            values_with_space = []
+                            def extract_values(obj):
+                                if isinstance(obj, dict):
+                                    for k, v in obj.items():
+                                        extract_values(v)
+                                elif isinstance(obj, list):
+                                    for item in obj:
+                                        extract_values(item)
+                                elif isinstance(obj, str):
+                                    if ' ' in obj:
+                                        values_with_space.append(obj)
+
+                            extract_values(doc)
+                            st.markdown("#### 🔗 Links for Extracted Texts")
+                            for term in values_with_space:
+                                display_glossary_entity(term)
+
+                            content = json.dumps(doc, indent=2)
+                            st.markdown(f"```json\n{content}\n```")
+
+                            # ⬅️➡️ Navigation - "Left and right, day and night"
+                            col_prev, col_next = st.columns([1, 1])
+                            with col_prev:
+                                if st.button("⬅️ Previous", key='prev_markdown'):
+                                    if st.session_state.current_index > 0:
+                                        st.session_state.current_index -= 1
+                                        st.rerun()
+                            with col_next:
+                                if st.button("➡️ Next", key='next_markdown'):
+                                    if st.session_state.current_index < total_docs - 1:
+                                        st.session_state.current_index += 1
+                                        st.rerun()
+                        
+                        elif selected_view == 'Show as Code Editor':
+                            Label = '#### 💻 Code editor view'
+                            st.markdown(Label)
+                            total_docs = len(documents)
+                            
+                            if total_docs == 0:
+                                st.warning("No documents available.")
+                                return
+                                
+                            doc = documents[st.session_state.current_index]
+                            doc_str = st.text_area("Edit Document", 
+                                                  value=json.dumps(doc, indent=2), 
+                                                  height=300, 
+                                                  key=f'code_editor_{st.session_state.current_index}')
+                            
+                            col_prev, col_next = st.columns([1, 1])
+                            with col_prev:
+                                if st.button("⬅️ Previous", key='prev_code'):
+                                    if st.session_state.current_index > 0:
+                                        st.session_state.current_index -= 1
+                                        st.rerun()
+                            with col_next:
+                                if st.button("➡️ Next", key='next_code'):
+                                    if st.session_state.current_index < total_docs - 1:
+                                        st.session_state.current_index += 1
+                                        st.rerun()
+                            
+                            col_save, col_delete = st.columns([1, 1])
+                            with col_save:
+                                if st.button("💾 Save Changes", key=f'save_button_{st.session_state.current_index}'):
+                                    try:
+                                        updated_doc = json.loads(doc_str)
+                                        response = container.upsert_item(body=updated_doc)
+                                        if response:
+                                            st.success(f"Document {updated_doc['id']} saved successfully.")
+                                            st.session_state.selected_document_id = updated_doc['id']
+                                            st.rerun()
+                                    except json.JSONDecodeError:
+                                        st.error("Invalid JSON format. Please check your edits.")
+                                    except Exception as e:
+                                        st.error(f"Error saving document: {str(e)}")
+                            
+                            with col_delete:
+                                if st.button("🗑️ Delete", key=f'delete_button_{st.session_state.current_index}'):
+                                    try:
+                                        current_doc = json.loads(doc_str)
+                                        doc_id = current_doc.get("id")
+                                        
+                                        if not doc_id:
+                                            st.error("Document ID not found.")
+                                            return
+                                        
+                                        # Confirm deletion
+                                        if 'confirm_delete' not in st.session_state:
+                                            st.session_state.confirm_delete = False
+                                        
+                                        if not st.session_state.confirm_delete:
+                                            if st.button("⚠️ Click to confirm deletion", key=f'confirm_delete_{st.session_state.current_index}'):
+                                                st.session_state.confirm_delete = True
+                                                st.rerun()
+                                        else:
+                                            try:
+                                                # Delete the document
+                                                container.delete_item(item=doc_id, partition_key=doc_id)
+                                                
+                                                # Update the session state
+                                                st.session_state.confirm_delete = False
+                                                
+                                                # Update the current index if necessary
+                                                if total_docs > 1:
+                                                    if st.session_state.current_index == total_docs - 1:
+                                                        st.session_state.current_index = max(0, total_docs - 2)
+                                                    documents.pop(st.session_state.current_index)
+                                                else:
+                                                    st.session_state.current_index = 0
+                                                    documents.clear()
+                                                
+                                                st.success(f"Document {doc_id} deleted successfully.")
+                                                st.rerun()
+                                                
+                                            except Exception as e:
+                                                st.error(f"Error deleting document: {str(e)}")
+                                                st.session_state.confirm_delete = False
+                                        
+                                    except json.JSONDecodeError:
+                                        st.error("Invalid JSON format. Please check the document.")
+                                    except Exception as e:
+                                        st.error(f"Error processing deletion: {str(e)}")
+                        
+                        
+                        
+                        
+                        elif selected_view == 'Show as Run AI':
+                            Label = '#### ✏️ Run AI with wisdom, save with precision'
+                            st.markdown(Label)                            
+                            num_cols = len(documents_to_display)
+                            cols = st.columns(num_cols)
+                        
+                            for idx, (col, doc) in enumerate(zip(cols, documents_to_display)):
+                                with col:
+                                    # ID and Name fields
+                                    editable_id = st.text_input("ID", value=doc.get('id', ''), key=f'edit_id_{idx}')
+                                    editable_name = st.text_input("Name", value=doc.get('name', ''), key=f'edit_name_{idx}')
+                                    
+                                    # Create editable document copy without id and name
+                                    editable_doc = doc.copy()
+                                    editable_doc.pop('id', None)
+                                    editable_doc.pop('name', None)
+                        
+                                    doc_str = st.text_area("Document Content (in JSON format)", 
+                                                         value=json.dumps(editable_doc, indent=2), 
+                                                         height=300, 
+                                                         key=f'doc_str_{idx}')
+                        
+                                    # Save and AI operations columns
+
+                                    
+                                    # Video Generator call  -  the video generation UI for container:
+                                    add_video_generation_ui(container)
+
+
+
+                                    if st.button("🤖 Run AI", key=f'run_with_ai_button_{idx}'):
+                                        # Your existing AI processing code here
+                                        values_with_space = []
+                                        def extract_values2(obj):
+                                            if isinstance(obj, dict):
+                                                for k, v in obj.items():
+                                                    extract_values2(v)
+                                            elif isinstance(obj, list):
+                                                for item in obj:
+                                                    extract_values2(item)
+                                            elif isinstance(obj, str):
+                                                if ' ' in obj:
+                                                    values_with_space.append(obj)
+                                        
+                                        extract_values2(doc)
+                                        for term in values_with_space:
+                                            display_glossary_entity(term)
+                                            search_glossary(term)
+
+                                    if st.button("💾 Save Changes", key=f'save_runai_{idx}'):
+                                        try:
+                                            updated_doc = json.loads(doc_str)
+                                            # Reinsert ID and name from editable fields
+                                            updated_doc['id'] = editable_id
+                                            updated_doc['name'] = editable_name
+                                            response = container.upsert_item(body=updated_doc)
+                                            if response:
+                                                st.success(f"Document {updated_doc['id']} saved successfully.")
+                                                st.session_state.selected_document_id = updated_doc['id']
+                                                st.rerun()
+                                        except Exception as e:
+                                            st.error(f"Error saving document: {str(e)}")
+
+                        
+                            # File Editor (When you need to tweak things ✏️)
+                            if hasattr(st.session_state, 'current_file'):
+                                st.subheader(f"Editing: {st.session_state.current_file} 🛠")
+                                new_content = st.text_area("File Content ✏️:", st.session_state.file_content, height=300)
+                                if st.button("Save Changes 💾"):
+                                    with open(st.session_state.current_file, 'w', encoding='utf-8') as file:
+                                        file.write(new_content)
+                                    st.success("File updated successfully! 🎉")
+                        
+                            # Image Gallery (For your viewing pleasure 📸)
+                            st.subheader("Image Gallery 🖼")
+                            image_files = glob.glob("*.png") + glob.glob("*.jpg") + glob.glob("*.jpeg")
+                            image_cols = st.slider("Gallery Columns 🖼", min_value=1, max_value=15, value=5)
+                            cols = st.columns(image_cols)
+                            for idx, image_file in enumerate(image_files):
+                                with cols[idx % image_cols]:
+                                    img = Image.open(image_file)
+                                    #st.image(img, caption=image_file, use_column_width=True)
+                                    st.image(img, use_column_width=True)
+                                    display_glossary_entity(os.path.splitext(image_file)[0])
+                        
+                            # Video Gallery (Let’s roll the tapes 🎬)
+                            st.subheader("Video Gallery 🎥")
+                            video_files = glob.glob("*.mp4")
+                            video_cols = st.slider("Gallery Columns 🎬", min_value=1, max_value=5, value=3)
+                            cols = st.columns(video_cols)
+                            for idx, video_file in enumerate(video_files):
+                                with cols[idx % video_cols]:
+                                    st.markdown(get_video_html(video_file, width="100%"), unsafe_allow_html=True)
+                                    display_glossary_entity(os.path.splitext(video_file)[0])
+                        
+                            # Audio Gallery (Tunes for the mood 🎶)
+                            st.subheader("Audio Gallery 🎧")
+                            audio_files = glob.glob("*.mp3") + glob.glob("*.wav")
+                            audio_cols = st.slider("Gallery Columns 🎶", min_value=1, max_value=15, value=5)
+                            cols = st.columns(audio_cols)
+                            for idx, audio_file in enumerate(audio_files):
+                                with cols[idx % audio_cols]:
+                                    st.markdown(get_audio_html(audio_file, width="100%"), unsafe_allow_html=True)
+                                    display_glossary_entity(os.path.splitext(audio_file)[0])
+                                
+
+
+                                                
+                        elif selected_view == 'Clone Document':
+                            st.markdown("#### 📄 Clone Document (Save As)")
+                            
+                            total_docs = len(documents)
+                            doc = documents[st.session_state.current_index]
+                            
+                            # Display current document info
+                            st.markdown(f"**Original Document ID:** {doc.get('id', '')}")
+                            st.markdown(f"**Original Document Name:** {doc.get('name', '')}")
+                            
+                            # Generate new unique ID and name
+                            unique_filename = gen_AI_IO_filename("Clone", doc.get('name', ''))
+                            new_id = st.text_input("New Document ID", value=unique_filename, key='new_clone_id')
+                            new_name = st.text_input("New Document Name", value=f"Clone_{unique_filename[:8]}", key='new_clone_name')
+                            
+                            # Create new document with all original content except system fields
+                            new_doc = {
+                                'id': new_id,
+                                'name': new_name,
+                                **{k: v for k, v in doc.items() if k not in ['id', 'name', '_rid', '_self', '_etag', '_attachments', '_ts']}
+                            }
+                            
+                            # Show editable preview of the new document
+                            doc_str = st.text_area(
+                                "Edit Document Content (in JSON format)",
+                                value=json.dumps(new_doc, indent=2),
+                                height=300,
+                                key='clone_preview'
+                            )
+                            
+                            col1, col2 = st.columns(2)
+                            
+                            with col1:
+                                if st.button("🔄 Generate New ID/Name", key='regenerate_id'):
+                                    # Generate new unique filename
+                                    new_unique_filename = gen_AI_IO_filename("Clone", doc.get('name', ''))
+                                    st.session_state.new_clone_id = new_unique_filename
+                                    st.session_state.new_clone_name = f"Clone_{new_unique_filename[:8]}"
+                                    st.rerun()
+                            
+                            with col2:
+                                if st.button("💾 Save As New Document", key='save_clone'):
+                                    try:
+                                        # Parse the edited document content
+                                        final_doc = json.loads(doc_str)
+                                        
+                                        # Ensure the new ID and name are used
+                                        final_doc['id'] = new_id
+                                        final_doc['name'] = new_name
+                                        
+                                        # Remove any system fields that might have been copied
+                                        system_fields = ['_rid', '_self', '_etag', '_attachments', '_ts']
+                                        for field in system_fields:
+                                            final_doc.pop(field, None)
+                                        
+                                        # Create the new document
+                                        response = container.create_item(body=final_doc)
+                                        
+                                        if response:
+                                            st.success(f"""
+                                            ✅ New document created successfully!
+                                            - ID: {final_doc['id']}
+                                            - Name: {final_doc['name']}
+                                            """)
+                                            # Update session state to show the new document
+                                            st.session_state.selected_document_id = final_doc['id']
+                                            st.rerun()
+                                        else:
+                                            st.error("Failed to create new document")
+                                    except json.JSONDecodeError as e:
+                                        st.error(f"Invalid JSON format: {str(e)}")
+                                    except Exception as e:
+                                        st.error(f"Error creating document: {str(e)}")
+                            
+                            # Navigation buttons for viewing other documents to clone
+                            col_prev, col_next = st.columns([1, 1])
+                            with col_prev:
+                                if st.button("⬅️ Previous", key='prev_clone'):
+                                    if st.session_state.current_index > 0:
+                                        st.session_state.current_index -= 1
+                                        st.rerun()
+                            with col_next:
+                                if st.button("➡️ Next", key='next_clone'):
+                                    if st.session_state.current_index < total_docs - 1:
+                                        st.session_state.current_index += 1
+                                        st.rerun()
+                                            
+                                            
+                        elif selected_view == 'New Record':
+                            st.markdown("#### Create a new document:")
+                            
+                            if st.button("🤖 Insert Auto-Generated Record"):
+                                auto_doc = {
+                                    "id": generate_unique_id(),
+                                    "name": f"Auto-generated Record {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+                                    "content": "This is an auto-generated record.",
+                                    "timestamp": datetime.now().isoformat()
+                                }
+                                success, message = save_or_clone_to_cosmos_db(container, document=auto_doc)
+                                if success:
+                                    st.success(message)
+                                    st.rerun()
+                                else:
+                                    st.error(message)
+                            else:
+                                new_id = st.text_input("ID", value=generate_unique_id(), key='new_id')
+                                default_doc = {
+                                    "id": new_id,
+                                    "name": "New Document",
+                                    "content": "",
+                                    "timestamp": datetime.now().isoformat()
+                                }
+                                new_doc_str = st.text_area("Document Content (in JSON format)", 
+                                                          value=json.dumps(default_doc, indent=2), 
+                                                          height=300)
+                                
+                                if st.button("➕ Create New Document"):
+                                    try:
+                                        # Preprocess the text before loading it into JSON
+                                        cleaned_doc_str = preprocess_text(new_doc_str)
+                                        new_doc = json.loads(cleaned_doc_str)
+                                        new_doc['id'] = new_id  # Ensure ID matches input field
+                                        
+                                        success, message = insert_record(container, new_doc)
+                                        if success:
+                                            st.success(f"New document created with id: {new_doc['id']} 🎉")
+                                            st.session_state.selected_document_id = new_doc['id']
+                                            st.rerun()
+                                        else:
+                                            st.error(message)
+                                    except json.JSONDecodeError as e:
+                                        st.error(f"Invalid JSON: {str(e)} 🚫")
+                        
+                                st.subheader(f"📊 Container: {st.session_state.selected_container}")
+                                if st.session_state.selected_container:
+                                    if documents_to_display:
+                                        Label = '#### 📊 Data display - Data tells tales that words cannot'
+                                        st.markdown(Label)
+                                        df = pd.DataFrame(documents_to_display)
+                                        st.dataframe(df)
+                                    else:
+                                        st.info("No documents to display. 🧐")
+                                        
+
+            Label = '#### 🐙 GitHub integration - Git happens'
+            st.subheader("🐙 GitHub Operations")
+            github_token = os.environ.get("GITHUB")
+            source_repo = st.text_input("Source GitHub Repository URL", 
+                                      value="https://github.com/AaronCWacker/AIExamples-8-24-Streamlit")
+            new_repo_name = st.text_input("New Repository Name (for cloning)", 
+                                        value=f"AIExample-Clone-{datetime.now().strftime('%Y%m%d_%H%M%S')}")
+
+            col1, col2 = st.columns(2)
+            with col1:
+                if st.button("📥 Clone Repository"):
+                    if github_token and source_repo:
+
+                        st.markdown(Label)
+                        try:
+                            local_path = f"./temp_repo_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+                            download_github_repo(source_repo, local_path)
+                            zip_filename = f"{new_repo_name}.zip"
+                            create_zip_file(local_path, zip_filename[:-4])
+                            st.markdown(get_download_link(zip_filename), unsafe_allow_html=True)
+                            st.success("Repository cloned successfully! 🎉")
+                        except Exception as e:
+                            st.error(f"An error occurred: {str(e)} 😢")
+                        finally:
+                            if os.path.exists(local_path):
+                                shutil.rmtree(local_path)
+                            if os.path.exists(zip_filename):
+                                os.remove(zip_filename)
+                    else:
+                        st.error("Please ensure GitHub token is set in environment variables and source repository URL is provided. 🔑❓")
+
+            with col2:
+                if st.button("📤 Push to New Repository"):
+                    if github_token and source_repo:
+
+                        st.markdown(Label)
+                        try:
+                            g = Github(github_token)
+                            new_repo = create_repo(g, new_repo_name)
+                            local_path = f"./temp_repo_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+                            download_github_repo(source_repo, local_path)
+                            push_to_github(local_path, new_repo, github_token)
+                            st.success(f"Repository pushed successfully to {new_repo.html_url} 🚀")
+                        except Exception as e:
+                            st.error(f"An error occurred: {str(e)} 😢")
+                        finally:
+                            if os.path.exists(local_path):
+                                shutil.rmtree(local_path)
+                    else:
+                        st.error("Please ensure GitHub token is set in environment variables and source repository URL is provided. 🔑❓")
+
+            
+            st.subheader("💬 Chat with Claude")
+            user_input = st.text_area("Message 📨:", height=100)
+
+            if st.button("Send 📨"):
+                Label = '#### 💬 Chat functionality - Every chat is a chance to learn'
+                st.markdown(Label)
+                if user_input:
+                    response = anthropicclient.messages.create(
+                        model="claude-3-sonnet-20240229",
+                        max_tokens=1000,
+                        messages=[
+                            {"role": "user", "content": user_input}
+                        ]
+                    )
+                    st.write("Claude's reply 🧠:")
+                    st.write(response.content[0].text)
+                    filename = generate_filename(user_input, "md")
+                    create_file(filename, user_input, response.content[0].text)
+                    st.session_state.chat_history.append({"user": user_input, "claude": response.content[0].text})
+                    # Save to Cosmos DB
+                    save_to_cosmos_db(container, user_input, response.content[0].text, "")
+
+
+            
+            # 📜 Chat history display - "History repeats itself, first as chat, then as wisdom"
+            st.subheader("Past Conversations 📜")
+            for chat in st.session_state.chat_history:
+                st.text_area("You said 💬:", chat["user"], height=100, disabled=True)
+                st.text_area("Claude replied 🤖:", chat["claude"], height=200, disabled=True)
+                st.markdown("---")
+                
+
+
+
+
+
+
+
+
+
+            
+            # 📝 File editor - "Edit with care, save with flair"
+            if hasattr(st.session_state, 'current_file'):
+                st.subheader(f"Editing: {st.session_state.current_file} 🛠")
+                new_content = st.text_area("File Content ✏️:", st.session_state.file_content, height=300)
+
+                # Preprocess the text before loading it into JSON - Added to protect copy paste into JSON to keep format.
+                cleaned_doc_str = preprocess_text(new_content)
+                new_doc = json.loads(cleaned_doc_str)
+                new_content = cleaned_doc_str
+
+                if st.button("Save Changes 💾"):
+                    with open(st.session_state.current_file, 'w', encoding='utf-8') as file:
+                        file.write(new_content)
+                    st.success("File updated successfully! 🎉")
+
+            # 📂 File management - "Manage many, maintain order"
+            update_file_management_section()
+
+        except exceptions.CosmosHttpResponseError as e:
+            st.error(f"Failed to connect to Cosmos DB. HTTP error: {str(e)} 🚨")
+        except Exception as e:
+            st.error(f"An unexpected error occurred: {str(e)} 😱")
+    
+    if st.session_state.logged_in and st.sidebar.button("🚪 Logout"):
+        Label = '#### 🚪 Logout - All good things must come to an end'
+        st.markdown(Label)
+        st.session_state.logged_in = False
+        st.session_state.selected_records.clear()
+        st.session_state.client = None
+        st.session_state.selected_database = None
+        st.session_state.selected_container = None
+        st.session_state.selected_document_id = None
+        st.session_state.current_index = 0
+        st.rerun()
+
+
+if __name__ == "__main__":
+    main()