Update app.py

app.py

@@ -6,13 +6,27 @@ import os
 import edge_tts
 import asyncio
 import warnings
-from gradio_client import Client
 import pytz
 import re
 import json
+import pandas as pd
+from pathlib import Path
+from gradio_client import Client
 
 warnings.filterwarnings('ignore')
 
+# Initialize story starters
+STORY_STARTERS = pd.DataFrame({
+    'category': ['Adventure', 'Mystery', 'Romance', 'Sci-Fi', 'Fantasy'],
+    'starter': [
+        'In a hidden temple deep in the Amazon...',
+        'The detective found an unusual note...',
+        'Two strangers meet on a rainy evening...',
+        'The space station received an unexpected signal...',
+        'A magical portal appeared in the garden...'
+    ]
+})
+
 # Initialize client outside of interface definition
 arxiv_client = None
 
@@ -22,6 +36,58 @@ def init_client():
         arxiv_client = Client("awacke1/Arxiv-Paper-Search-And-QA-RAG-Pattern")
     return arxiv_client
 
+def save_story(story, audio_path):
+    """Save story and audio to gallery"""
+    try:
+        # Create gallery directory if it doesn't exist
+        gallery_dir = Path("gallery")
+        gallery_dir.mkdir(exist_ok=True)
+        
+        # Generate timestamp for unique filename
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        
+        # Save story text
+        story_path = gallery_dir / f"story_{timestamp}.txt"
+        with open(story_path, "w") as f:
+            f.write(story)
+        
+        # Copy audio file to gallery
+        if audio_path:
+            new_audio_path = gallery_dir / f"audio_{timestamp}.mp3"
+            os.system(f"cp {audio_path} {str(new_audio_path)}")
+            
+        return str(story_path), str(new_audio_path)
+    except Exception as e:
+        print(f"Error saving to gallery: {str(e)}")
+        return None, None
+
+def load_gallery():
+    """Load all stories and audio from gallery"""
+    try:
+        gallery_dir = Path("gallery")
+        if not gallery_dir.exists():
+            return []
+        
+        files = []
+        for story_file in gallery_dir.glob("story_*.txt"):
+            timestamp = story_file.stem.split('_')[1]
+            audio_file = gallery_dir / f"audio_{timestamp}.mp3"
+            
+            with open(story_file) as f:
+                story_text = f.read()
+            
+            files.append({
+                "timestamp": timestamp,
+                "story_path": str(story_file),
+                "audio_path": str(audio_file) if audio_file.exists() else None,
+                "story_preview": story_text[:100] + "..."
+            })
+        
+        return sorted(files, key=lambda x: x["timestamp"], reverse=True)
+    except Exception as e:
+        print(f"Error loading gallery: {str(e)}")
+        return []
+
 def generate_story(prompt, model_choice):
     """Generate story using specified model"""
     try:
@@ -52,63 +118,90 @@ async def generate_speech(text, voice="en-US-AriaNeural"):
         return None
 
 def process_story_and_audio(prompt, model_choice):
-    """Process story and generate audio"""
+    """Process story, generate audio, and save to gallery"""
     try:
         # Generate story
         story = generate_story(prompt, model_choice)
         if isinstance(story, str) and story.startswith("Error"):
-            return story, None
-
+            return story, None, None
+        
         # Generate audio
         audio_path = asyncio.run(generate_speech(story))
         
-        return story, audio_path
+        # Save to gallery
+        story_path, saved_audio_path = save_story(story, audio_path)
+        
+        return story, audio_path, load_gallery()
     except Exception as e:
-        return f"Error: {str(e)}", None
+        return f"Error: {str(e)}", None, None
 
 # Create the Gradio interface
 with gr.Blocks(title="AI Story Generator") as demo:
     gr.Markdown("""
     # 🎭 AI Story Generator & Narrator
-    Generate creative stories and listen to them!
+    Generate creative stories, listen to them, and build your gallery!
     """)
     
     with gr.Row():
-        with gr.Column():
-            prompt_input = gr.Textbox(
-                label="Story Concept",
-                placeholder="Enter your story idea...",
-                lines=3
+        with gr.Column(scale=3):
+            with gr.Row():
+                prompt_input = gr.Textbox(
+                    label="Story Concept",
+                    placeholder="Enter your story idea...",
+                    lines=3
+                )
+            
+            with gr.Row():
+                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"
+                )
+                generate_btn = gr.Button("Generate Story")
+            
+            with gr.Row():
+                story_output = gr.Textbox(
+                    label="Generated Story",
+                    lines=10,
+                    interactive=False
+                )
+            
+            with gr.Row():
+                audio_output = gr.Audio(
+                    label="Story Narration",
+                    type="filepath"
+                )
+        
+        # Sidebar with Story Starters and Gallery
+        with gr.Column(scale=1):
+            gr.Markdown("### 📚 Story Starters")
+            story_starters = gr.Dataframe(
+                value=STORY_STARTERS,
+                headers=["category", "starter"],
+                interactive=False
             )
-            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"
+            
+            gr.Markdown("### 🎬 Gallery")
+            gallery = gr.Dataframe(
+                value=load_gallery(),
+                headers=["timestamp", "story_preview"],
+                interactive=False
             )
-            generate_btn = gr.Button("Generate Story")
     
-    with gr.Row():
-        story_output = gr.Textbox(
-            label="Generated Story",
-            lines=10,
-            interactive=False
-        )
+    # Event handlers
+    def update_prompt(evt: gr.SelectData):
+        return STORY_STARTERS.iloc[evt.index[0]]["starter"]
     
-    with gr.Row():
-        audio_output = gr.Audio(
-            label="Story Narration",
-            type="filepath"
-        )
+    story_starters.select(update_prompt, None, prompt_input)
     
     generate_btn.click(
         fn=process_story_and_audio,
         inputs=[prompt_input, model_choice],
-        outputs=[story_output, audio_output]
+        outputs=[story_output, audio_output, gallery]
     )
 
-# Launch the app using the current pattern
 if __name__ == "__main__":
     demo.launch()