Update app.py

app.py

@@ -1,17 +1,23 @@
-# app.py - Gym Workout Plan PDF + Video (Fixed Errors)
+# app.py - Gym Workout Generator (PDF + Screenshot Template + Fixed Video)
 
 import gradio as gr
 from fpdf import FPDF
 import os
 import re
 from datetime import datetime
+import tempfile
+import base64
+from io import BytesIO
+from PIL import Image
 
-# Video generation
+# Video generation with fallback
 try:
-    from moviepy.editor import ImageClip, concatenate_videoclips, TextClip, CompositeVideoClip
+    from moviepy.editor import ImageClip, concatenate_videoclips, TextClip, CompositeVideoClip, ColorClip
+    from moviepy.video.fx.all import crop
     VIDEO_ENABLED = True
 except ImportError:
     VIDEO_ENABLED = False
+    print("MoviePy not available - using basic video generation")
 
 class GymWorkoutPDF(FPDF):
     def footer(self):
@@ -20,6 +26,7 @@ class GymWorkoutPDF(FPDF):
         self.cell(0, 8, f'GYM WORKOUT PLAN | Page {self.page_no()}', 0, 0, 'C')
 
 def clean_text(text, max_length=45):
+    """Clean text for PDF and video"""
     if not text:
         return "Workout"
     text = str(text)
@@ -42,27 +49,86 @@ def clean_text(text, max_length=45):
     text = re.sub(r'\s+', ' ', text.strip())
     return text[:max_length]
 
+def create_screenshot_template(image_path, workout_name, workout_num, main_title):
+    """Create screenshot-style template image"""
+    try:
+        # Load and resize image
+        img = Image.open(image_path)
+        img = img.resize((800, 600), Image.Resampling.LANCZOS)
+        
+        # Create template
+        template = Image.new('RGB', (800, 600), color=(34, 139, 34))  # Dark green background
+        
+        # Add workout overlay
+        from PIL import ImageDraw, ImageFont
+        
+        draw = ImageDraw.Draw(template)
+        
+        # Title background
+        title_bg = Image.new('RGBA', (800, 120), color=(0, 100, 0, 200))
+        template.paste(title_bg, (0, 0))
+        
+        # Fonts (fallback to default)
+        try:
+            font_large = ImageFont.truetype("arial.ttf", 48)
+            font_medium = ImageFont.truetype("arial.ttf", 36)
+            font_small = ImageFont.truetype("arial.ttf", 24)
+        except:
+            font_large = ImageFont.load_default()
+            font_medium = ImageFont.load_default()
+            font_small = ImageFont.load_default()
+        
+        # Draw text
+        clean_name = clean_text(workout_name)
+        clean_title = clean_text(main_title)
+        
+        draw.text((50, 20), f"WORKOUT {workout_num}", fill="white", font=font_large)
+        draw.text((50, 80), clean_name.upper(), fill="yellow", font=font_medium)
+        draw.text((50, 120), f"PROGRAM: {clean_title}", fill="white", font=font_small)
+        
+        # Add image
+        img_resized = img.resize((700, 400), Image.Resampling.LANCZOS)
+        template.paste(img_resized, (50, 150))
+        
+        # Footer
+        footer_bg = Image.new('RGBA', (800, 80), color=(0, 0, 0, 150))
+        template.paste(footer_bg, (0, 520))
+        draw.text((50, 540), f"Workout Execution Plan - Print & Train!", fill="white", font=font_small)
+        
+        # Save template
+        template_path = f"template_{workout_num}.jpg"
+        template.save(template_path, "JPEG", quality=95)
+        return template_path
+        
+    except Exception as e:
+        print(f"Template creation failed: {e}")
+        return image_path  # Return original if template fails
+
 def generate_content(main_title, workout_names, image_files):
     if not main_title.strip():
-        return None, None, "Error: Main Title Required!"
+        return None, None, gr.update(), "Error: Main Title Required!"
     
     names_list = [n.strip() for n in workout_names.split(',') if n.strip()]
     
     if not names_list:
-        return None, None, "Error: Add Workout Names!"
+        return None, None, gr.update(), "Error: Add Workout Names!"
     
     if len(names_list) > 30:
-        return None, None, "Error: Max 30 Workouts!"
+        return None, None, gr.update(), "Error: Max 30 Workouts!"
     
-    if not image_files or len(names_list) != len(image_files):
-        return None, None, f"Error: Number of workout names ({len(names_list)}) must match images ({len(image_files)})!"
+    if not image_files:
+        return None, None, gr.update(), "Error: Upload at least 1 image!"
+    
+    # Allow flexible image count - use available images
+    available_images = min(len(image_files), len(names_list))
+    status_msg = f"Using {available_images} images for {len(names_list)} workouts"
     
     try:
         clean_main_title = clean_text(main_title, 50)
         pdf = GymWorkoutPDF()
         pdf.set_margins(18, 18, 18)
         
