Update app.py

app.py

@@ -1,71 +1,172 @@
 import streamlit as st
+from streamlit.components.v1 import html
 from pathlib import Path
 import json
+import time
+from datetime import datetime
+import re
+import pandas as pd
+import markdown
+import yaml
+from io import StringIO
+import openpyxl
+import csv
 
-# 🦄 Magical state initialization
+# 🦄✨ Enhanced state initialization with file type tracking! 
 if 'file_data' not in st.session_state:
     st.session_state.file_data = {}
+if 'file_types' not in st.session_state:
+    st.session_state.file_types = {}  # 📁 Track file types for special handling
+if 'md_outline' not in st.session_state:
+    st.session_state.md_outline = {}  # 📑 Store markdown outlines
 
-def save_to_file(data, filename):
-    """🌈 Rainbow file saver - spreading joy through data persistence!"""
+# 🎯 Supported file types and their handlers
+FILE_TYPES = {
+    "md": "📝 Markdown",
+    "txt": "📄 Text",
+    "json": "🔧 JSON",
+    "csv": "📊 CSV",
+    "xlsx": "📗 Excel",
+    "yaml": "⚙️ YAML",
+    "xml": "🔗 XML"
+}
+
+def parse_markdown_outline(content):
+    """📑 Generate a cute outline from markdown!"""
+    lines = content.split('\n')
+    outline = []
+    for line in lines:
+        if line.strip().startswith('#'):
+            level = len(line.split()[0])  # Count #'s
+            title = line.strip('#').strip()
+            outline.append({
+                'level': level,
+                'title': title,
+                'indent': '    ' * (level - 1)
+            })
+    return outline
+
+def read_file_content(uploaded_file):
+    """📚 Smart file reader with type detection!"""
+    file_type = uploaded_file.name.split('.')[-1].lower()
+    try:
+        if file_type == 'md':
+            content = uploaded_file.getvalue().decode()
+            st.session_state.md_outline[uploaded_file.name] = parse_markdown_outline(content)
+            return content, "md"
+            
+        elif file_type == 'csv':
+            df = pd.read_csv(uploaded_file)
+            return df.to_string(), "csv"
+            
+        elif file_type == 'xlsx':
+            df = pd.read_excel(uploaded_file)
+            return df.to_string(), "xlsx"
+            
+        elif file_type == 'json':
+            content = json.load(uploaded_file)
+            return json.dumps(content, indent=2), "json"
+            
+        elif file_type == 'yaml':
+            content = yaml.safe_load(uploaded_file)
+            return yaml.dump(content), "yaml"
+            
+        else:  # Default text handling
+            return uploaded_file.getvalue().decode(), "txt"
+            
+    except Exception as e:
+        st.error(f"🚨 Oops! Error reading {uploaded_file.name}: {str(e)}")
+        return None, None
+
+def save_file_content(content, filename, file_type):
+    """💾 Smart file saver with type handling!"""
     try:
-        with open(filename, 'w') as f:
-            json.dump(data, f)
+        if file_type == "md":
+            with open(filename, 'w') as f:
+                f.write(content)
+                
+        elif file_type in ["csv", "xlsx"]:
+            # Convert string back to DataFrame
+            df = pd.read_csv(StringIO(content)) if file_type == "csv" else pd.read_excel(StringIO(content))
+            if file_type == "csv":
+                df.to_csv(filename, index=False)
+            else:
+                df.to_excel(filename, index=False)
+                
+        elif file_type == "json":
+            with open(filename, 'w') as f:
+                json.dump(json.loads(content), f, indent=2)
+                
+        elif file_type == "yaml":
+            with open(filename, 'w') as f:
+                yaml.dump(yaml.safe_load(content), f)
+                
+        else:  # Default text handling
+            with open(filename, 'w') as f:
+                f.write(content)
+                
         return True
     except Exception as e:
-        st.error(f"Oopsie! 🙈 Couldn't save to {filename}: {str(e)}")
+        st.error(f"🚨 Error saving {filename}: {str(e)}")
         return False
 
