Update app.py

app.py

@@ -1,191 +1,204 @@
-import anthropic
-import base64
-import json
-import os
-import pandas as pd
-import pytz
-import re
-import streamlit as st
+import gradio as gr
+import random
+import time
 from datetime import datetime
+import tempfile
+import os
+from moviepy.editor import ImageClip, concatenate_videoclips
 from gradio_client import Client
-from azure.cosmos import CosmosClient, exceptions
-
-# App Configuration
-title = "🤖 ArXiv and Claude AI Assistant"
-st.set_page_config(page_title=title, layout="wide")
-
-# Cosmos DB configuration
-ENDPOINT = "https://acae-afd.documents.azure.com:443/"
-Key = os.environ.get("Key")
-DATABASE_NAME = os.environ.get("COSMOS_DATABASE_NAME")
-CONTAINER_NAME = os.environ.get("COSMOS_CONTAINER_NAME")
+from PIL import Image
+import edge_tts
+import asyncio
+import warnings
+import numpy as np
 
-# Initialize Anthropic client
-anthropic_client = anthropic.Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
+warnings.filterwarnings('ignore')
 
-# Initialize session state
-if "chat_history" not in st.session_state:
-    st.session_state.chat_history = []
+# Initialize the Gradio client for model access
+client = Client("stabilityai/stable-diffusion-xl-base-1.0")
+arxiv_client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
 
-def generate_filename(prompt, file_type):
-    """Generate a filename with timestamp and sanitized prompt"""
-    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}"
+STORY_GENRES = [
+    "Science Fiction",
+    "Fantasy",
+    "Mystery",
+    "Romance",
+    "Horror",
+    "Adventure",
+    "Historical Fiction",
+    "Comedy"
+]
 
-def create_file(filename, prompt, response, should_save=True):
-    """Create and save a file with prompt and response"""
-    if not should_save:
-        return
-    with open(filename, 'w', encoding='utf-8') as file:
-        file.write(f"Prompt:\n{prompt}\n\nResponse:\n{response}")
+STORY_STRUCTURES = {
+    "Three Act": "Setup (Introduction, Inciting Incident) -> Confrontation (Rising Action, Climax) -> Resolution (Falling Action, Conclusion)",
+    "Hero's Journey": "Ordinary World -> Call to Adventure -> Trials -> Transformation -> Return",
+    "Five Act": "Exposition -> Rising Action -> Climax -> Falling Action -> Resolution",
+    "Seven Point": "Hook -> Plot Turn 1 -> Pinch Point 1 -> Midpoint -> Pinch Point 2 -> Plot Turn 2 -> Resolution"
+}
 
-def save_to_cosmos_db(container, query, response1, response2):
-    """Save interaction to Cosmos DB"""
+async def generate_speech(text, voice="en-US-AriaNeural"):
+    """Generate speech from text using edge-tts"""
     try:
-        if container:
-            timestamp = datetime.utcnow().strftime('%Y%m%d%H%M%S%f')
-            record = {
-                "id": timestamp,
-                "name": timestamp,
-                "query": query,
-                "response1": response1,
-                "response2": response2,
-                "timestamp": datetime.utcnow().isoformat(),
-                "type": "ai_response",
-                "version": "1.0"
-            }
-            container.create_item(body=record)
-            st.success(f"Record saved to Cosmos DB with ID: {record['id']}")
+        communicate = edge_tts.Communicate(text, voice)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
+            tmp_path = tmp_file.name
+            await communicate.save(tmp_path)
+        return tmp_path
     except Exception as e:
-        st.error(f"Error saving to Cosmos DB: {str(e)}")
+        print(f"Error in text2speech: {str(e)}")
+        raise
 
-def search_arxiv(query):
-    """Search ArXiv using Gradio client"""
+def generate_story_prompt(base_prompt, genre, structure):
+    """Generate an expanded story prompt based on genre and structure"""
+    prompt = f"""Create a {genre} story using this concept: '{base_prompt}'
+    Follow this structure: {STORY_STRUCTURES[structure]}
+    Include vivid descriptions and sensory details.
+    Make it engaging and suitable for visualization.
+    Keep each scene description clear and detailed enough for image generation.
+    Limit the story to 5-7 key scenes.
+    """
+    return prompt
+
+def generate_story(prompt, model_choice):
+    """Generate story using specified model"""
     try:
