Update app.py

app.py

@@ -1,215 +1,381 @@
-import streamlit as st
-import anthropic
 import os
+import random
+import uuid
 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
-    }
-)
+import gradio as gr
+import numpy as np
+from PIL import Image
+import torch
+import glob
+from datetime import datetime
+import pandas as pd
+import anthropic
+import pytz
 
-# Set up the Anthropic client
-client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
+from diffusers import StableDiffusionXLPipeline, EulerAncestralDiscreteScheduler
 
-# Initialize session state
-if "chat_history" not in st.session_state:
-    st.session_state.chat_history = []
+DESCRIPTION = """# 🎨 ArtForge + Claude Chat
+Create, curate, and compete with AI-generated art. Chat with Claude. Manage quotes. Track logs. Enjoy!
+"""
 
-# Helper Functions: All Your Essentials 🚀
+# ------------------ Global Files & Constants ------------------ #
+LIKES_CACHE_FILE = "likes_cache.json"
+LOG_CACHE_FILE = "log_cache.json"
+QUOTE_CACHE_FILE = "quotes_cache.json"
 
-# 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>'
+# For serving static content:
+URL_PREFIX = "https://huggingface.co/spaces/awacke1/dalle-3-xl-lora-v2/file="
 
-# 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)}",
+# ------------------ Load/Save Helpers ------------------ #
+def load_json(file):
+    if os.path.exists(file):
+        with open(file, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    return {}
+
+def save_json(file, data):
+    with open(file, 'w', encoding='utf-8') as f:
+        json.dump(data, f, indent=4)
+
+likes_cache = load_json(LIKES_CACHE_FILE) or {}
+all_logs = load_json(LOG_CACHE_FILE) if os.path.exists(LOG_CACHE_FILE) else []
+quotes_cache = load_json(QUOTE_CACHE_FILE) if os.path.exists(QUOTE_CACHE_FILE) else []
+
+# Image metadata
+image_metadata = pd.DataFrame(columns=['Filename', 'Prompt', 'Likes', 'Dislikes', 'Hearts', 'Created'])
+
+# ---------- Anthropic (Claude) Setup (optional) ---------- #
+anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY", None)
+claude_client = anthropic.Anthropic(api_key=anthropic_api_key) if anthropic_api_key else None
+
+# ------------------ Logging of Inputs/Outputs ------------------ #
+def log_input_output(user_input, model_output, file_link=""):
+    global all_logs
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    new_entry = {
+        "timestamp": timestamp,
+        "input": user_input,
+        "output": model_output,
+        "file_link": file_link
     }
-    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:
+    all_logs.append(new_entry)
+    save_json(LOG_CACHE_FILE, all_logs)
+
+# ------------------ Votes & Images ------------------ #
+def load_likes_cache():
+    return likes_cache
+
+def save_likes_cache():
+    save_json(LIKES_CACHE_FILE, likes_cache)
+
+def get_image_caption(filename):
+    global likes_cache, image_metadata
+    if filename in likes_cache:
+        likes = likes_cache[filename]['likes']
+        dislikes = likes_cache[filename]['dislikes']
+        hearts = likes_cache[filename]['hearts']
+        row = image_metadata.loc[image_metadata['Filename'] == filename]
+        if not row.empty:
+            prompt = row.iloc[0]['Prompt']
+            return f"{filename}\nPrompt: {prompt}\n👍 {likes} 👎 {dislikes} ❤️ {hearts}"
+    return filename
+
+def get_image_gallery():
+    global image_metadata
+    image_files = image_metadata['Filename'].tolist()
+    return [
+        (file, get_image_caption(file)) 
+        for file in image_files if os.path.exists(file)
+    ]
+
+def delete_all_images():
+    global image_metadata, likes_cache
+    for file in image_metadata['Filename']:
+        if os.path.exists(file):
             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}