-def load_from_file(filename):
-    """🎀 Pretty file loader - bringing your data back with style!"""
-    try:
-        with open(filename, 'r') as f:
-            return json.load(f)
-    except FileNotFoundError:
-        st.info(f"✨ New adventure! No previous data found in {filename}")
-        return {}
-    except json.JSONDecodeError:
-        st.warning(f"🎭 Hmm, the file {filename} contains invalid JSON. Starting fresh!")
-        return {}
+def show_markdown_preview(content):
+    """👀 Show pretty markdown preview!"""
+    st.markdown("### 👀 Markdown Preview")
+    st.markdown(content)
+
+def show_markdown_outline(filename):
+    """📑 Display pretty markdown outline!"""
+    if filename in st.session_state.md_outline:
+        st.markdown("### 📑 Document Outline")
+        for item in st.session_state.md_outline[filename]:
+            st.markdown(f"{item['indent']}• {item['title']}")
 
 def main():
-    st.title("🎉 Super Fun File Handler!")
+    st.title("📚✨ Super Smart File Handler with Markdown Magic! ✨📚")
     
-    # 🎨 Pretty file upload section
-    uploaded_file = st.file_uploader("Upload your happy little file!", type=['txt', 'json'])
+    # 📁 Enhanced file upload with type support
+    uploaded_file = st.file_uploader(
+        "📤 Upload your file!", 
+        type=list(FILE_TYPES.keys()),
+        help="Supports: " + ", ".join([f"{v} (.{k})" for k, v in FILE_TYPES.items()])
+    )
     
     if uploaded_file:
-        # 🎪 Process the uploaded file with circus-level excitement!
-        content = uploaded_file.getvalue().decode()
-        st.session_state.file_data[uploaded_file.name] = content
-        st.success(f"🌟 Woohoo! Successfully loaded {uploaded_file.name}")
+        content, file_type = read_file_content(uploaded_file)
+        if content is not None:
+            st.session_state.file_data[uploaded_file.name] = content
+            st.session_state.file_types[uploaded_file.name] = file_type
+            st.success(f"🎉 Loaded {FILE_TYPES.get(file_type, '📄')} file: {uploaded_file.name}")
+            
+            # 📝 Special handling for markdown files
+            if file_type == "md":
+                show_markdown_preview(content)
+                show_markdown_outline(uploaded_file.name)
     
-    # 🎠 Display our magical collection of files
+    # 📂 File Display and Editing
     if st.session_state.file_data:
-        st.subheader("🗂️ Your Wonderful Files:")
+        st.subheader("📂 Your Files")
         for filename, content in st.session_state.file_data.items():
-            with st.expander(f"📁 {filename}"):
-                st.text_area("Content", content, height=150, key=filename)
+            file_type = st.session_state.file_types[filename]
+            with st.expander(f"{FILE_TYPES.get(file_type, '📄')} {filename}"):
+                edited_content = st.text_area(
+                    "Content",
+                    content,
+                    height=300,
+                    key=f"edit_{filename}"
+                )
                 
-                if st.button(f"💾 Save changes to {filename}"):
-                    updated_content = st.session_state[filename]
-                    if save_to_file(updated_content, filename):
-                        st.success(f"🎉 Yay! Saved {filename} successfully!")
-    
-    # 🎪 System prompt section
-    st.subheader("🤖 Super Smart System Prompt Generator")
-    if st.session_state.file_data:
-        selected_files = st.multiselect(
-            "Select files for your prompt",
-            list(st.session_state.file_data.keys())
-        )
-        
-        if selected_files:
-            prompt = "Here are the contents of the selected files:\n\n"
-            for file in selected_files:
-                prompt += f"File: {file}\n```\n{st.session_state.file_data[file]}\n```\n\n"
-            
-            st.text_area("Generated Prompt", prompt, height=300)
+                if edited_content != content:
+                    st.session_state.file_data[filename] = edited_content
+                    if file_type == "md":
+                        st.session_state.md_outline[filename] = parse_markdown_outline(edited_content)
+                        show_markdown_preview(edited_content)
+                        show_markdown_outline(filename)
+                
+                if st.button(f"💾 Save {filename}"):
+                    if save_file_content(edited_content, filename, file_type):
+                        st.success(f"✨ Saved {filename} successfully!")
 
 if __name__ == "__main__":
     main()