Update app.py

app.py

@@ -150,6 +150,14 @@ def preprocess_text(text):
     text = re.sub(r'[^\x00-\x7F]+', '', text)
     return text.strip()
 
+# NEW: Sanitize JSON text before saving (remove problematic control characters)
+def sanitize_json_text(text):
+    # Remove control characters except newline, carriage return, and tab
+    text = re.sub(r'[\x00-\x08\x0B\x0C\x0E-\x1F]', '', text)
+    # Escape newline, tab, and carriage return
+    text = text.replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t")
+    return text
+
 # =============================================================================
 # ───────────── COSMOS DB FUNCTIONS ─────────────
 # =============================================================================
@@ -408,8 +416,14 @@ def display_file_editor(file_path):
     col1, col2 = st.columns([1, 5])
     with col1:
         if st.button("💾 Save"):
-            if save_file_content(file_path, new_content):
-                st.session_state.file_content[file_path] = new_content
+            sanitized = sanitize_json_text(new_content)
+            try:
+                json.loads(sanitized)
+            except Exception as e:
+                st.error(f"Sanitization failed: {str(e)}")
+                return
+            if save_file_content(file_path, sanitized):
+                st.session_state.file_content[file_path] = sanitized
                 st.success("Saved! 🎉")
                 time.sleep(1)
                 st.rerun()
@@ -507,12 +521,74 @@ def show_sidebar_data_grid():
                 })
             df = pd.DataFrame(data)
             st.sidebar.markdown("### 📊 Data Grid")
-            st.sidebar.dataframe(df)
+            st.sidebar.dataframe(df[["Name", "Timestamp"]])
         except Exception as e:
             st.sidebar.error(f"Data grid error: {str(e)}")
     else:
         st.sidebar.info("No container selected for data grid.")
 
+# =============================================================================
+# ───────────── SEARCH RESULTS DISPLAY (Editable Code Editors)
+# =============================================================================
+def display_search_results(keyword, container):
+    results = vector_keyword_search(keyword, container)
+    st.markdown("### 🔍 Search Results")
+    for res in results:
+        doc_id = res.get("id", "")
+        exp = st.expander(f"Result {doc_id}")
+        with exp:
+            edited = st.text_area("Edit Document", value=json.dumps(res, indent=2), key=f"search_{doc_id}")
+            if st.button(f"💾 Save changes for {doc_id}", key=f"save_search_{doc_id}"):
+                try:
+                    updated_doc = json.loads(edited)
+                    container.upsert_item(body=updated_doc)
+                    st.success(f"Updated {doc_id}!")
+                    st.experimental_rerun()
+                except Exception as e:
+                    st.error(f"Error saving {doc_id}: {str(e)}")
+
+# =============================================================================
+# ───────────── DOCUMENTS LIST VIEW (Editable List with Sorting)
+# =============================================================================
+def edit_documents_list(container):
+    records = get_documents(container)
+    sort_option = st.selectbox("Sort by", ["Timestamp", "Name"], key="sort_option")
+    if sort_option == "Name":
+        records.sort(key=lambda r: r.get("name", "").lower())
+    else:
+        records.sort(key=lambda r: r.get("timestamp", ""), reverse=True)
+    data = []
+    for rec in records:
+        ts = rec.get("timestamp", "")
+        try:
+            dt = datetime.fromisoformat(ts)
+            formatted = dt.strftime("%I:%M %p %m/%d/%Y")
+        except Exception:
+            formatted = ts
+        data.append({
+            "ID": rec.get("id", ""),
+            "Name": rec.get("name", ""),
+            "Content": rec.get("content", "")[:100] + "..." if rec.get("content", "") else "",
+            "Timestamp": formatted
+        })
+    df = pd.DataFrame(data)
+    edited_df = st.data_editor(df[["Name", "Content", "Timestamp"]], key="docs_editor", num_rows="dynamic")
+    if st.button("💾 Save List Changes"):
+        for idx, row in edited_df.iterrows():
+            original = data[idx]
+            if row["Name"] != original["Name"] or row["Content"] != original["Content"]:
+                doc_id = original["ID"]
+                doc = next((r for r in records if r.get("id") == doc_id), None)
+                if doc:
+                    doc["name"] = row["Name"]
+                    doc["content"] = row["Content"]
+                    success, message = update_record(container, doc)
+                    if success:
+                        st.success(f"Updated {doc_id} 👍")
+                    else:
+                        st.error(f"Error updating {doc_id}: {message}")
+        st.experimental_rerun()
+
 # =============================================================================
 # ────��──────── VIDEO & AUDIO UI FUNCTIONS ─────────────
 # =============================================================================
