Update app.py

app.py

@@ -1,19 +1,23 @@
-# app.py - Gym Workout Generator (Fixed - No 'info' parameter)
+# app.py - Gym Workout Generator (Fixed Video Download + Generated Templates)
 
 import gradio as gr
 from fpdf import FPDF
 import os
 import re
 from datetime import datetime
-from PIL import Image, ImageDraw, ImageFont
 import tempfile
+import base64
+from io import BytesIO
+from PIL import Image, ImageDraw, ImageFont
 
 # Video generation
 try:
     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):
@@ -30,12 +34,13 @@ def clean_text(text, max_length=45):
         u"\U0001F600-\U0001F64F"
         u"\U0001F300-\U0001F5FF"
         u"\U0001F680-\U0001F6FF"
+        u"\U0001F1E0-\U0001F1FF"
         "]+",
         flags=re.UNICODE
     )
     text = emoji_pattern.sub('', text)
     replacements = {
-        '–': '-', '—': '-', '""': '"', '•': '*', '°': 'deg'
+        '–': '-', '—': '-', '“': '"', '”': '"', '•': '*', '°': 'deg'
     }
     for old, new in replacements.items():
         text = text.replace(old, new)
@@ -43,304 +48,226 @@ def clean_text(text, max_length=45):
     text = re.sub(r'\s+', ' ', text.strip())
     return text[:max_length]
 
-def create_workout_screenshot(image_path, workout_name, workout_num, main_title, exercise_list):
-    """Create professional workout screenshot template"""
+def create_screenshot_template(image_path, workout_name, workout_num, main_title):
     try:
-        # Load base image
+        # Load image
         img = Image.open(image_path)
-        img = img.resize((900, 700), Image.Resampling.LANCZOS)
+        img = img.resize((800, 600), Image.Resampling.LANCZOS)
         
-        # Create workout template
-        template = Image.new('RGB', (900, 700), color=(25, 25, 25))
-        draw = ImageDraw.Draw(template)
+        # Create template
+        template = Image.new('RGB', (800, 600), color=(34, 139, 34))
         
-        # Header
-        header_bg = Image.new('RGBA', (900, 120), color=(0, 100, 0, 220))
-        template.paste(header_bg, (0, 0))
+        draw = ImageDraw.Draw(template)
         
-        # Fonts with fallback
+        # Fallback fonts
         try:
-            font_title = ImageFont.truetype("arial.ttf", 50)
-            font_subtitle = ImageFont.truetype("arial.ttf", 32)
-            font_exercise = ImageFont.truetype("arial.ttf", 24)
-            font_small = ImageFont.truetype("arial.ttf", 18)
+            font_large = ImageFont.truetype("arial.ttf", 48)
+            font_medium = ImageFont.truetype("arial.ttf", 36)
+            font_small = ImageFont.truetype("arial.ttf", 24)
         except:
-            font_title = ImageFont.load_default()
-            font_subtitle = ImageFont.load_default()
-            font_exercise = ImageFont.load_default()
+            font_large = ImageFont.load_default()
+            font_medium = ImageFont.load_default()
             font_small = ImageFont.load_default()
         
-        # Workout header text
         clean_name = clean_text(workout_name)
         clean_title = clean_text(main_title)
         
-        draw.text((30, 20), f"WORKOUT {workout_num}", fill="white", font=font_title)
-        draw.text((30, 70), clean_name.upper(), fill="#FFD700", font=font_subtitle)
-        draw.text((30, 100), f"PROGRAM: {clean_title}", fill="white", font=font_small)
-        
-        # Exercise section
-        exercises_bg = Image.new('RGBA', (850, 300), color=(0, 0, 0, 150))
-        template.paste(exercises_bg, (25, 130))
-        
-        draw.text((40, 140), "EXERCISES:", fill="#00FF00", font=font_exercise)
-        
-        sample_exercises = exercise_list or [
-            "Bench Press - 4 sets x 10-12 reps",
-            "Incline Dumbbell Press - 3 sets x 12 reps", 
-            "Chest Flys - 3 sets x 15 reps",
-            "Push Ups - 3 sets to failure"
-        ]
-        
-        y_pos = 180
-        for exercise in sample_exercises[:6]:
-            draw.text((40, y_pos), f"• {exercise}", fill="white", font=font_small)
-            y_pos += 35
+        # Add text
+        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)
         
-        # Main workout image
-        img_resized = img.resize((800, 350), Image.Resampling.LANCZOS)
-        template.paste(img_resized, (50, 450))
+        # Paste image
+        img_resized = img.resize((700, 400), Image.Resampling.LANCZOS)
+        template.paste(img_resized, (50, 150))
         
         # Footer