-                ]
+    image_metadata = pd.DataFrame(columns=['Filename','Prompt','Likes','Dislikes','Hearts','Created'])
+    likes_cache.clear()
+    save_likes_cache()
+    return get_image_gallery(), image_metadata.values.tolist()
+
+def delete_image(filename):
+    global image_metadata, likes_cache
+    if filename and os.path.exists(filename):
+        os.remove(filename)
+        image_metadata = image_metadata[image_metadata['Filename'] != filename]
+        if filename in likes_cache:
+            del likes_cache[filename]
+            save_likes_cache()
+    return get_image_gallery(), image_metadata.values.tolist()
+
+def vote(filename, vote_type):
+    global likes_cache, image_metadata
+    if filename in likes_cache:
+        likes_cache[filename][vote_type.lower()] += 1
+        save_likes_cache()
+        # Reflect in dataframe
+        row_idx = image_metadata[image_metadata['Filename'] == filename].index
+        if not row_idx.empty:
+            col = vote_type.capitalize()
+            curr_val = image_metadata.at[row_idx[0], col]
+            image_metadata.at[row_idx[0], col] = curr_val + 1
+    return get_image_gallery(), image_metadata.values.tolist()
+
+# ------------------ Image Generation (Original Code) ------------------ #
+MAX_SEED = np.iinfo(np.int32).max
+if not torch.cuda.is_available():
+    DESCRIPTION += "\n<p>Running on CPU 🥶 This demo may not work on CPU.</p>"
+
+# Load pipeline
+if torch.cuda.is_available():
+    pipe = StableDiffusionXLPipeline.from_pretrained(
+        "fluently/Fluently-XL-v4",
+        torch_dtype=torch.float16,
+        use_safetensors=True,
+    )
+    pipe.scheduler = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)
+    pipe.load_lora_weights("ehristoforu/dalle-3-xl-v2", weight_name="dalle-3-xl-lora-v2.safetensors", adapter_name="dalle")
+    pipe.set_adapters("dalle")
+    pipe.to("cuda")
+else:
+    pipe = None
+
+def randomize_seed_fn(seed: int, randomize_seed: bool):
+    if randomize_seed:
+        seed = random.randint(0, MAX_SEED)
+    return seed
+
+def save_image(img, prompt):
+    global image_metadata, likes_cache
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    safe_prompt = re.sub(r'[^\w\s-]', '', prompt.lower())[:50]
+    safe_prompt = re.sub(r'[-\s]+', '-', safe_prompt).strip('-')
+    filename = f"{timestamp}_{safe_prompt}.png"
+    img.save(filename)
+    # Add metadata row
+    new_row = {
+        'Filename': filename,
+        'Prompt': prompt,
+        'Likes': 0,
+        'Dislikes': 0,
+        'Hearts': 0,
+        'Created': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+    image_metadata.loc[len(image_metadata)] = new_row
+    likes_cache[filename] = {'likes': 0, 'dislikes': 0, 'hearts': 0}
+    save_likes_cache()
+    return filename
+
+def generate(
+    prompt: str,
+    negative_prompt: str = "",
+    use_negative_prompt: bool = False,
+    seed: int = 0,
+    width: int = 1024,
+    height: int = 1024,
+    guidance_scale: float = 3,
+    randomize_seed: bool = False,
+    progress=gr.Progress(track_tqdm=True),
+):
+    if pipe is None:
+        return ["Error: No GPU or pipeline not loaded"], 0, [], get_image_gallery(), image_metadata.values.tolist()
+
+    seed = randomize_seed_fn(seed, randomize_seed)
+    if not use_negative_prompt:
+        negative_prompt = ""
+
+    images = pipe(
+        prompt=prompt,
+        negative_prompt=negative_prompt,
+        width=width,
+        height=height,
+        guidance_scale=guidance_scale,
+        num_inference_steps=20,
+        num_images_per_prompt=1,
+        cross_attention_kwargs={"scale": 0.65},
+        output_type="pil",
+    ).images
+
+    image_paths = [save_image(img, prompt) for img in images]
+    # Build static-content file links
+    file_links = [f"{URL_PREFIX}{p}" for p in image_paths]
+
+    # Log this generation
+    log_input_output(user_input=prompt, model_output="(image generated)", file_link=", ".join(file_links))
+
+    return image_paths, seed, file_links, get_image_gallery(), image_metadata.values.tolist()
+
+# Some example prompts
+def get_random_style():
+    styles = [
+        "Impressionist", "Cubist", "Surrealist", "Abstract Expressionist",
+        "Pop Art", "Minimalist", "Baroque", "Art Nouveau", "Pointillist", "Fauvism"
+    ]
+    return random.choice(styles)
+
+examples = [
+    f"{get_random_style()} painting of a majestic lighthouse...",
+    f"{get_random_style()} still life with a pair of vintage eyeglasses...",
+    f"{get_random_style()} depiction of a rustic wooden stool...",
+]
+
+# ------------------ Claude Chat (Added from Streamlit) ------------------ #
+def chat_claude(user_input: str):
+    if not claude_client:
+        # If no API key or no client
+        return "Claude not available. Set ANTHROPIC_API_KEY."
+    if not user_input.strip():
+        return "No input provided."
+
+    response = claude_client.messages.create(
+        model="claude-3-sonnet-20240229",
+        max_tokens=1000,
+        messages=[{"role": "user", "content": user_input}]
+    )
+    text = response.content[0].text
+    log_input_output(user_input, text, "")
+    return text
+
+# ------------------ Quotes Feature (Short Version) ------------------ #
+def get_quotes_df():
+    return pd.DataFrame(quotes_cache) if quotes_cache else pd.DataFrame(columns=["text", "likes", "created"])
+
+def add_quote(quote_text):
+    if not quote_text.strip():
+        return get_quotes_df()
+    central = pytz.timezone('US/Central')
+    dt_str = datetime.now(central).strftime("%Y-%m-%d %H:%M:%S")
+    quotes_cache.append({"text": quote_text, "likes": 0, "created": dt_str})
+    save_json(QUOTE_CACHE_FILE, quotes_cache)
+    return get_quotes_df()
+
+def like_quote(index):
+    # index from DataFrame row index
+    if 0 <= index < len(quotes_cache):
+        quotes_cache[index]["likes"] += 1
+        save_json(QUOTE_CACHE_FILE, quotes_cache)
+    return get_quotes_df()
+
+# ------------------ Build Gradio Interface ------------------ #
+css = '''
+.gradio-container{max-width: 1024px !important}
+h1{text-align:center}
+footer {
+visibility: hidden
+}
+'''
+
+with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
+    gr.Markdown(DESCRIPTION)
+
+    with gr.Tab("Generate Images"):
+        with gr.Group():
+            with gr.Row():
+                prompt = gr.Text(
+                    label="Prompt",
+                    show_label=False,
+                    max_lines=1,
+                    placeholder="Enter your prompt",
+                    container=False,
+                )
+                run_button = gr.Button("Run", scale=0)
+            result = gr.Gallery(label="Result", columns=1, preview=True, show_label=False)
+
+        with gr.Accordion("Advanced options", open=False):
+            use_negative_prompt = gr.Checkbox(label="Use negative prompt", value=True)
+            negative_prompt = gr.Text(
+                label="Negative prompt",
+                lines=4,
+                max_lines=6,
+                value="(deformed, distorted, disfigured:1.3), ...",
+                placeholder="Enter negative prompt"
+            )
+            seed = gr.Slider(
+                label="Seed",
+                minimum=0,
+                maximum=MAX_SEED,
+                step=1,
+                value=0
             )
-            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])
+            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
+            with gr.Row():
+                width = gr.Slider(label="Width", minimum=512, maximum=2048, step=8, value=1024)
+                height = gr.Slider(label="Height", minimum=512, maximum=2048, step=8, value=1024)
+            guidance_scale = gr.Slider(label="Guidance Scale", minimum=0.1, maximum=20.0, step=0.1, value=3)
+
+        # Button triggers generate function
+        run_button.click(
+            fn=generate,
+            inputs=[prompt, negative_prompt, use_negative_prompt, seed, width, height, guidance_scale, randomize_seed],
+            outputs=[result, seed, gr.HTML(visible=False), gr.Gallery(), gr.Dataframe()],
+        )
+
+        gr.Examples(
+            examples=examples,
+            inputs=prompt,
+            outputs=[result, seed],
+            fn=generate,
+            cache_examples=False,
+        )
+
+    with gr.Tab("Gallery & Voting"):
+        image_gallery = gr.Gallery(label="Generated Images", show_label=True, columns=4, height="auto")
+        with gr.Row():
+            like_button = gr.Button("👍 Like")
+            dislike_button = gr.Button("👎 Dislike")
+            heart_button = gr.Button("❤️ Heart")
+            delete_image_button = gr.Button("🗑️ Delete Selected Image")
+        selected_image = gr.State(None)
+        metadata_df = gr.Dataframe(
+            label="Image Metadata",
+            headers=["Filename", "Prompt", "Likes", "Dislikes", "Hearts", "Created"],
+            interactive=False
+        )
+        delete_all_button = gr.Button("🗑️ Delete All Images")
+
+        delete_all_button.click(
+            fn=delete_all_images,
+            inputs=[],
+            outputs=[image_gallery, metadata_df],
+        )
+        image_gallery.select(fn=lambda evt: evt, inputs=[], outputs=[selected_image])
+        like_button.click(fn=lambda x: vote(x, 'likes'), inputs=selected_image, outputs=[image_gallery, metadata_df])
+        dislike_button.click(fn=lambda x: vote(x, 'dislikes'), inputs=selected_image, outputs=[image_gallery, metadata_df])
+        heart_button.click(fn=lambda x: vote(x, 'hearts'), inputs=selected_image, outputs=[image_gallery, metadata_df])
+        delete_image_button.click(fn=delete_image, inputs=[selected_image], outputs=[image_gallery, metadata_df])
+
+    with gr.Tab("Chat Claude"):
+        claude_input = gr.Textbox(label="Your message:")
+        claude_output = gr.Textbox(label="Claude's reply:", lines=4)
+        claude_button = gr.Button("Send to Claude")
+        claude_button.click(fn=chat_claude, inputs=claude_input, outputs=claude_output)
+
+    with gr.Tab("Quotes"):
+        with gr.Row():
+            quote_text = gr.Textbox(label="Add a quote:")
+            add_quote_btn = gr.Button("Add Quote")
+        quote_data = gr.Dataframe(headers=["text","likes","created"], interactive=False)
+        with gr.Row():
+            row_index = gr.Number(label="Index to like:")
+            like_btn = gr.Button("Like Quote")
+
+        add_quote_btn.click(fn=add_quote, inputs=quote_text, outputs=quote_data)
+        like_btn.click(fn=like_quote, inputs=row_index, outputs=quote_data)
+
+    with gr.Tab("Logs"):
+        gr.Markdown("#### All logged inputs & outputs")
+        logs_data = gr.Dataframe(
+            label="Log Data",
+            value=pd.DataFrame(all_logs),
+            interactive=False
+        )
+
+    def update_gallery_and_metadata():
+        return gr.update(value=get_image_gallery()), gr.update(value=image_metadata.values.tolist())
+
+    demo.load(fn=update_gallery_and_metadata, outputs=[image_gallery, metadata_df])
 
 if __name__ == "__main__":
-    main()
+    demo.queue(max_size=20).launch(share=True, debug=False)