@@ -629,57 +705,6 @@ def add_video_generation_ui(container):
         except Exception as e:
             st.error(f"Upload error: {str(e)}")
 
-# =============================================================================
-# ───────────── AI SAMPLES SIDEBAR (Processed as a Python List) ─────────────
-# =============================================================================
-def display_ai_samples():
-    ai_samples = [
-        {
-            "name": "FullTextContains",
-            "description": "Query using FullTextContains",
-            "query": 'SELECT TOP 10 * FROM c WHERE FullTextContains(c.text, "bicycle")'
-        },
-        {
-            "name": "FullTextContainsAll",
-            "description": "Query using FullTextContainsAll",
-            "query": 'SELECT TOP 10 * FROM c WHERE FullTextContainsAll(c.text, "red", "bicycle")'
-        },
-        {
-            "name": "FullTextContainsAny",
-            "description": "Query using FullTextContainsAny",
-            "query": 'SELECT TOP 10 * FROM c WHERE FullTextContains(c.text, "red") AND FullTextContainsAny(c.text, "bicycle", "skateboard")'
-        },
-        {
-            "name": "FullTextScore",
-            "description": "Query using FullTextScore (order by relevance)",
-            "query": 'SELECT TOP 10 * FROM c ORDER BY RANK FullTextScore(c.text, ["bicycle", "mountain"])'
-        },
-        {
-            "name": "Vector Search with Score",
-            "description": "Example vector search snippet",
-            "query": 'results = vector_search.similarity_search_with_score(query="Your query", k=5)\nfor result, score in results:\n    print(result.json(), score)'
-        },
-        {
-            "name": "Vector Search with Filtering",
-            "description": "Example vector search with a filter",
-            "query": 'pre_filter = {"conditions": [{"property": "metadata.page", "operator": "$eq", "value": 0}]}\nresults = vector_search.similarity_search_with_score(query="Your query", k=5, pre_filter=pre_filter)'
-        },
-        {
-            "name": "Hybrid Search",
-            "description": "Example hybrid search snippet",
-            "query": 'results = vector_search.similarity_search_with_score(query="Your query", k=5, query_type=CosmosDBQueryType.HYBRID)'
-        }
-    ]
-    st.sidebar.markdown("### 🤖 AI Samples")
-    st.sidebar.info("🚀 Get started with our AI samples! Time free access to get started today.")
-    sample_names = [sample["name"] for sample in ai_samples]
-    selected_sample_name = st.sidebar.selectbox("Select an AI Sample", sample_names)
-    selected_sample = next((s for s in ai_samples if s["name"] == selected_sample_name), None)
-    if selected_sample:
-        st.sidebar.markdown(f"**{selected_sample['name']}**: {selected_sample['description']}")
-        lang = "sql" if "FullText" in selected_sample["name"] else "python"
-        st.sidebar.code(selected_sample["query"], language=lang)
-
 # =============================================================================
 # ───────────── NEW ITEM & FIELD FUNCTIONS
 # =============================================================================
@@ -704,6 +729,10 @@ def new_item_default(container):
 def auto_save_edit():
     try:
          edited_str = st.session_state.doc_editor
+         try:
+             json.loads(edited_str)
+         except Exception:
+             edited_str = sanitize_json_text(edited_str)
          edited_doc = json.loads(edited_str)
          container = st.session_state.current_container
          container.upsert_item(edited_doc)
@@ -793,260 +822,336 @@ def display_langchain_functions():
         st.sidebar.write(f"{func['name']}: {func['comment']}")
 
 # =============================================================================
-# ───────────── OPTIONAL: SIDEBAR DATA GRID (Records with formatted timestamps)
+# ───────────── SIDEBAR DATA GRID (Editable Names Grid)
 # =============================================================================