-        footer_bg = Image.new('RGBA', (900, 100), color=(0, 50, 0, 200))
-        template.paste(footer_bg, (0, 600))
+        draw.text((50, 540), "Workout Execution Plan - Print & Train!", fill="white", font=font_small)
         
-        draw.text((50, 620), "WORKOUT EXECUTION PLAN", fill="white", font=font_subtitle)
-        draw.text((50, 650), "Sets x Reps | Rest Periods | Progressive Overload", fill="#FFD700", font=font_small)
-        
-        # Save
-        template_path = f"workout_screenshot_{workout_num}.jpg"
-        template.save(template_path, "JPEG", quality=95)
+        # Save to temp
+        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp_file:
+            template_path = tmp_file.name
+            template.save(template_path, "JPEG", quality=95)
         return template_path
         
     except Exception as e:
-        print(f"Screenshot creation failed: {e}")
+        print(f"Template error: {e}")
         return image_path
 
-def generate_workout_content(main_title, workout_names, image_files, exercise_details):
+def generate_content(main_title, workout_names, image_files):
     if not main_title.strip():
         return None, None, "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!"
     
-    if len(names_list) > 20:
-        return None, None, "Error: Max 20 Workouts!"
+    if len(names_list) > 30:
+        return None, None, "Error: Max 30 Workouts!"
     
-    # Parse exercises
-    exercise_lists = []
-    if exercise_details.strip():
-        exercises = [ex.strip() for ex in exercise_details.split('\n') if ex.strip()]
-        exercises_per_workout = len(exercises) // len(names_list) if names_list else 0
-        for i in range(len(names_list)):
-            start_idx = i * exercises_per_workout
-            end_idx = start_idx + exercises_per_workout
-            exercise_lists.append(exercises[start_idx:end_idx])
-    else:
-        default_exercises = {
-            "chest": ["Bench Press 4x10", "Incline Press 3x12", "Chest Flys 3x15"],
-            "leg": ["Squats 4x8", "Leg Press 3x12", "Lunges 3x10"],
-            "back": ["Deadlifts 4x8", "Pull Ups 3x10", "Rows 3x12"],
-            "arm": ["Bicep Curls 3x12", "Tricep Extensions 3x12", "Hammer Curls 3x15"]
-        }
-        for workout in names_list:
-            workout_lower = workout.lower()
-            for key, ex_list in default_exercises.items():
-                if key in workout_lower:
-                    exercise_lists.append(ex_list)
-                    break
-            else:
-                exercise_lists.append(["Main Exercise 4x10", "Secondary 3x12", "Finisher 3x15"])
+    if not image_files:
+        return None, None, "Error: Upload at least 1 image!"
+    
+    available_images = len(image_files)
+    status_msg = f"Using {available_images} images for {len(names_list)} workouts (placeholders for missing)"
     
     try:
+        clean_main_title = clean_text(main_title, 50)
         pdf = GymWorkoutPDF()
-        pdf.set_margins(15, 15, 15)
+        pdf.set_margins(18, 18, 18)
         
-        # Title Page
+        # PDF Title
         pdf.add_page()
-        pdf.set_font('Arial', 'B', 22)
+        pdf.set_font('Arial', 'B', 20)
         pdf.set_text_color(0, 128, 0)
-        pdf.cell(0, 20, "PROFESSIONAL GYM WORKOUT PROGRAM", ln=1, align='C')
-        pdf.set_font('Arial', 'B', 18)
-        clean_title = clean_text(main_title)
-        pdf.cell(0, 18, clean_title.upper(), ln=1, align='C')
+        pdf.cell(0, 18, "GYM WORKOUT PROGRAM", ln=1, align='C')
+        pdf.set_font('Arial', 'B', 16)
+        pdf.cell(0, 15, clean_main_title.upper(), ln=1, align='C')
         
-        pdf.ln(10)
-        pdf.set_font('Arial', '', 12)
-        pdf.cell(0, 12, f"TOTAL WORKOUTS: {len(names_list)}", ln=1, align='C')
-        pdf.cell(0, 12, f"CREATED: {datetime.now().strftime('%d/%m/%Y')}", ln=1, align='C')
+        pdf.ln(15)
+        pdf.set_font('Arial', '', 11)
+        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')
         
         template_paths = []
         
-        # Workout Pages
-        for i, (workout_name, exercises) in enumerate(zip(names_list, exercise_lists)):
+        for i, workout_name in enumerate(names_list):
             pdf.add_page()
