Update app.py

app.py

@@ -12,64 +12,53 @@ import json
 import pandas as pd
 from pathlib import Path
 from gradio_client import Client
-import hashlib
 
 warnings.filterwarnings('ignore')
 
-# Initialize story starters
+# Initialize story starters with added comedy section
 STORY_STARTERS = [
     ['Adventure', 'In a hidden temple deep in the Amazon...'],
     ['Mystery', 'The detective found an unusual note...'],
     ['Romance', 'Two strangers meet on a rainy evening...'],
     ['Sci-Fi', 'The space station received an unexpected signal...'],
-    ['Fantasy', 'A magical portal appeared in the garden...']
+    ['Fantasy', 'A magical portal appeared in the garden...'],
+    ['Comedy-Sitcom', 'The new roommate arrived with seven emotional support animals...'],
+    ['Comedy-Workplace', 'The office printer started sending mysterious messages...'],
+    ['Comedy-Family', 'Grandma decided to become a social media influencer...'],
+    ['Comedy-Supernatural', 'The ghost haunting the house was absolutely terrible at scaring people...'],
+    ['Comedy-Travel', 'The GPS insisted on giving directions in interpretive dance descriptions...']
 ]
 
 # Initialize client outside of interface definition
 arxiv_client = None
 
-def sanitize_filename(text, max_length=50):
-    """Create a safe filename from text"""
-    # Get first line or first few words
-    first_line = text.split('\n')[0].strip()
-    # Remove special characters and spaces
-    safe_name = re.sub(r'[^\w\s-]', '', first_line)
-    safe_name = re.sub(r'[-\s]+', '-', safe_name).strip('-')
-    # Truncate to max length while keeping words intact
-    if len(safe_name) > max_length:
-        safe_name = safe_name[:max_length].rsplit('-', 1)[0]
-    return safe_name.lower()
-
-def generate_unique_filename(base_name, timestamp, extension):
-    """Generate a unique filename with timestamp and hash"""
-    # Create a hash of the base name to ensure uniqueness
-    name_hash = hashlib.md5(base_name.encode()).hexdigest()[:6]
-    return f"{timestamp}_{base_name}_{name_hash}{extension}"
+def init_client():
+    global arxiv_client
+    if arxiv_client is None:
+        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 with improved naming"""
+    """Save story and audio to gallery with markdown formatting"""
     try:
         # Create gallery directory if it doesn't exist
         gallery_dir = Path("gallery")
         gallery_dir.mkdir(exist_ok=True)
         
-        # Generate timestamp and safe filename base
+        # Generate timestamp and sanitize first line for filename
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        safe_name = sanitize_filename(story)
-        
-        # Generate unique filenames
-        story_filename = generate_unique_filename(safe_name, timestamp, ".md")
-        audio_filename = generate_unique_filename(safe_name, timestamp, ".mp3")
+        first_line = story.split('\n')[0].strip()
+        safe_name = re.sub(r'[^\w\s-]', '', first_line)[:50]  # First 50 chars, sanitized
         
         # Save story text as markdown
-        story_path = gallery_dir / story_filename
+        story_path = gallery_dir / f"story_{timestamp}_{safe_name}.md"
         with open(story_path, "w") as f:
-            f.write(f"# {safe_name.replace('-', ' ').title()}\n\n{story}")
+            f.write(f"# {first_line}\n\n{story}")
         
-        # Copy audio file to gallery with new name
+        # Copy audio file to gallery with matching name
         new_audio_path = None
         if audio_path:
-            new_audio_path = gallery_dir / audio_filename
+            new_audio_path = gallery_dir / f"audio_{timestamp}_{safe_name}.mp3"
             os.system(f"cp {audio_path} {str(new_audio_path)}")
             
         return str(story_path), str(new_audio_path) if new_audio_path else None
@@ -77,48 +66,35 @@ def save_story(story, audio_path):
         print(f"Error saving to gallery: {str(e)}")
         return None, None
 
-def format_gallery_entry(timestamp, preview, story_path, audio_path):
-    """Format gallery entry as markdown with audio controls"""
-    story_link = f"[{preview}]({story_path})"
-    if audio_path:
-        audio_html = f'<audio controls><source src="{audio_path}" type="audio/mp3">Your browser does not support the audio element.</audio>'
-        return f"{timestamp}: {story_link}\n{audio_html}"
-    return f"{timestamp}: {story_link}"
-
 def load_gallery():
-    """Load all stories and audio from gallery with markdown formatting"""
+    """Load all stories and audio from gallery with markdown support"""
     try:
         gallery_dir = Path("gallery")
         if not gallery_dir.exists():
             return []
         
         files = []
-        for story_file in sorted(gallery_dir.glob("*.md"), reverse=True):
-            # Extract timestamp from filename
-            timestamp = story_file.stem.split('_')[0]
-            
-            # Read story content
-            with open(story_file) as f:
-                story_text = f.read()
-                # Extract preview from content (skip markdown header)
-                preview = story_text.split('\n\n', 1)[1][:100] + "..."
+        for story_file in sorted(gallery_dir.glob("story_*.md"), reverse=True):
+            # Extract timestamp and name from filename
+            parts = story_file.stem.split('_', 2)
+            timestamp = f"{parts[1]}"
             
             # Find matching audio file
-            audio_file = gallery_dir / f"{story_file.stem}.mp3"
+            audio_pattern = f"audio_{timestamp}_*.mp3"
+            audio_files = list(gallery_dir.glob(audio_pattern))
+            audio_file = audio_files[0] if audio_files else None
             
-            # Format as markdown with audio controls
-            formatted_entry = format_gallery_entry(
-                timestamp,
-                preview,
-                str(story_file),
-                str(audio_file) if audio_file.exists() else None
-            )
+            # Read story content and get preview
+            with open(story_file) as f:
+                content = f.read()
+                # Skip markdown header and get preview
+                preview = content.split('\n\n', 1)[1][:100] + "..."
             
             files.append([
                 timestamp,
-                formatted_entry,
+                f"[{preview}]({str(story_file)})",  # Markdown link to story
                 str(story_file),
-                str(audio_file) if audio_file.exists() else None
+                str(audio_file) if audio_file else None
             ])
         
         return files
@@ -126,7 +102,7 @@ def load_gallery():
         print(f"Error loading gallery: {str(e)}")
         return []
 
-# Rest of your existing functions remain the same
+# Keep all other functions unchanged
 def generate_story(prompt, model_choice):
     """Generate story using specified model"""
     try:
@@ -174,7 +150,19 @@ def process_story_and_audio(prompt, model_choice):
     except Exception as e:
         return f"Error: {str(e)}", None, None
 
-# Create the Gradio interface
+def play_gallery_audio(evt: gr.SelectData, gallery_data):
+    """Play audio from gallery selection"""
+    try:
+        selected_row = gallery_data[evt.index[0]]
+        audio_path = selected_row[3]  # Audio path is the fourth element
+        if audio_path and os.path.exists(audio_path):
+            return audio_path
+        return None
+    except Exception as e:
+        print(f"Error playing gallery audio: {str(e)}")
+        return None
+
+# Create the Gradio interface (keep unchanged)
 with gr.Blocks(title="AI Story Generator") as demo:
     gr.Markdown("""
     # 🎭 AI Story Generator & Narrator
@@ -223,16 +211,12 @@ with gr.Blocks(title="AI Story Generator") as demo:
                 interactive=False
             )
             
-            gr.Markdown("### 🎬 Story Gallery")
-            gallery = gr.HTML(value="")
-            
-            def update_gallery():
-                gallery_entries = load_gallery()
-                if not gallery_entries:
-                    return "<p>No stories in gallery yet.</p>"
-                return "<br>".join(entry[1] for entry in gallery_entries)
-            
-            demo.load(update_gallery, outputs=[gallery])
+            gr.Markdown("### 🎬 Gallery")
+            gallery = gr.Dataframe(
+                value=load_gallery(),
+                headers=["Timestamp", "Preview", "Story Path", "Audio Path"],
+                interactive=False
+            )
     
     # Event handlers
     def update_prompt(evt: gr.SelectData):
@@ -245,6 +229,12 @@ with gr.Blocks(title="AI Story Generator") as demo:
         inputs=[prompt_input, model_choice],
         outputs=[story_output, audio_output, gallery]
     )
+    
+    gallery.select(
+        fn=play_gallery_audio,
+        inputs=[gallery],
+        outputs=[audio_output]
+    )
 
 if __name__ == "__main__":
     demo.launch()