-# (This feature is now integrated above via show_sidebar_data_grid().)
+def edit_names_grid(container):
+    records = get_documents(container)
+    data = []
+    for rec in records:
+        ts = rec.get("timestamp", "")
+        try:
+            dt = datetime.fromisoformat(ts)
+            formatted = dt.strftime("%I:%M %p %m/%d/%Y")
+        except Exception:
+            formatted = ts
+        data.append({
+            "ID": rec.get("id", ""),
+            "Name": rec.get("name", ""),
+            "Timestamp": formatted
+        })
+    df = pd.DataFrame(data)
+    edited_df = st.sidebar.data_editor(df[["Name", "Timestamp"]], key="names_editor", num_rows="dynamic")
+    if st.sidebar.button("💾 Save Name Changes"):
+        for idx, row in edited_df.iterrows():
+            original = df.iloc[idx]
+            if row["Name"] != original["Name"]:
+                doc_id = original["ID"]
+                doc = next((r for r in records if r.get("id") == doc_id), None)
+                if doc:
+                    doc["name"] = row["Name"]
+                    success, message = update_record(container, doc)
+                    if success:
+                        st.sidebar.success(f"Updated Name for {doc_id} to '{row['Name']}'")
+                    else:
+                        st.sidebar.error(f"Update error for {doc_id}: {message}")
+        st.experimental_rerun()
 
 # =============================================================================
-# ───────────── ASYNC TTS & ARXIV FUNCTIONS (Optional Features)
+# ───────────── SEARCH RESULTS DISPLAY (Editable Code Editors)
 # =============================================================================
-import asyncio
-import edge_tts
-from streamlit_marquee import streamlit_marquee
-from collections import Counter
-
-class PerformanceTimer:
-    def __init__(self, operation_name: str):
-        self.operation_name = operation_name
-        self.start_time = None
-    def __enter__(self):
-        self.start_time = time.time()
-        return self
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        pass
+def display_search_results(keyword, container):
+    results = vector_keyword_search(keyword, container)
+    st.markdown("### 🔍 Search Results")
+    for res in results:
+        doc_id = res.get("id", "")
+        exp = st.expander(f"Result {doc_id}")
+        with exp:
+            edited = st.text_area("Edit Document", value=json.dumps(res, indent=2), key=f"search_{doc_id}")
+            if st.button(f"💾 Save changes for {doc_id}", key=f"save_search_{doc_id}"):
+                try:
+                    updated_doc = json.loads(edited)
+                    container.upsert_item(body=updated_doc)
+                    st.success(f"Updated {doc_id}!")
+                    st.experimental_rerun()
+                except Exception as e:
+                    st.error(f"Error saving {doc_id}: {str(e)}")
 
-async def async_edge_tts_generate(text: str, voice: str, rate: int = 0, pitch: int = 0, file_format: str = "mp3"):
-    with PerformanceTimer("tts_generation") as timer:
-        text = text.replace("\n", " ").strip()
-        if not text:
-            return None, 0
-        cache_key = f"{text[:100]}_{voice}_{rate}_{pitch}_{file_format}"
-        if cache_key in st.session_state.get('audio_cache', {}):
-            return st.session_state['audio_cache'][cache_key], 0
+# =============================================================================
+# ───────────── DOCUMENTS LIST VIEW (Editable List with Sorting)
+# =============================================================================
+def edit_documents_list(container):
+    records = get_documents(container)
+    sort_option = st.selectbox("Sort by", ["Timestamp", "Name"], key="sort_option")
+    if sort_option == "Name":
+        records.sort(key=lambda r: r.get("name", "").lower())
+    else:
+        records.sort(key=lambda r: r.get("timestamp", ""), reverse=True)
+    data = []
+    for rec in records:
+        ts = rec.get("timestamp", "")
         try:
