Create app-backup3.py

app-backup3.py

@@ -0,0 +1,584 @@
+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 yaml
+from io import StringIO
+import openpyxl
+import csv
+import base64
+import glob
+import os
+
+# Add this function after the imports and before other functions
+def scan_and_load_files():
+    """🔍 File Detective - Scans directory for supported files and loads them automatically"""
+    loaded_files = []
+    
+    # Get all files with supported extensions
+    for ext in FILE_TYPES.keys():
+        files = glob.glob(f"*.{ext}")
+        for filepath in files:
+            try:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                    file_type = filepath.split('.')[-1].lower()
+                    
+                    # Store file content and type
+                    st.session_state.file_data[filepath] = content
+                    st.session_state.file_types[filepath] = file_type
+                    
+                    # Special handling for markdown files
+                    if file_type == 'md':
+                        st.session_state.md_outline[filepath] = parse_markdown_outline(content)
+                        st.session_state.rendered_content[filepath] = content
+                        
+                        # Add to markdown files history if not already present
+                        if filepath not in [f["filename"] for f in st.session_state.md_files_history]:
+                            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                            encoded_content = encode_content(content)
+                            st.session_state.md_files_history.append({
+                                "filename": filepath,
+                                "timestamp": timestamp,
+                                "content": encoded_content
+                            })
+                            
+                            # Create initial version history
+                            if filepath not in st.session_state.md_versions:
+                                st.session_state.md_versions[filepath] = []
+                            st.session_state.md_versions[filepath].append({
+                                "timestamp": timestamp,
+                                "content": encoded_content,
+                                "action": "auto-loaded"
+                            })
+                    
+                    loaded_files.append(filepath)
+            except Exception as e:
+                st.error(f"🚨 Error loading {filepath}: {str(e)}")
+    
+    # Update combined markdown after loading all files
+    if loaded_files:
+        st.session_state.combined_markdown = combine_markdown_files()
+    
+    return loaded_files
+
+
+
+
+# Modify the main function to include initial file scanning
+def main():
+
+    # Add a reset button in sidebar
+    if st.sidebar.button("🔄 Reset & Rescan Files"):
+        # Clear all session state
+        for key in list(st.session_state.keys()):
+            del st.session_state[key]
+        st.experimental_rerun()
+
+    st.title("📚✨ Super Smart File Handler with Markdown Magic! ✨📚")
+    
+    # Initialize session state
+    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 = {}
+    if 'md_outline' not in st.session_state:
+        st.session_state.md_outline = {}
+    if 'rendered_content' not in st.session_state:
+        st.session_state.rendered_content = {}
+    if 'file_history' not in st.session_state:
+        st.session_state.file_history = []
+    if 'md_versions' not in st.session_state:
+        st.session_state.md_versions = {}
+    if 'md_files_history' not in st.session_state:
+        st.session_state.md_files_history = []
+    if 'combined_markdown' not in st.session_state:
+        st.session_state.combined_markdown = ""
+    
+    # Scan for existing files on startup
+    if 'files_scanned' not in st.session_state:
+        loaded_files = scan_and_load_files()
+        if loaded_files:
+            st.success(f"🎉 Auto-loaded {len(loaded_files)} existing files: {', '.join(loaded_files)}")
+        st.session_state.files_scanned = True
+
+        
+    st.title("📚✨ Super Smart File Handler with Markdown Magic! ✨📚")
+    
+    # Scan for existing files on startup
+    if 'files_scanned' not in st.session_state:
+        loaded_files = scan_and_load_files()
+        if loaded_files:
+            st.success(f"🎉 Auto-loaded {len(loaded_files)} existing files: {', '.join(loaded_files)}")
+        st.session_state.files_scanned = True
+    
+    # Show markdown history in sidebar
+    show_sidebar_history()
+    
+    # Add tabs for different upload methods
+    upload_tab, book_tab = st.tabs(["📤 File Upload", "📖 Book View"])
+    
+    with upload_tab:
+        # Add a rescan button
+        if st.button("🔄 Rescan Directory"):
+            st.session_state.files_scanned = False
+            st.experimental_rerun()
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            single_uploaded_file = st.file_uploader(
+                "📤 Upload single file", 
+                type=list(FILE_TYPES.keys()),
+                help="Supports: " + ", ".join([f"{v} (.{k})" for k, v in FILE_TYPES.items()]),
+                key="single_uploader"
+            )
+        
+        with col2:
+            multiple_uploaded_files = st.file_uploader(
+                "📚 Upload multiple files",
+                type=list(FILE_TYPES.keys()),
+                accept_multiple_files=True,
+                help="Upload multiple files to view as a book",
+                key="multiple_uploader"
+            )
+        
+        # Process single file upload
+        if single_uploaded_file:
+            content, file_type = read_file_content(single_uploaded_file)
+            if content is not None:
+                st.session_state.file_data[single_uploaded_file.name] = content
+                st.session_state.file_types[single_uploaded_file.name] = file_type
+                st.success(f"🎉 Loaded {FILE_TYPES.get(file_type, '📄')} file: {single_uploaded_file.name}")
+        
+        # Process multiple file upload
+        if multiple_uploaded_files:
+            for uploaded_file in multiple_uploaded_files:
+                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 {len(multiple_uploaded_files)} files")
+        
+        # Show file history
+        show_file_history()
+        
+        # Show individual files
+        if st.session_state.file_data:
+            st.subheader("📂 Your Files")
+            for filename, content in st.session_state.file_data.items():
+                file_type = st.session_state.file_types[filename]
+                with st.expander(f"{FILE_TYPES.get(file_type, '📄')} {filename}"):
+                    if file_type == "md":
+                        content = create_markdown_tabs(content, filename)
+                    else:
+                        edited_content = st.text_area(
+                            "Content",
+                            content,
+                            height=300,
+                            key=f"edit_{filename}"
+                        )
+                        if edited_content != content:
+                            st.session_state.file_data[filename] = edited_content
+                            content = edited_content
+                    
+                    if st.button(f"💾 Save {filename}"):
+                        if save_file_content(content, filename, file_type):
+                            st.success(f"✨ Saved {filename} successfully!")
+    
+    with book_tab:
+        show_book_view()
+
+# 🎨 File type emojis - Making file types fun and visual!
+FILE_TYPES = {
+    "md": "📝 Markdown",
+    "txt": "📄 Text",
+    "json": "🔧 JSON",
+    "csv": "📊 CSV",
+    "xlsx": "📗 Excel",
+    "yaml": "⚙️ YAML",
+    "xml": "🔗 XML"
+}
+
+# 🧠 Brain initialization - Setting up our app's memory!
+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 = {}
+if 'md_outline' not in st.session_state:
+    st.session_state.md_outline = {}
+if 'rendered_content' not in st.session_state:
+    st.session_state.rendered_content = {}
+if 'file_history' not in st.session_state:
+    st.session_state.file_history = []
+if 'md_versions' not in st.session_state:
+    st.session_state.md_versions = {}
+if 'md_files_history' not in st.session_state:
+    st.session_state.md_files_history = []
+if 'combined_markdown' not in st.session_state:
+    st.session_state.combined_markdown = ""
+
+# 🧹 Clean Sweep! - Decluttering our markdown files
+def delete_all_md_files():
+    """Delete all markdown files except README.md"""
+    files_to_remove = [
+        f for f in st.session_state.md_files_history 
+        if f["filename"] != "README.md"
+    ]
+    for file in files_to_remove:
+        filename = file["filename"]
+        if filename in st.session_state.file_data:
+            del st.session_state.file_data[filename]
+        if filename in st.session_state.file_types:
+            del st.session_state.file_types[filename]
+        if filename in st.session_state.md_outline:
+            del st.session_state.md_outline[filename]
+        if filename in st.session_state.rendered_content:
+            del st.session_state.rendered_content[filename]
+        if filename in st.session_state.md_versions:
+            del st.session_state.md_versions[filename]
+    
+    st.session_state.md_files_history = [
+        f for f in st.session_state.md_files_history 
+        if f["filename"] == "README.md"
+    ]
+    st.session_state.combined_markdown = ""
+    return len(files_to_remove)
+
+# 🎁 Download Gift Wrapper - Making files downloadable with style!
+def get_binary_file_downloader_html(bin_file, file_label='File'):
+    """Generate a link allowing the data in a given file to be downloaded"""
+    b64 = base64.b64encode(bin_file.encode()).decode()
+    return f'<a href="data:text/plain;base64,{b64}" download="{file_label}">📥 Download {file_label}</a>'
+
+# 🔐 Secret Keeper - Encoding our content safely
+def encode_content(content):
+    """Encode content to base64"""
+    return base64.b64encode(content.encode()).decode()
+
+# 🔓 Mystery Solver - Decoding our secret content
+def decode_content(encoded_content):
+    """Decode content from base64"""
+    return base64.b64decode(encoded_content.encode()).decode()
+
+# 📚 Book Maker - Combining markdown files into a beautiful book
+def combine_markdown_files():
+    """Combine all markdown files into a single document"""
+    combined = []
+    for md_file in sorted(st.session_state.md_files_history, key=lambda x: x["filename"]):
+        content = decode_content(md_file["content"])
+        combined.append(f"# {md_file['filename']}\n\n{content}\n\n---\n\n")
+    return "".join(combined)
+
+# 📝 History Scribe - Recording every file action with precision
+def add_to_history(filename, content, action="uploaded"):
+    """Add a file action to the history with timestamp"""
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    encoded_content = encode_content(content)
+    history_entry = {
+        "timestamp": timestamp,
+        "filename": filename,
+        "action": action,
+        "content": encoded_content
+    }
+    st.session_state.file_history.insert(0, history_entry)
+    
+    if filename.endswith('.md'):
+        if filename not in st.session_state.md_versions:
+            st.session_state.md_versions[filename] = []
+        st.session_state.md_versions[filename].append({
+            "timestamp": timestamp,
+            "content": encoded_content,
+            "action": action
+        })
+        
+        if filename not in [f["filename"] for f in st.session_state.md_files_history]:
+            st.session_state.md_files_history.append({
+                "filename": filename,
+                "timestamp": timestamp,
+                "content": encoded_content
+            })
+        
+        st.session_state.combined_markdown = combine_markdown_files()
+
+# 📚 Shelf Display - Showing our markdown collection in the sidebar
+def show_sidebar_history():
+    """Display markdown file history in the sidebar"""
+    st.sidebar.markdown("### 📚 Markdown Files History")
+    
+    if st.sidebar.button("🧹 Delete All (except README.md)"):
+        deleted_count = delete_all_md_files()
+        st.sidebar.success(f"Deleted {deleted_count} markdown files")
+        st.rerun()
+    
+    for md_file in st.session_state.md_files_history:
+        col1, col2, col3 = st.sidebar.columns([2, 1, 1])
+        
+        with col1:
+            st.markdown(f"**{md_file['filename']}**")
+        
+        with col2:
+            if st.button("📂 Open", key=f"open_{md_file['filename']}"):
+                content = decode_content(md_file['content'])
+                st.session_state.file_data[md_file['filename']] = content
+                st.session_state.file_types[md_file['filename']] = "md"
+                st.session_state.md_outline[md_file['filename']] = parse_markdown_outline(content)
+                st.rerun()
+        
+        with col3:
+            download_link = get_binary_file_downloader_html(
+                decode_content(md_file['content']), 
+                md_file['filename']
+            )
+            st.markdown(download_link, unsafe_allow_html=True)
+
+# 📖 Book Display - Showing our combined markdown masterpiece
+def show_book_view():
+    """Display all markdown files in a book-like format"""
+    if st.session_state.combined_markdown:
+        st.markdown("## 📖 Book View")
+        st.markdown(st.session_state.combined_markdown)
+
+# 📋 Time Traveler - Showing our file's journey through time
+def show_file_history():
+    """Display the file history in a collapsible section"""
+    if st.session_state.file_history:
+        with st.expander("📋 File History", expanded=False):
+            st.markdown("### Recent File Activities")
+            for entry in st.session_state.file_history:
+                col1, col2 = st.columns([2, 3])
+                with col1:
+                    st.markdown(f"**{entry['timestamp']}**")
+                with col2:
+                    st.markdown(f"{entry['action'].title()}: {entry['filename']}")
+
+# ⏰ Time Machine - Exploring previous versions of our files
+def show_markdown_versions(filename):
+    """Display previous versions of a markdown file"""
+    if filename in st.session_state.md_versions:
+        versions = st.session_state.md_versions[filename]
+        if len(versions) > 1:
+            st.markdown("### �� Previous Versions")
+            version_idx = st.selectbox(
+                "Select version to view",
+                range(len(versions)-1),
+                format_func=lambda x: f"Version {len(versions)-1-x} - {versions[x]['timestamp']}"
+            )
+            
+            if version_idx is not None:
+                version = versions[version_idx]
+                decoded_content = decode_content(version['content'])
+                st.text_area(
+                    "Content",
+                    decoded_content,
+                    height=200,
+                    key=f"version_{filename}_{version_idx}",
+                    disabled=True
+                )
+                if st.button(f"Restore to this version", key=f"restore_{filename}_{version_idx}"):
+                    st.session_state.file_data[filename] = decoded_content
+                    st.session_state.md_outline[filename] = parse_markdown_outline(decoded_content)
+                    add_to_history(filename, decoded_content, "restored")
+                    st.rerun()
+
+# 🗺️ Map Maker - Creating a beautiful outline of our markdown
+def parse_markdown_outline(content):
+    """Generate an outline from markdown content"""
+    lines = content.split('\n')
+    outline = []
+    for line in lines:
+        if line.strip().startswith('#'):
+            level = len(line.split()[0])
+            title = line.strip('#').strip()
+            outline.append({
+                'level': level,
+                'title': title,
+                'indent': '    ' * (level - 1)
+            })
+    return outline
+
+# 📑 Tab Master - Creating beautiful tabs for our markdown content
+def create_markdown_tabs(content, filename):
+    """Create tabs for markdown content viewing and editing"""
+    tab1, tab2, tab3 = st.tabs(["📝 Editor", "👀 Preview", "🕒 History"])
+    
+    with tab1:
+        edited_content = st.text_area(
+            "Edit your markdown",
+            content,
+            height=300,
+            key=f"edit_{filename}"
+        )
+        
+        if edited_content != content:
+            st.session_state.file_data[filename] = edited_content
+            st.session_state.md_outline[filename] = parse_markdown_outline(edited_content)
+            add_to_history(filename, edited_content, "edited")
+            content = edited_content
+    
+    with tab2:
+        st.markdown("### Preview")
+        st.markdown(content)
+        
+        if filename in st.session_state.md_outline:
+            st.markdown("---")
+            st.markdown("### 📑 Document Outline")
+            for item in st.session_state.md_outline[filename]:
+                st.markdown(f"{item['indent']}• {item['title']}")
+    
+    with tab3:
+        show_markdown_versions(filename)
+    
+    return content
+
+# 📤 File Reader - Smart file reading with a smile!
+def read_file_content(uploaded_file):
+    """Smart file reader with enhanced markdown handling"""
+    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)
+            st.session_state.rendered_content[uploaded_file.name] = content
+            add_to_history(uploaded_file.name, 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
+
+# 💾 File Saver - Keeping our files safe and sound
+def save_file_content(content, filename, file_type):
+    """Smart file saver with enhanced markdown handling"""
+    try:
+        if file_type == "md":
+            with open(filename, 'w') as f:
+                f.write(content)
+                st.session_state.rendered_content[filename] = content
+                add_to_history(filename, content, "saved")
+                
+        elif file_type in ["csv", "xlsx"]:
+            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"🚨 Error saving {filename}: {str(e)}")
+        return False
+
+# 🎭 Main Show - Where the magic happens!
+def main():
+    st.title("📚✨ Super Smart File Handler with Markdown Magic! ✨📚")
+    
+    # Show markdown history in sidebar
+    show_sidebar_history()
+    
+    # Add tabs for different upload methods
+    upload_tab, book_tab = st.tabs(["📤 File Upload", "📖 Book View"])
+    
+    with upload_tab:
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            single_uploaded_file = st.file_uploader(
+                "📤 Upload single file", 
+                type=list(FILE_TYPES.keys()),
+                help="Supports: " + ", ".join([f"{v} (.{k})" for k, v in FILE_TYPES.items()]),
+                key="single_uploader"
+            )
+        
+        with col2:
+            multiple_uploaded_files = st.file_uploader(
+                "📚 Upload multiple files",
+                type=list(FILE_TYPES.keys()),
+                accept_multiple_files=True,
+                help="Upload multiple files to view as a book",
+                key="multiple_uploader"
+            )
+        
+        # Process single file upload
+        if single_uploaded_file:
+            content, file_type = read_file_content(single_uploaded_file)
+            if content is not None:
+                st.session_state.file_data[single_uploaded_file.name] = content
+                st.session_state.file_types[single_uploaded_file.name] = file_type
+                st.success(f"🎉 Loaded {FILE_TYPES.get(file_type, '📄')} file: {single_uploaded_file.name}")
+        
+        # Process multiple file upload
+        if multiple_uploaded_files:
+            for uploaded_file in multiple_uploaded_files:
+                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 {len(multiple_uploaded_files)} files")
+        
+        # Show file history
+        show_file_history()
+        
+        # Show individual files
+        if st.session_state.file_data:
+            st.subheader("📂 Your Files")
+            for filename, content in st.session_state.file_data.items():
+                file_type = st.session_state.file_types[filename]
+                with st.expander(f"{FILE_TYPES.get(file_type, '📄')} {filename}"):
+                    if file_type == "md":
+                        content = create_markdown_tabs(content, filename)
+                    else:
+                        edited_content = st.text_area(
+                            "Content",
+                            content,
+                            height=300,
+                            key=f"edit_{filename}"
+                        )
+                        if edited_content != content:
+                            st.session_state.file_data[filename] = edited_content
+                            content = edited_content
+                    
+                    if st.button(f"💾 Save {filename}"):
+                        if save_file_content(content, filename, file_type):
+                            st.success(f"✨ Saved {filename} successfully!")
+    
+    with book_tab:
+        show_book_view()
+
+if __name__ == "__main__":
+    main()