-        # PDF
+        # PDF Generation
         pdf.add_page()
         pdf.set_font('Arial', 'B', 20)
         pdf.set_text_color(0, 128, 0)
@@ -75,7 +141,9 @@ def generate_content(main_title, workout_names, image_files):
         pdf.cell(0, 10, f"TOTAL WORKOUTS: {len(names_list)}", ln=1, align='C')
         pdf.cell(0, 10, f"CREATED: {datetime.now().strftime('%d/%m/%Y')}", ln=1, align='C')
         
-        for i, (workout_name, img_path) in enumerate(zip(names_list, image_files)):
+        template_paths = []
+        
+        for i, workout_name in enumerate(names_list):
             pdf.add_page()
             pdf.set_font('Arial', 'B', 16)
             pdf.set_text_color(0, 128, 0)
@@ -85,86 +153,170 @@ def generate_content(main_title, workout_names, image_files):
             pdf.set_font('Arial', 'B', 14)
             pdf.multi_cell(0, 12, clean_name.upper(), align='C')
             
-            if os.path.exists(img_path):
+            # Use available images or placeholder
+            img_path = image_files[i] if i < len(image_files) else None
+            template_path = None
+            
+            if img_path and os.path.exists(img_path):
                 try:
+                    # Create screenshot template
+                    template_path = create_screenshot_template(
+                        img_path, workout_name, i+1, main_title
+                    )
+                    template_paths.append(template_path)
+                    
+                    # Add to PDF
                     img_width = 110
                     x_pos = (pdf.w - img_width) / 2
-                    pdf.image(img_path, x=x_pos, y=pdf.get_y(), w=img_width, h=130)
+                    pdf.image(template_path, x=x_pos, y=pdf.get_y(), w=img_width, h=130)
                     pdf.set_draw_color(0, 128, 0)
                     pdf.rect(x_pos, pdf.get_y(), img_width, 130, 'D')
                 except:
-                    pass
+                    # Fallback to original image
+                    try:
+                        pdf.image(img_path, x=x_pos, y=pdf.get_y(), w=img_width, h=130)
+                    except:
+                        pass
+            else:
+                # No image - placeholder
+                pdf.set_fill_color(240, 248, 240)
+                pdf.set_draw_color(0, 128, 0)
+                pdf.rect(x_pos, pdf.get_y(), img_width, 130, 'FD')
+                pdf.set_font('Arial', 'B', 11)
+                pdf.set_xy(x_pos + 10, pdf.get_y() + 50)
+                pdf.cell(90, 10, f"WORKOUT {i+1}", ln=1, align='C')
         
         timestamp = int(datetime.now().timestamp())
         pdf_path = f"workout_plan_{timestamp}.pdf"
         pdf.output(pdf_path)
         
-        # VIDEO
+        # VIDEO GENERATION
         video_path = None
-        if VIDEO_ENABLED:
-            clips = []
-            hd_width, hd_height = 1920, 1080
-            duration_per_slide = 5
-            
-            # Title slide
-            title_text = TextClip(
-                f"GYM WORKOUT PROGRAM\n{clean_main_title.upper()}",
-                fontsize=80, color='white', font='Arial-Bold',
-                size=(hd_width, 300), bg_color='darkgreen'
-            ).set_duration(3).set_position('center')
-            title_clip = CompositeVideoClip([title_text], size=(hd_width, hd_height))
-            clips.append(title_clip)
-            
-            # Workout slides
-            for i, (workout_name, img_path) in enumerate(zip(names_list, image_files)):
-                clean_name = clean_text(workout_name, 40)
-                img_clip = ImageClip(img_path).resize(height=hd_height-200)
-                img_clip = img_clip.set_position('center').set_duration(duration_per_slide)
+        if VIDEO_ENABLED and template_paths:
+            try:
+                clips = []
+                hd_width, hd_height = 1920, 1080
+                duration_per_slide = 6
                 
-                text_clip = TextClip(
-                    f"WORKOUT {i+1}\n{clean_name.upper()}",
-                    fontsize=60, color='white', font='Arial-Bold',
-                    size=(hd_width-400, 200), bg_color='rgba(0,128,0,0.7)'
-                ).set_position(('center', hd_height-250)).set_duration(duration_per_slide)
+                # Title slide
+                title_clip = ColorClip(size=(hd_width, hd_height), color=(0, 128, 0)).set_duration(4)
+                title_text = TextClip(
+                    f"GYM WORKOUT PROGRAM\n{clean_main_title.upper()}",
+                    fontsize=100, color='white', font='Arial-Bold',
+                    size=(hd_width-400, None)
+                ).set_position('center').set_duration(4)
+                title_slide = CompositeVideoClip([title_clip, title_text])
+                clips.append(title_slide)
                 