-            rate_str = f"{rate:+d}%"
-            pitch_str = f"{pitch:+d}Hz"
-            communicate = edge_tts.Communicate(text, voice, rate=rate_str, pitch=pitch_str)
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            filename = f"audio_{timestamp}_{random.randint(1000, 9999)}.{file_format}"
-            await communicate.save(filename)
-            st.session_state.setdefault('audio_cache', {})[cache_key] = filename
-            return filename, time.time() - timer.start_time
-        except Exception as e:
-            st.error(f"Error generating audio: {str(e)}")
-            return None, 0
-
-def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0, file_format="mp3"):
-    result = asyncio.run(async_edge_tts_generate(text, voice, rate, pitch, file_format))
-    if isinstance(result, tuple):
-        return result[0]
-    return result
-
-async def async_save_qa_with_audio(question: str, answer: str):
-    with PerformanceTimer("qa_save") as timer:
-        md_file = create_file(question, answer, "md")
-        audio_file = None
-        if st.session_state.get('enable_audio', True):
-            audio_text = f"{question}\n\nAnswer: {answer}"
-            audio_file, _ = await async_edge_tts_generate(audio_text, voice=st.session_state.get('tts_voice', "en-US-AriaNeural"), file_format=st.session_state.get('audio_format', "mp3"))
-        return md_file, audio_file, time.time() - timer.start_time, 0
-
-def save_qa_with_audio(question, answer, voice=None):
-    if not voice:
-        voice = st.session_state.get('tts_voice', "en-US-AriaNeural")
-    md_file = create_file(question, answer, "md")
-    audio_text = f"{question}\n\nAnswer: {answer}"
-    audio_file = speak_with_edge_tts(audio_text, voice=voice, file_format=st.session_state.get('audio_format', "mp3"))
-    return md_file, audio_file
-
-def play_and_download_audio(file_path, file_type="mp3"):
-    if file_path and os.path.exists(file_path):
-        st.audio(file_path)
-        dl_link = get_download_link(file_path, file_type=file_type)
-        st.markdown(dl_link, unsafe_allow_html=True)
+            dt = datetime.fromisoformat(ts)
+            formatted = dt.strftime("%I:%M %p %m/%d/%Y")
+        except Exception:
+            formatted = ts
+        data.append({
+            "ID": rec.get("id", ""),
+            "Name": rec.get("name", ""),
+            "Content": rec.get("content", "")[:100] + "..." if rec.get("content", "") else "",
+            "Timestamp": formatted
+        })
+    df = pd.DataFrame(data)
+    edited_df = st.data_editor(df[["Name", "Content", "Timestamp"]], key="docs_editor", num_rows="dynamic")
+    if st.button("💾 Save List Changes"):
+        for idx, row in edited_df.iterrows():
+            original = data[idx]
+            if row["Name"] != original["Name"] or row["Content"] != original["Content"]:
+                doc_id = original["ID"]
+                doc = next((r for r in records if r.get("id") == doc_id), None)
+                if doc:
+                    doc["name"] = row["Name"]
+                    doc["content"] = row["Content"]
+                    success, message = update_record(container, doc)
+                    if success:
+                        st.success(f"Updated {doc_id} 👍")
+                    else:
+                        st.error(f"Error updating {doc_id}: {message}")
+        st.experimental_rerun()
 
-def create_download_link_with_cache(file_path: str, file_type: str = "mp3") -> str:
-    cache_key = f"dl_{file_path}"
-    if cache_key in st.session_state.get('download_link_cache', {}):
-        return st.session_state['download_link_cache'][cache_key]
+# =============================================================================
+# ───────────── VIDEO & AUDIO UI FUNCTIONS ─────────────
+# =============================================================================
+def validate_and_preprocess_image(file_data, target_size=(576, 1024)):
     try:
-        with open(file_path, "rb") as f:
-            b64 = base64.b64encode(f.read()).decode()
-        filename = os.path.basename(file_path)
-        if file_type == "mp3":
-            link = f'<a href="data:audio/mpeg;base64,{b64}" download="{filename}">🎵 Download {filename}</a>'
-        elif file_type == "wav":
-            link = f'<a href="data:audio/wav;base64,{b64}" download="{filename}">🔊 Download {filename}</a>'
-        elif file_type == "md":
-            link = f'<a href="data:text/markdown;base64,{b64}" download="{filename}">📝 Download {filename}</a>'
+        st.write("Preprocessing image...")
+        if isinstance(file_data, bytes):
+            img = Image.open(io.BytesIO(file_data))
+        elif hasattr(file_data, 'read'):
+            if hasattr(file_data, 'seek'):
+                file_data.seek(0)
+            img = Image.open(file_data)
+        elif isinstance(file_data, Image.Image):
+            img = file_data
+        else:
+            raise ValueError(f"Unsupported input: {type(file_data)}")
+        if img.mode != 'RGB':
+            img = img.convert('RGB')
+        aspect_ratio = img.size[0] / img.size[1]
+        if aspect_ratio > target_size[0] / target_size[1]:
+            new_width = target_size[0]
+            new_height = int(new_width / aspect_ratio)
         else:
