app.py

import streamlit as st
import anthropic
import os
import base64
import glob
import json
import pytz
from datetime import datetime
from streamlit.components.v1 import html
from PIL import Image
import re
from urllib.parse import quote

# 1. App Configuration
Site_Name = '🤖🧠Claude35📝🔬'
title="🤖🧠Claude35📝🔬"
helpURL='https://huggingface.co/awacke1'
bugURL='https://huggingface.co/spaces/awacke1'
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
    }
)

# Set up the Anthropic client
client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))

# Initialize session state
if "chat_history" not in st.session_state:
    st.session_state.chat_history = []

# Helper Functions: All Your Essentials 🚀

# Function to get a file download link (because you deserve easy downloads 😎)
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>'

# Function to generate a filename based on prompt and time (because names matter 🕒)
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}"

# Function to create and save a file (and avoid the black hole of lost data 🕳)
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)

# Function to load file content (for revisiting the past 📜)
def load_file(file_name):
    with open(file_name, "r", encoding='utf-8') as file:
        content = file.read()
    return content

# Function to display handy glossary entity links (search like a pro 🔍)
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"[{emoji}]({url(k)})" for emoji, url in search_urls.items()])
    st.markdown(f"**{k}** <small>{links_md}</small>", unsafe_allow_html=True)

# Function to create zip of files (because more is more 🧳)
def create_zip_of_files(files):
    import zipfile
    zip_name = "all_files.zip"
    with zipfile.ZipFile(zip_name, 'w') as zipf:
        for file in files:
            zipf.write(file)
    return zip_name

# 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>
    '''

# 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>
    '''


# Streamlit App Layout (like a house with better flow 🏡)
def main():
    
    # Sidebar with Useful Controls (All the VIP actions 🎛)
    st.sidebar.title("🧠Claude📝")
    
    all_files = glob.glob("*.md")
    all_files.sort(reverse=True)

    if st.sidebar.button("🗑 Delete All"):
        for file in all_files:
            os.remove(file)
        st.rerun()

    if st.sidebar.button("⬇️ Download All"):
        zip_file = create_zip_of_files(all_files)
        st.sidebar.markdown(get_download_link(zip_file), unsafe_allow_html=True)

    for file in all_files:
        col1, col2, col3, col4 = st.sidebar.columns([1,3,1,1])
        with col1:
            if st.button("🌐", key="view_"+file):
                st.session_state.current_file = file
                st.session_state.file_content = load_file(file)
        with col2:
            st.markdown(get_download_link(file), unsafe_allow_html=True)
        with col3:
            if st.button("📂", key="edit_"+file):
                st.session_state.current_file = file
                st.session_state.file_content = load_file(file)
        with col4:
            if st.button("🗑", key="delete_"+file):
                os.remove(file)
                st.rerun()

    # Main Area: Chat with Claude (He’s a good listener 💬)
    user_input = st.text_area("Message 📨:", height=100)
    
    if st.button("Send 📨"):
        if user_input:
            response = client.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})

    # Display Chat History (Never forget a good chat 💭)
    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 (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])

if __name__ == "__main__":
    main()