-                slide = CompositeVideoClip([img_clip, text_clip], size=(hd_width, hd_height))
-                clips.append(slide)
-            
-            video = concatenate_videoclips(clips, method="compose")
-            video_path = f"workout_video_{timestamp}.mp4"
-            video.write_videofile(
-                video_path, 
-                fps=24, 
-                codec='libx264',
-                audio=False
-            )
+                # Workout slides with templates
+                for template_img in template_paths[:10]:  # Limit to 10 for video
+                    if os.path.exists(template_img):
+                        img_clip = ImageClip(template_img).resize(height=hd_height)
+                        img_clip = img_clip.set_duration(duration_per_slide)
+                        
+                        # Add zoom effect
+                        img_clip = img_clip.fx(crop, x1=100, y1=50, x2=hd_width-100, y2=hd_height-100)
+                        
+                        clips.append(img_clip)
+                
+                if clips:
+                    video = concatenate_videoclips(clips, method="compose")
+                    video_path = f"workout_video_{timestamp}.mp4"
+                    video.write_videofile(
+                        video_path, 
+                        fps=24, 
+                        codec='libx264',
+                        audio=False,
+                        verbose=False,
+                        logger=None
+                    )
+                    video.close()
+                
+            except Exception as e:
+                print(f"Video error: {e}")
+                video_path = None
+        
+        # Cleanup templates
+        for path in template_paths:
+            try:
+                os.remove(path)
+            except:
+                pass
         
-        success_msg = f"SUCCESS! Generated PDF and {'Video' if video_path else 'No Video (Install MoviePy)'} for {len(names_list)} workouts!"
-        return pdf_path, video_path, success_msg
+        video_status = "HD Video Generated!" if video_path else "Video Disabled (MoviePy required)"
+        success_msg = f"""
+✅ SUCCESS! Generated content for {len(names_list)} workouts!
+📄 PDF: {len(names_list) + 1} pages with screenshot templates
+🎥 {video_status}
+💪 Images processed: {available_images}/{len(names_list)}
+        """
+        
+        return pdf_path, video_path, gr.update(), success_msg
         
     except Exception as e:
-        return None, None, f"Error: {str(e)}"
+        return None, None, gr.update(), f"Error: {str(e)}"
 
-# UI
-with gr.Blocks(title="Gym Workout Generator") as demo:
-    gr.Markdown("# Gym Workout Generator\nPDF + HD Video | No Errors")
+# Enhanced UI
+with gr.Blocks(
+    title="Gym Workout Generator",
+    theme=gr.themes.Soft(primary_hue="green"),
+    css="""
+    .header {background: linear-gradient(135deg, #16a34a, #15803d); color: white; padding: 20px; border-radius: 10px;}
+    .input-box {background: #f0fdf4; padding: 15px; border-radius: 8px; border: 2px solid #dcfce7;}
+    .status-success {background: #dcfce7; color: #166534; padding: 15px; border-radius: 8px;}
+    """
+) as demo:
+    
+    gr.HTML("""
+    <div class="header">
+        <h2>🏋️ Gym Workout Generator</h2>
+        <p>PDF + HD Video + Screenshot Templates</p>
+    </div>
+    """)
+    
+    gr.Markdown("""
+    ### 📋 How to Use:
+    1. Enter **Program Title**
+    2. Add **Workout Names** (comma separated)
+    3. Upload **Images/Screenshots** (can be fewer than workouts)
+    4. Get **PDF** with screenshot-style templates + **HD Video**
+    
+    💡 **Tip**: Upload exercise screenshots - they get automatic gym templates!
+    """)
     
     with gr.Row():
-        main_title = gr.Textbox(label="MAIN TITLE *")
-        workout_names = gr.Textbox(label="WORKOUT NAMES * (Comma separated)")
+        with gr.Column(scale=2):
+            main_title = gr.Textbox(
+                label="MAIN PROGRAM TITLE *",
+                placeholder="12 Week Strength Program",
+                elem_classes="input-box"
+            )
+            workout_names = gr.Textbox(
+                label="WORKOUT NAMES * (Comma separated)",
+                placeholder="Chest Day, Leg Day, Back Workout, Arms, Cardio",
+                lines=3,
+                elem_classes="input-box"
+            )
+        with gr.Column(scale=1):
+            images_input = gr.File(
+                label="Images/Screenshots (Optional)",
+                file_count="multiple",
+                file_types=["image"],
+                elem_classes="input-box"
+            )
     
-    images_input = gr.File(label="Images * (Match workout count)", file_count="multiple", file_types=["image"])
+    generate_btn = gr.Button("🚀 Generate PDF + Video", variant="primary")
     
-    generate_btn = gr.Button("Generate")
+    with gr.Row():
+        pdf_output = gr.File(label="📄 Download PDF")
+        video_output = gr.File(label="🎥 Download HD Video")
     
-    pdf_output = gr.File(label="PDF")
-    video_output = gr.File(label="HD Video")
-    status = gr.Markdown("Ready...")
+    status = gr.Markdown("Ready to generate professional gym content...")
     
     generate_btn.click(
         fn=generate_content,
         inputs=[main_title, workout_names, images_input],
-        outputs=[pdf_output, video_output, status]
+        outputs=[pdf_output, video_output, video_output, status]
     )
 
 if __name__ == "__main__":