-            link = f'<a href="data:application/octet-stream;base64,{b64}" download="{filename}">Download {filename}</a>'
-        st.session_state.setdefault('download_link_cache', {})[cache_key] = link
-        return link
+            new_height = target_size[1]
+            new_width = int(new_height * aspect_ratio)
+        new_width = (new_width // 2) * 2
+        new_height = (new_height // 2) * 2
+        resized_img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+        final_img = Image.new('RGB', target_size, (255, 255, 255))
+        paste_x = (target_size[0] - new_width) // 2
+        paste_y = (target_size[1] - new_height) // 2
+        final_img.paste(resized_img, (paste_x, paste_y))
+        return final_img
     except Exception as e:
-        st.error(f"Error creating download link: {str(e)}")
-        return ""
+        st.error(f"Image error: {str(e)}")
+        return None
 
-# =============================================================================
-# ───────────── RESEARCH / ARXIV FUNCTIONS (Optional Features)
-# =============================================================================
-def parse_arxiv_refs(ref_text: str):
-    if not ref_text:
-        return []
-    results = []
-    current_paper = {}
-    lines = ref_text.split('\n')
-    for i, line in enumerate(lines):
-        if line.count('|') == 2:
-            if current_paper:
-                results.append(current_paper)
-                if len(results) >= 20:
-                    break
-            try:
-                header_parts = line.strip('* ').split('|')
-                date = header_parts[0].strip()
-                title = header_parts[1].strip()
-                url_match = re.search(r'(https://arxiv.org/\S+)', line)
-                url = url_match.group(1) if url_match else f"paper_{len(results)}"
-                current_paper = {
-                    'date': date,
-                    'title': title,
-                    'url': url,
-                    'authors': '',
-                    'summary': '',
-                    'full_audio': None,
-                    'download_base64': '',
-                }
-            except Exception as e:
-                st.warning(f"Error parsing paper header: {str(e)}")
-                current_paper = {}
-                continue
-        elif current_paper:
-            if not current_paper['authors']:
-                current_paper['authors'] = line.strip('* ')
-            else:
-                if current_paper['summary']:
-                    current_paper['summary'] += ' ' + line.strip()
+def add_video_generation_ui(container):
+    st.markdown("### 🎥 Video Gen")
+    col1, col2 = st.columns([2, 1])
+    with col1:
+        uploaded_file = st.file_uploader("Upload Image 🖼️", type=['png', 'jpg', 'jpeg'])
+    with col2:
+        st.markdown("#### Params")
+        motion = st.slider("🌊 Motion", 1, 255, 127)
+        fps = st.slider("🎬 FPS", 1, 30, 6)
+        with st.expander("Advanced"):
+            use_custom = st.checkbox("Custom Seed")
+            seed = st.number_input("Seed", value=int(time.time() * 1000)) if use_custom else None
+    if uploaded_file is not None:
+        try:
+            file_data = uploaded_file.read()
+            preview1, preview2 = st.columns(2)
+            with preview1:
+                st.write("Original")
+                st.image(Image.open(io.BytesIO(file_data)), use_column_width=True)
+            with preview2:
+                proc_img = validate_and_preprocess_image(io.BytesIO(file_data))
+                if proc_img:
+                    st.write("Processed")
+                    st.image(proc_img, use_column_width=True)
                 else:
-                    current_paper['summary'] = line.strip()
-    if current_paper:
-        results.append(current_paper)
-    return results[:20]
-
-def create_paper_links_md(papers):
-    lines = ["# Paper Links\n"]
-    for i, p in enumerate(papers, start=1):
-        lines.append(f"{i}. **{p['title']}** — [Arxiv Link]({p['url']})")
-    return "\n".join(lines)
-
-def generate_pdf_link(url: str) -> str:
-    if "abs" in url:
-        pdf_url = url.replace("abs", "pdf")
-        if not pdf_url.endswith(".pdf"):
-            pdf_url += ".pdf"
-        return pdf_url
-    return url
-
-def generate_5min_feature_markdown(paper: dict) -> str:
-    title = paper.get('title', '')
-    summary = paper.get('summary', '')
-    authors = paper.get('authors', '')
-    date = paper.get('date', '')
-    url = paper.get('url', '')
-    pdf_link = generate_pdf_link(url)
-    title_wc = len(title.split())
-    summary_wc = len(summary.split())
-    high_info_terms = [term for term in summary.split()[:5]]
-    terms_str = ", ".join(high_info_terms)
-    rouge_score = round((len(high_info_terms) / max(len(summary.split()), 1)) * 100, 2)
-    mermaid_code = "```mermaid\nflowchart TD\n"
-    for i in range(len(high_info_terms) - 1):
-        mermaid_code += f'    T{i+1}["{high_info_terms[i]}"] --> T{i+2}["{high_info_terms[i+1]}"]\n'
-    mermaid_code += "```"
-    md = f"""
-## {title}
-
-**Authors:** {authors}  
-**Date:** {date}  
-**Word Count (Title):** {title_wc} | **Word Count (Summary):** {summary_wc}  
+                    st.error("Preprocess failed")
+                    return
+            if st.button("🎥 Generate"):
+                with st.spinner("Generating video..."):
+                    with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as temp_file:
+                        proc_img.save(temp_file.name, format='PNG')
+                        try:
+                            client = Client("awacke1/stable-video-diffusion", hf_token=os.environ.get("HUGGINGFACE_TOKEN"))
+                            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,
+                                fps_id=fps,
+                                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):
+                                    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! 🎉")
+                                    st.video(video_filename)
+                                    if container:
+                                        video_record = {
+                                            "id": generate_unique_id(),
+                                            "pk": generate_unique_id(),
+                                            "type": "generated_video",
+                                            "filename": video_filename,
+                                            "seed": seed if seed is not None else "random",
+                                            "motion": motion,
+                                            "fps": fps,
+                                            "timestamp": datetime.now().isoformat()
+                                        }
+                                        success, message = insert_record(container, video_record)
+                                        if success:
+                                            st.success("DB record saved!")
+                                        else:
+                                            st.error(f"DB error: {message}")
+                                else:
+                                    st.error("Invalid result format")
+                            else:
+                                st.error("No result returned")
+                        except Exception as e:
+                            st.error(f"Video gen error: {str(e)}")
+                        finally:
+                            try:
+                                os.unlink(temp_file.name)
+                                st.write("Temp file removed")
+                            except Exception as e:
+                                st.warning(f"Cleanup error: {str(e)}")
+        except Exception as e:
+            st.error(f"Upload error: {str(e)}")
 
-**Links:** [Abstract]({url}) | [PDF]({pdf_link})
+# =============================================================================
+# ───────────── NEW ITEM & FIELD FUNCTIONS
+# =============================================================================
+def new_item_default(container):
+    new_id = generate_unique_id()
+    default_doc = {
+         "id": new_id,
+         "pk": new_id,
+         "name": "New Sample Document",
+         "content": "Start editing your document here...",
+         "timestamp": datetime.now().isoformat(),
+         "type": "sample"
+    }
+    success, message = insert_record(container, default_doc)
+    if success:
+         st.success("New sample document created! ✨")
+         return default_doc
+    else:
+         st.error("Error creating new item: " + message)
+         return None
 
-**High Info Terms:** {terms_str}  
-**ROUGE Score:** {rouge_score}%
+def auto_save_edit():
+    try:
+         edited_str = st.session_state.doc_editor
+         try:
+             json.loads(edited_str)
+         except Exception:
+             edited_str = sanitize_json_text(edited_str)
+         edited_doc = json.loads(edited_str)
+         container = st.session_state.current_container
+         container.upsert_item(edited_doc)
+         st.success("Auto-saved! 💾")
+    except Exception as e:
+         st.error(f"Auto-save error: {str(e)}")
 
-### Mermaid Graph of Key Concepts
-{mermaid_code}
+def add_field_to_doc():
+    key = st.session_state.new_field_key
+    value = st.session_state.new_field_value
+    try:
+         doc = json.loads(st.session_state.doc_editor)
+         doc[key] = value
+         st.session_state.doc_editor = json.dumps(doc, indent=2)
+         auto_save_edit()
+         st.success(f"Added field {key} 👍")
+    except Exception as e:
+         st.error(f"Error adding field: {str(e)}")
 
----
-"""
-    return md
+# =============================================================================
+# ───────────── SEARCH RESULTS DISPLAY (Editable Code Editors)
+# =============================================================================
+def display_search_results(keyword, container):
+    results = vector_keyword_search(keyword, container)
+    st.markdown("### 🔍 Search Results")
+    for res in results:
+        doc_id = res.get("id", "")
+        exp = st.expander(f"Result {doc_id}")
+        with exp:
+            edited = st.text_area("Edit Document", value=json.dumps(res, indent=2), key=f"search_{doc_id}")
+            if st.button(f"💾 Save changes for {doc_id}", key=f"save_search_{doc_id}"):
+                try:
+                    updated_doc = json.loads(edited)
+                    container.upsert_item(body=updated_doc)
+                    st.success(f"Updated {doc_id}!")
+                    st.experimental_rerun()
+                except Exception as e:
+                    st.error(f"Error saving {doc_id}: {str(e)}")
 
-def create_detailed_paper_md(papers: list) -> str:
-    md_parts = ["# Detailed Research Paper Summary\n"]
-    for idx, paper in enumerate(papers, start=1):
-        md_parts.append(generate_5min_feature_markdown(paper))
-    return "\n".join(md_parts)
+# =============================================================================
+# ───────────── DOCUMENTS LIST VIEW (Editable List with Sorting)
+# =============================================================================
+def edit_documents_list(container):
+    records = get_documents(container)
+    sort_option = st.selectbox("Sort by", ["Timestamp", "Name"], key="sort_option")
+    if sort_option == "Name":
+        records.sort(key=lambda r: r.get("name", "").lower())
+    else:
+        records.sort(key=lambda r: r.get("timestamp", ""), reverse=True)
+    data = []
+    for rec in records:
+        ts = rec.get("timestamp", "")
+        try:
+            dt = datetime.fromisoformat(ts)
+            formatted = dt.strftime("%I:%M %p %m/%d/%Y")
+        except Exception:
+            formatted = ts
+        data.append({
+            "ID": rec.get("id", ""),
+            "Name": rec.get("name", ""),
+            "Content": rec.get("content", "")[:100] + "..." if rec.get("content", "") else "",
+            "Timestamp": formatted
+        })
+    df = pd.DataFrame(data)
+    edited_df = st.data_editor(df[["Name", "Content", "Timestamp"]], key="docs_editor", num_rows="dynamic")
+    if st.button("💾 Save List Changes"):
+        for idx, row in edited_df.iterrows():
+            original = data[idx]
+            if row["Name"] != original["Name"] or row["Content"] != original["Content"]:
+                doc_id = original["ID"]
+                doc = next((r for r in records if r.get("id") == doc_id), None)
+                if doc:
+                    doc["name"] = row["Name"]
+                    doc["content"] = row["Content"]
+                    success, message = update_record(container, doc)
+                    if success:
+                        st.success(f"Updated {doc_id} 👍")
+                    else:
+                        st.error(f"Error updating {doc_id}: {message}")
+        st.experimental_rerun()
 
 # =============================================================================
-# ─────────────────────────────────────────────────────────
-# MAIN AI LOOKUP FUNCTION (Optional Features)
+# ───────────── SEARCH DOCUMENTS UI (Enter Key triggers search)
 # =============================================================================
-def perform_ai_lookup(q, vocal_summary=True, extended_refs=False, titles_summary=True, full_audio=False, useArxiv=True, useArxivAudio=False):
-    start = time.time()
-    ai_constitution = """
-    You are a medical and machine learning review board expert...
-    """
-    # 1) Claude API call
-    import anthropic
-    client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY_3"))
-    user_input = q
-    response = client.messages.create(
-        model="claude-3-sonnet-20240229",
-        max_tokens=1000,
-        messages=[{"role": "user", "content": user_input}]
-    )
-    st.write("Claude's reply 🧠:")
-    st.markdown(response.content[0].text)
-    result = response.content[0].text
-    create_file(q, result, "md")
-    md_file, audio_file = save_qa_with_audio(q, result)
-    st.subheader("📝 Main Response Audio")
-    play_and_download_audio(audio_file, st.session_state.get('audio_format', "mp3"))
-    if useArxiv:
-        q = q + result
-        st.write('Running Arxiv RAG with Claude inputs.')
-        client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
-        refs = client.predict(q, 10, "Semantic Search", "mistralai/Mixtral-8x7B-Instruct-v0.1", api_name="/update_with_rag_md")[0]
-        result = f"🔎 {q}\n\n{refs}"
-        md_file, audio_file = save_qa_with_audio(q, result)
-        st.subheader("📝 Main Response Audio")
-        play_and_download_audio(audio_file, st.session_state.get('audio_format', "mp3"))
-        papers = parse_arxiv_refs(refs)
-        if papers:
-            paper_links = create_paper_links_md(papers)
-            links_file = create_file(q, paper_links, "md")
-            st.markdown(paper_links)
-            detailed_md = create_detailed_paper_md(papers)
-            detailed_file = create_file(q, detailed_md, "md")
-            st.markdown(detailed_md)
-            if useArxivAudio:
-                asyncio.run(async_edge_tts_generate("Sample text", st.session_state.get('tts_voice', "en-US-AriaNeural")))
-            st.write("Displaying Papers:")
-            # (Optional: call functions to display papers)
-        else:
-            st.warning("No papers found.")
-        response2 = client.messages.create(
-            model="claude-3-sonnet-20240229",
-            max_tokens=1000,
-            messages=[{"role": "user", "content": q + '\n\nUse the reference papers below to answer the question by creating a python streamlit app.py and requirements.txt with working code.'}]
-        )
-        r2 = response2.content[0].text
-        st.write("Claude's reply 🧠:")
-        st.markdown(r2)
-    elapsed = time.time() - start
-    st.write(f"**Total Elapsed:** {elapsed:.2f} s")
-    return result
+def search_documents_ui(container):
+    with st.sidebar.form("search_form"):
+        keyword = st.text_input("Search Keyword", key="search_keyword")
+        submitted = st.form_submit_button("🔍 Search")
+        if submitted and keyword:
+            display_search_results(keyword, container)
 
 # =============================================================================
 # ───────────── MAIN FUNCTION ─────────────
@@ -1089,17 +1194,11 @@ def main():
         else:
             st.warning("No container selected!")
     st.sidebar.markdown("## 🔍 Vector Search")
-    search_keyword = st.sidebar.text_input("Search Keyword", key="vector_search_keyword")
-    if st.sidebar.button("Search"):
-        if st.session_state.get("current_container"):
-            results = vector_keyword_search(search_keyword, st.session_state.current_container)
-            st.sidebar.write(f"Found {len(results)} results:")
-            for res in results:
-                st.sidebar.code(json.dumps(res, indent=2), language="json")
-        else:
-            st.warning("No container selected for search!")
+    search_documents_ui(st.session_state.get("current_container"))
     show_sidebar_data_grid()
     display_langchain_functions()
+    if st.session_state.get("current_container"):
+        edit_names_grid(st.session_state.current_container)
     try:
         if st.session_state.get("client") is None:
             st.session_state.client = CosmosClient(ENDPOINT, credential=st.session_state.primary_key)
@@ -1170,9 +1269,11 @@ def main():
                 num_docs = st.slider("Docs", 1, 20, 1)
                 documents_to_display = documents[:num_docs] if total_docs > num_docs else documents
                 st.sidebar.info(f"Showing {len(documents_to_display)} docs")
-                view_options = ['Markdown', 'Code', 'Run AI', 'Clone', 'New']
+                view_options = ['List', 'Markdown', 'Code', 'Run AI', 'Clone', 'New']
                 selected_view = st.sidebar.selectbox("View", view_options, index=1)
-                if selected_view == 'Markdown':
+                if selected_view == 'List':
+                    edit_documents_list(container)
+                elif selected_view == 'Markdown':
                     st.markdown("#### 📄 Markdown")
                     if documents:
                         doc = documents[st.session_state.current_index]
@@ -1334,4 +1435,4 @@ def main():
     show_sidebar_data_grid()
 
 if __name__ == "__main__":
-    main()
+    main()