-        client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
-        
-        # Get response from Mixtral model
-        result_mixtral = client.predict(
-            query,
-            "mistralai/Mixtral-8x7B-Instruct-v0.1",
+        result = arxiv_client.predict(
+            prompt,
+            model_choice,
             True,
             api_name="/ask_llm"
         )
-        
-        # Get response from Mistral model
-        result_mistral = client.predict(
-            query,
-            "mistralai/Mistral-7B-Instruct-v0.2",
-            True,
-            api_name="/ask_llm"
-        )
-        
-        # Get RAG-enhanced response
-        result_rag = client.predict(
-            query,
-            10,  # llm_results_use
-            "Semantic Search",
-            "mistralai/Mistral-7B-Instruct-v0.2",
-            api_name="/update_with_rag_md"
-        )
-        
-        return result_mixtral, result_mistral, result_rag
+        return result
     except Exception as e:
-        st.error(f"Error searching ArXiv: {str(e)}")
-        return None, None, None
-
-def main():
-    st.title(title)
+        return f"Error generating story: {str(e)}"
 
-    # Initialize Cosmos DB client if key is available
-    if Key:
-        cosmos_client = CosmosClient(ENDPOINT, credential=Key)
-        try:
-            database = cosmos_client.get_database_client(DATABASE_NAME)
-            container = database.get_container_client(CONTAINER_NAME)
-        except Exception as e:
-            st.error(f"Error connecting to Cosmos DB: {str(e)}")
-            container = None
-    else:
-        st.warning("Cosmos DB Key not found in environment variables")
-        container = None
+def generate_image_from_text(text_prompt):
+    """Generate an image from text description"""
+    try:
+        result = client.predict(
+            text_prompt,
+            num_inference_steps=30,
+            guidance_scale=7.5,
+            width=768,
+            height=512,
+            api_name="/text2image"
+        )
+        return result
+    except Exception as e:
+        return None
 
-    # Create tabs for different functionalities
-    arxiv_tab, claude_tab, history_tab = st.tabs(["ArXiv Search", "Chat with Claude", "History"])
+def create_video_from_images(image_paths, durations):
+    """Create video from a series of images"""
+    clips = [ImageClip(img_path).set_duration(dur) for img_path, dur in zip(image_paths, durations)]
+    final_clip = concatenate_videoclips(clips, method="compose")
+    output_path = tempfile.mktemp(suffix=".mp4")
+    final_clip.write_videofile(output_path, fps=24)
+    return output_path
 
-    with arxiv_tab:
-        st.header("🔍 ArXiv Search")
-        arxiv_query = st.text_area("Enter your research query:", height=100)
-        if st.button("Search ArXiv"):
-            if arxiv_query:
-                with st.spinner("Searching ArXiv..."):
-                    result_mixtral, result_mistral, result_rag = search_arxiv(arxiv_query)
-                    
-                    if result_mixtral:
-                        st.subheader("Mixtral Model Response")
-                        st.markdown(result_mixtral)
-                        
-                        st.subheader("Mistral Model Response")
-                        st.markdown(result_mistral)
-                        
-                        st.subheader("RAG-Enhanced Response")
-                        if isinstance(result_rag, (list, tuple)) and len(result_rag) > 0:
-                            st.markdown(result_rag[0])
-                            if len(result_rag) > 1:
-                                st.markdown(result_rag[1])
-                        
-                        # Save results
-                        filename = generate_filename(arxiv_query, "md")
-                        create_file(filename, arxiv_query, f"{result_mixtral}\n\n{result_mistral}")
-                        
-                        if container:
-                            save_to_cosmos_db(container, arxiv_query, result_mixtral, result_mistral)
+def process_story(story_text, num_scenes=5):
+    """Break story into scenes for visualization"""
+    sentences = story_text.split('.')
+    scenes = []
+    scene_length = max(1, len(sentences) // num_scenes)
+    
+    for i in range(0, len(sentences), scene_length):
+        scene = '. '.join(sentences[i:i+scene_length]).strip()
+        if scene:
+            scenes.append(scene)
+    
+    return scenes[:num_scenes]
 
-    with claude_tab:
-        st.header("💬 Chat with Claude")
-        user_input = st.text_area("Your message:", height=100)
-        if st.button("Send"):
-            if user_input:
-                with st.spinner("Claude is thinking..."):
-                    try:
-                        response = anthropic_client.messages.create(
-                            model="claude-3-sonnet-20240229",
-                            max_tokens=1000,
-                            messages=[{"role": "user", "content": user_input}]
-                        )
-                        
-                        claude_response = response.content[0].text
-                        st.markdown("### Claude's Response:")
-                        st.markdown(claude_response)
-                        
-                        # Save chat history
-                        st.session_state.chat_history.append({
-                            "user": user_input,
-                            "claude": claude_response,
-                            "timestamp": datetime.now().isoformat()
-                        })
-                        
-                        # Save to file
-                        filename = generate_filename(user_input, "md")
-                        create_file(filename, user_input, claude_response)
-                        
-                        # Save to Cosmos DB
-                        if container:
-                            save_to_cosmos_db(container, user_input, claude_response, "")
-                            
-                    except Exception as e:
-                        st.error(f"Error communicating with Claude: {str(e)}")
+def story_generator_interface(prompt, genre, structure, model_choice, num_scenes, words_per_scene):
+    """Main story generation and multimedia creation function"""
+    
+    # Generate expanded prompt
+    story_prompt = generate_story_prompt(prompt, genre, structure)
+    
+    # Generate story
+    story = generate_story(story_prompt, model_choice)
+    
+    # Process story into scenes
+    scenes = process_story(story, num_scenes)
+    
+    # Generate images for each scene
+    image_paths = []
+    for scene in scenes:
+        image = generate_image_from_text(scene)
+        if image is not None:
+            temp_path = tempfile.mktemp(suffix=".png")
+            Image.fromarray(image).save(temp_path)
+            image_paths.append(temp_path)
+    
+    # Generate speech
+    audio_path = asyncio.run(generate_speech(story))
+    
+    # Create video
+    scene_durations = [5.0] * len(image_paths)  # 5 seconds per scene
+    video_path = create_video_from_images(image_paths, scene_durations)
+    
+    return story, image_paths, audio_path, video_path
 
-    with history_tab:
-        st.header("📜 Chat History")
-        for chat in reversed(st.session_state.chat_history):
-            with st.expander(f"Conversation from {chat.get('timestamp', 'Unknown time')}"):
-                st.markdown("**Your message:**")
-                st.markdown(chat["user"])
-                st.markdown("**Claude's response:**")
-                st.markdown(chat["claude"])
+# Create Gradio interface
+with gr.Blocks(title="AI Story Generator & Visualizer") as demo:
+    gr.Markdown("# 🎭 AI Story Generator & Visualizer")
+    
+    with gr.Row():
+        with gr.Column():
+            prompt_input = gr.Textbox(
+                label="Story Concept",
+                placeholder="Enter your story idea...",
+                lines=3
+            )
+            genre_input = gr.Dropdown(
+                label="Genre",
+                choices=STORY_GENRES,
+                value="Fantasy"
+            )
+            structure_input = gr.Dropdown(
+                label="Story Structure",
+                choices=list(STORY_STRUCTURES.keys()),
+                value="Three Act"
+            )
+            model_choice = gr.Dropdown(
+                label="Model",
+                choices=["mistralai/Mixtral-8x7B-Instruct-v0.1", "mistralai/Mistral-7B-Instruct-v0.2"],
+                value="mistralai/Mixtral-8x7B-Instruct-v0.1"
+            )
+            num_scenes = gr.Slider(
+                label="Number of Scenes",
+                minimum=3,
+                maximum=7,
+                value=5,
+                step=1
+            )
+            words_per_scene = gr.Slider(
+                label="Words per Scene",
+                minimum=20,
+                maximum=100,
+                value=50,
+                step=10
+            )
+            generate_btn = gr.Button("Generate Story & Media")
+    
+    with gr.Row():
+        with gr.Column():
+            story_output = gr.Textbox(
+                label="Generated Story",
+                lines=10,
+                readonly=True
+            )
+        with gr.Column():
+            gallery = gr.Gallery(label="Scene Visualizations")
+    
+    with gr.Row():
+        audio_output = gr.Audio(label="Story Narration")
+        video_output = gr.Video(label="Story Video")
+    
+    generate_btn.click(
+        fn=story_generator_interface,
+        inputs=[prompt_input, genre_input, structure_input, model_choice, num_scenes, words_per_scene],
+        outputs=[story_output, gallery, audio_output, video_output]
+    )
 
 if __name__ == "__main__":
-    main()
+    demo.launch(reload=True)