-            
-            pdf.set_font('Arial', 'B', 18)
+            pdf.set_font('Arial', 'B', 16)
             pdf.set_text_color(0, 128, 0)
-            pdf.cell(0, 16, f"WORKOUT {i+1}", ln=1, align='C')
+            pdf.cell(0, 14, f"WORKOUT {i+1}", ln=1, align='C')
             
-            clean_name = clean_text(workout_name)
-            pdf.set_font('Arial', 'B', 16)
-            pdf.multi_cell(0, 14, clean_name.upper(), align='C')
+            clean_name = clean_text(workout_name, 40)
+            pdf.set_font('Arial', 'B', 14)
+            pdf.multi_cell(0, 12, clean_name.upper(), align='C')
             
-            # Create screenshot
-            img_path = image_files[i] if i < len(image_files) else None
-            screenshot_path = None
+            img_path = image_files[i] if i < available_images else None
+            template_path = None
             
             if img_path and os.path.exists(img_path):
-                screenshot_path = create_workout_screenshot(
-                    img_path, workout_name, i+1, main_title, exercises
+                template_path = create_screenshot_template(
+                    img_path, workout_name, i+1, main_title
                 )
-                template_paths.append(screenshot_path)
+                template_paths.append(template_path)
                 
-                img_width = 140
+                # Add template to PDF
+                img_width = 110
                 x_pos = (pdf.w - img_width) / 2
-                try:
-                    pdf.image(screenshot_path, x=x_pos, y=pdf.get_y(), w=img_width, h=180)
-                    pdf.set_draw_color(0, 128, 0)
-                    pdf.rect(x_pos, pdf.get_y(), img_width, 180, 'D')
-                except:
-                    pass
+                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')
             else:
-                img_width = 140
-                x_pos = (pdf.w - img_width) / 2
+                # Placeholder
                 pdf.set_fill_color(240, 248, 240)
                 pdf.set_draw_color(0, 128, 0)
-                pdf.rect(x_pos, pdf.get_y(), img_width, 180, 'FD')
-                pdf.set_font('Arial', 'B', 12)
-                pdf.set_xy(x_pos + 10, pdf.get_y() + 70)
-                pdf.cell(img_width-20, 10, f"WORKOUT {i+1}", ln=1, align='C')
-            
-            # Workout details
-            pdf.set_y(pdf.get_y() + 200)
-            pdf.set_font('Arial', 'B', 14)
-            pdf.set_text_color(0, 128, 0)
-            pdf.cell(0, 12, "EXERCISE PLAN", ln=1, align='C')
-            
-            pdf.set_font('Arial', '', 10)
-            for j, exercise in enumerate(exercises[:5]):
-                pdf.ln(6)
-                pdf.cell(0, 8, f"{j+1}. {exercise}", ln=1, align='L')
+                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"gym_workouts_{timestamp}.pdf"
-        pdf.output(pdf_path)
+        # Save PDF to temp
+        with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as tmp_pdf:
+            pdf_path = tmp_pdf.name
+            pdf.output(pdf_path)
         
-        # Video
+        # VIDEO GENERATION
         video_path = None
         if VIDEO_ENABLED and template_paths:
             try:
                 clips = []
-                duration = 7
+                hd_width, hd_height = 1920, 1080
+                duration_per_slide = 6
                 
-                title_clip = ColorClip(size=(1280, 720), color=(0, 100, 0)).set_duration(4)
-                title_text = TextClip(f"GYM WORKOUT PROGRAM\n{clean_title.upper()}", 
-                                    fontsize=70, color='white').set_duration(4).set_position('center')
-                clips.append(CompositeVideoClip([title_clip, title_text]))
+                # 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'
+                ).set_position('center').set_duration(4)
+                title_slide = CompositeVideoClip([title_clip, title_text])
+                clips.append(title_slide)
                 
-                for screenshot in template_paths:
-                    if os.path.exists(screenshot):
-                        clip = (ImageClip(screenshot)
-                               .resize(height=720)
-                               .set_duration(duration)
-                               .crossfadein(1))
-                        clips.append(clip)
+                # Workout slides
+                for i, template_img in enumerate(template_paths):
+                    if os.path.exists(template_img):
+                        img_clip = ImageClip(template_img).resize(height=hd_height)
+                        img_clip = img_clip.set_duration(duration_per_slide)
+                        
+                        img_clip = img_clip.fx(crop, x1=100, y1=50, x2=hd_width-100, y2=hd_height-100)
+                        
+                        clips.append(img_clip)
                 
-                if len(clips) > 1:
-                    video = concatenate_videoclips(clips)
-                    video_path = f"workout_video_{timestamp}.mp4"
-                    video.write_videofile(video_path, fps=24, codec='libx264', audio=False)
+                if clips:
+                    video = concatenate_videoclips(clips, method="compose")
+                    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp_video:
+                        video_path = tmp_video.name
+                        video.write_videofile(
+                            video_path,
+                            fps=24, 
+                            codec='libx264',
+                            audio=False,
+                            verbose=False,
+                            logger=None
+                        )
                     video.close()
-            except:
-                pass
+                
+            except Exception as e:
+                print(f"Video error: {e}")
+                video_path = None
         
-        # Cleanup
+        # Cleanup templates
         for path in template_paths:
             try:
                 os.remove(path)
             except:
                 pass
         
-        video_status = "HD Video Generated!" if video_path else "No Video (MoviePy needed)"
-        return pdf_path, video_path, f"""
-✅ SUCCESS! {len(names_list)} Workout Screenshots Generated!
-📄 PDF: {len(names_list) + 1} pages with professional templates
-🖼️ {len(template_paths)} Workout screenshots created
+        video_status = "HD Video Generated and Ready to Download!" if video_path else "Video Generation Failed - Check MoviePy/FFmpeg Installation"
+        success_msg = f"""
+✅ SUCCESS! Generated for {len(names_list)} workouts!
+📄 PDF with generated screenshot templates
 🎥 {video_status}
-💪 Ready for gym clients!
+💪 Images processed: {available_images} (templates created)
         """
         
+        return pdf_path, video_path, success_msg
+        
     except Exception as e:
         return None, None, f"Error: {str(e)}"
 
-# FIXED UI - No 'info' parameter
+# 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: 25px; border-radius: 15px; text-align: center;}
-    .input-box {background: #f0fdf4; padding: 15px; border-radius: 10px; border: 2px solid #dcfce7; margin: 10px 0;}
-    .success {background: #dcfce7; color: #166534; padding: 20px; border-radius: 10px;}
-    """
+    theme=gr.themes.Soft(primary_hue="green")
 ) as demo:
     
-    gr.HTML("""
-    <div class="header">
-        <h2>Gym Workout Screenshot Generator</h2>
-        <p>Create professional workout plans with exercise screenshots</p>
-    </div>
-    """)
+    gr.Markdown("# Gym Workout Generator\nPDF + HD Video + Screenshot Templates")
     
     gr.Markdown("""
     ### How to Use:
-    1. Enter program title
-    2. Add workout names (comma separated)
-    3. Upload exercise images/screenshots
-    4. Get PDF with workout templates + HD video
+    1. Enter Title
+    2. Add Workout Names (comma separated)
+    3. Upload Images/Screenshots (optional - placeholders for missing)
+    4. Get PDF + Video with generated templates!
+    
+    Tip: Uploaded images get auto-converted to gym screenshot templates!
     """)
     
-    with gr.Row():
-        with gr.Column(scale=2):
-            main_title = gr.Textbox(
-                label="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 Day, Arms",
-                lines=3,
-                elem_classes="input-box"
-            )
-            
-            exercise_details = gr.Textbox(
-                label="EXERCISES (Optional)",
-                placeholder="Bench Press 4x10\nSquats 4x8\nDeadlifts 3x8",
-                lines=4,
-                elem_classes="input-box"
-            )
-        
-        with gr.Column(scale=1):
-            images_input = gr.File(
-                label="Exercise Images/Screenshots",
-                file_count="multiple",
-                file_types=[".jpg", ".jpeg", ".png"],
-                elem_classes="input-box"
-            )  # REMOVED 'info' parameter
+    main_title = gr.Textbox(label="MAIN PROGRAM TITLE *")
+    workout_names = gr.Textbox(label="WORKOUT NAMES * (Comma separated)")
     
-    generate_btn = gr.Button("Generate Workout Screenshots + PDF", variant="primary")
+    images_input = gr.File(label="Images/Screenshots (Optional)", file_count="multiple", file_types=["image"])
     
-    with gr.Row():
-        pdf_output = gr.File(label="Download PDF")
-        video_output = gr.File(label="Download Video (if available)")
+    generate_btn = gr.Button("Generate")
     
+    pdf_output = gr.File(label="PDF")
+    video_output = gr.File(label="HD Video")
     status = gr.Markdown("Ready...")
     
     generate_btn.click(
-        fn=generate_workout_content,
-        inputs=[main_title, workout_names, images_input, exercise_details],
+        fn=generate_content,
+        inputs=[main_title, workout_names, images_input],
         outputs=[pdf_output, video_output, status]
     )