Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py - Professional Gym Workout Generator (FIXED - No 'info' parameter)
+# app.py - Gym Workout Generator (Fixed Video + Generated Templates in PDF/Video)
 
 import gradio as gr
 from fpdf import FPDF
@@ -6,322 +6,262 @@ import os
 import re
 from datetime import datetime
 import tempfile
+from io import BytesIO
 from PIL import Image, ImageDraw, ImageFont
-import numpy as np
 
-# Enhanced video generation
+# Video generation
 try:
-    from moviepy.editor import (
-        ImageClip, concatenate_videoclips, TextClip, CompositeVideoClip, 
-        ColorClip, vfx
-    )
+    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 ProfessionalGymPDF(FPDF):
-    def header(self):
-        self.set_font('Arial', 'B', 15)
-        self.set_text_color(0, 128, 0)
-        self.cell(0, 10, 'PROFESSIONAL GYM WORKOUT PLAN', 0, 1, 'C')
-        self.ln(5)
-    
+class GymWorkoutPDF(FPDF):
     def footer(self):
-        self.set_y(-15)
-        self.set_font('Arial', 'I', 8)
-        self.cell(0, 10, f'Page {self.page_no()} | {datetime.now().strftime("%d/%m/%Y")}', 0, 0, 'C')
+        self.set_y(-10)
+        self.set_font('Arial', 'I', 7)
+        self.cell(0, 8, f'GYM WORKOUT PLAN | Page {self.page_no()}', 0, 0, 'C')
 
-def clean_text(text, max_length=60):
+def clean_text(text, max_length=45):
     if not text:
-        return "Workout Session"
+        return "Workout"
     text = str(text)
-    emoji_pattern = re.compile("["
+    emoji_pattern = re.compile(
+        "["
         u"\U0001F600-\U0001F64F"
         u"\U0001F300-\U0001F5FF"
         u"\U0001F680-\U0001F6FF"
         u"\U0001F1E0-\U0001F1FF"
-        "]+", flags=re.UNICODE)
+        "]+",
+        flags=re.UNICODE
+    )
     text = emoji_pattern.sub('', text)
-    text = re.sub(r'[^\w\s\-.,!?\(\)]', '', text)
+    replacements = {
+        '–': '-', '—': '-', '“': '"', '”': '"', '•': '*', '°': 'deg'
+    }
+    for old, new in replacements.items():
+        text = text.replace(old, new)
+    text = re.sub(r'[^\x00-\x7F\u0020-\u007E]', '', text)
     text = re.sub(r'\s+', ' ', text.strip())
     return text[:max_length]
 
-def create_premium_template(image_path, workout_name, workout_num, main_title):
-    """Create professional HD template with workout name overlay"""
+def create_screenshot_template(image_path, workout_name, workout_num, main_title):
     try:
+        # Load image
         img = Image.open(image_path)
-        img = img.resize((1920, 1080), Image.Resampling.LANCZOS)
+        img = img.resize((800, 600), Image.Resampling.LANCZOS)
+        
+        # Create template
+        template = Image.new('RGB', (800, 600), color=(34, 139, 34))
         
-        template = Image.new('RGB', (1920, 1080), color=(25, 25, 25))
         draw = ImageDraw.Draw(template)
         
+        # Fallback fonts
         try:
-            font_title = ImageFont.truetype("arial.ttf", 80)
-            font_workout = ImageFont.truetype("arial.ttf", 60)
-            font_sub = ImageFont.truetype("arial.ttf", 40)
+            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_workout = ImageFont.load_default()
-            font_sub = ImageFont.load_default()
+            font_large = ImageFont.load_default()
+            font_medium = ImageFont.load_default()
+            font_small = ImageFont.load_default()
         
         clean_name = clean_text(workout_name)
         clean_title = clean_text(main_title)
         
-        header_bg = Image.new('RGBA', (1920, 200), (0, 100, 0, 200))
-        template.paste(header_bg, (0, 0), header_bg)
-        
-        draw.text((100, 50), f"WORKOUT SESSION {workout_num}", fill="white", font=font_title)
-        draw.text((100, 130), clean_name.upper(), fill="#FFD700", font=font_workout)
-        draw.text((100, 200), f"PROGRAM: {clean_title}", fill="white", font=font_sub)
-        
-        img_resized = img.resize((1600, 800), Image.Resampling.LANCZOS)
-        template.paste(img_resized, (160, 300))
-        
-        draw.rectangle([160, 300, 1760, 1100], outline="#00FF00", width=5)
+        # 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)
         
-        footer_bg = Image.new('RGBA', (1920, 150), (0, 0, 0, 180))
-        template.paste(footer_bg, (0, 930), footer_bg)
+        # Paste image
+        img_resized = img.resize((700, 400), Image.Resampling.LANCZOS)
+        template.paste(img_resized, (50, 150))
         
-        draw.text((100, 950), "EXECUTION PLAN:", fill="#00FF00", font=font_sub)
-        draw.text((100, 990), "SETS | REPS | REST | PROGRESS", fill="white", font=font_sub)
-        draw.text((100, 1030), "PRINT • TRAIN • TRACK • REPEAT", fill="#FFD700", font=font_sub)
+        # Footer
+        draw.text((50, 540), "Workout Execution Plan - Print & Train!", fill="white", font=font_small)
         
-        template_path = f"hd_template_{workout_num}.jpg"
-        template.save(template_path, "JPEG", quality=95, optimize=False)
+        # 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"Template error: {e}")
         return image_path
 
-def generate_professional_content(main_title, workout_names, image_files):
+def generate_content(main_title, workout_names, image_files):
     if not main_title.strip():
-        return None, None, "❌ Main Title Required!"
+        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, "❌ Add Workout Names!"
+        return None, None, "Error: Add Workout Names!"
+    
+    if len(names_list) > 30:
+        return None, None, "Error: Max 30 Workouts!"
     
-    if len(names_list) > 20:
-        return None, None, "❌ Max 20 Workouts!"
+    if not image_files:
+        return None, None, "Error: Upload at least 1 image!"
     
-    available_images = len(image_files) if image_files else 0
+    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, 60)
-        pdf = ProfessionalGymPDF()
-        pdf.set_margins(20, 20, 20)
-        pdf.add_page()
+        clean_main_title = clean_text(main_title, 50)
+        pdf = GymWorkoutPDF()
+        pdf.set_margins(18, 18, 18)
         
-        # Premium PDF Title Page
-        pdf.set_font('Arial', 'B', 24)
+        # PDF Title
+        pdf.add_page()
+        pdf.set_font('Arial', 'B', 20)
         pdf.set_text_color(0, 128, 0)
-        pdf.cell(0, 20, "PROFESSIONAL", ln=1, align='C')
-        pdf.set_font('Arial', 'B', 28)
-        pdf.cell(0, 25, "GYM WORKOUT", ln=1, align='C')
-        pdf.set_font('Arial', 'B', 22)
-        pdf.cell(0, 20, "PROGRAM", ln=1, align='C')
-        
-        pdf.ln(10)
-        pdf.set_font('Arial', 'B', 18)
+        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(15)
-        pdf.set_font('Arial', '', 12)
-        pdf.set_text_color(100, 100, 100)
-        pdf.cell(0, 10, f"TOTAL SESSIONS: {len(names_list)}", ln=1, align='C')
-        pdf.cell(0, 10, f"CREATED: {datetime.now().strftime('%d/%m/%Y %H:%M')}", ln=1, align='C')
-        pdf.cell(0, 10, "PROFESSIONAL GYM CERTIFIED", ln=1, align='C')
+        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')
         
-        hd_templates = []
+        template_paths = []
         
         for i, workout_name in enumerate(names_list):
             pdf.add_page()
-            pdf.set_font('Arial', 'B', 20)
-            pdf.set_text_color(0, 128, 0)
-            pdf.cell(0, 18, f"SESSION {i+1}", ln=1, align='C')
-            
-            clean_name = clean_text(workout_name, 50)
             pdf.set_font('Arial', 'B', 16)
-            pdf.cell(0, 14, clean_name.upper(), ln=1, align='C')
-            
-            pdf.ln(5)
-            pdf.set_font('Arial', 'B', 14)
             pdf.set_text_color(0, 128, 0)
-            pdf.cell(0, 12, "EXECUTION PROTOCOL", ln=1, align='C')
-            
-            pdf.set_draw_color(0, 128, 0)
-            pdf.set_line_width(2)
-            pdf.line(20, pdf.get_y(), pdf.w-20, pdf.get_y())
+            pdf.cell(0, 14, f"WORKOUT {i+1}", ln=1, align='C')
             
-            pdf.ln(8)
-            pdf.set_font('Arial', '', 10)
-            pdf.set_text_color(60, 60, 60)
-            
-            workout_details = [
-                f"PRIMARY FOCUS: {clean_name}",
-                "WARMUP: 5-10 min dynamic stretches",
-                "SETS x REPS: _________________________",
-                "WEIGHT PROGRESSION: _________________",
-                "REST INTERVALS: ______________________",
-                "TARGET RPE: 7-9 / 10",
-                "COOLDOWN: Static stretches 5-10 min"
-            ]
-            
-            for detail in workout_details:
-                pdf.ln(6)
-                pdf.cell(0, 8, detail, ln=1, align='L')
+            clean_name = clean_text(workout_name, 40)
+            pdf.set_font('Arial', 'B', 14)
+            pdf.multi_cell(0, 12, clean_name.upper(), align='C')
             
             img_path = image_files[i] if i < available_images else None
             template_path = None
             
             if img_path and os.path.exists(img_path):
-                template_path = create_premium_template(
+                template_path = create_screenshot_template(
                     img_path, workout_name, i+1, main_title
                 )
-                hd_templates.append(template_path)
+                template_paths.append(template_path)
                 
-                img_width = 140
+                # Add to PDF
+                img_width = 110
                 x_pos = (pdf.w - img_width) / 2
-                try:
-                    pdf.image(template_path, x=x_pos, y=pdf.get_y(), w=img_width, h=180)
-                    pdf.set_draw_color(0, 128, 0)
-                    pdf.set_line_width(1)
-                    pdf.rect(x_pos, pdf.get_y(), img_width, 180, 'D')
-                except:
-                    pass
-            
-            pdf.ln(10)
-            pdf.set_font('Arial', 'B', 12)
-            pdf.set_text_color(0, 128, 0)
-            pdf.cell(0, 10, "SIGNATURE: ________________ Date: ________", ln=1, align='C')
+                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:
+                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"professional_workout_{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)
         
-        # HD VIDEO GENERATION
+        # VIDEO GENERATION
         video_path = None
-        if VIDEO_ENABLED and hd_templates:
+        if VIDEO_ENABLED and template_paths:
             try:
                 clips = []
-                duration_per_slide = 8
+                hd_width, hd_height = 1920, 1080
+                duration_per_slide = 6
                 
-                title_bg = ColorClip(size=(1920, 1080), color=(0, 50, 0)).set_duration(5)
+                # Title slide
+                title_clip = ColorClip(size=(hd_width, hd_height), color=(0, 128, 0)).set_duration(4)
                 title_text = TextClip(
-                    f"PROFESSIONAL GYM PROGRAM\n{clean_main_title.upper()}",
-                    fontsize=120, color='white', font='Arial-Bold',
-                    size=(1600, None)
-                ).set_position('center').set_duration(5)
-                title_slide = CompositeVideoClip([title_bg, title_text]).set_duration(5)
+                    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 template_img in hd_templates:
+                # Workout slides
+                for i, template_img in enumerate(template_paths):
                     if os.path.exists(template_img):
-                        img_clip = (ImageClip(template_img)
-                                   .set_duration(duration_per_slide)
-                                   .resize(height=1080)
-                                   .fx(vfx.fadein, 1)
-                                   .fx(vfx.fadeout, 1))
+                        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)
                 
-                video = concatenate_videoclips(clips, method="compose")
-                video_path = f"hd_workout_video_{timestamp}.mp4"
-                video.write_videofile(
-                    video_path,
-                    fps=30,
-                    codec='libx264',
-                    audio=False,
-                    bitrate="8000k",
-                    verbose=False,
-                    logger=None
-                )
-                video.close()
+                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 Exception as e:
                 print(f"Video error: {e}")
                 video_path = None
         
         # Cleanup
-        for path in hd_templates:
+        for path in template_paths:
             try:
                 os.remove(path)
             except:
                 pass
         
-        video_status = "✅ HD VIDEO GENERATED (1920x1080)" if video_path else "❌ Video Failed"
+        video_status = "HD Video Generated!" if video_path else "Video Generation Failed - Check MoviePy/FFmpeg"
         success_msg = f"""
-🎯 PROFESSIONAL GYM CONTENT GENERATED!
-
-📄 PDF: {len(names_list) + 1} premium pages
-🎥 {video_status}
-💪 Workouts: {len(names_list)} sessions
-🖼️ Images: {available_images} HD templates
+SUCCESS! Generated for {len(names_list)} workouts!
+PDF with generated screenshot templates
+{video_status}
+Images processed: {available_images}
         """
         
         return pdf_path, video_path, success_msg
         
     except Exception as e:
-        return None, None, f"❌ Error: {str(e)}"
+        return None, None, f"Error: {str(e)}"
 
-# FIXED UI - REMOVED 'info' parameter
-with gr.Blocks(
-    title="Professional Gym Workout Generator",
-    theme=gr.themes.Soft(primary_hue="green"),
-    css="""
-    .header {background: linear-gradient(135deg, #0f5132, #198754); color: white; padding: 30px; border-radius: 15px; text-align: center;}
-    .input-box {background: #f8fff9; padding: 20px; border-radius: 10px; border: 2px solid #198754;}
-    .btn-pro {background: linear-gradient(45deg, #198754, #0f5132) !important; font-size: 18px; padding: 15px;}
-    .status-pro {background: #d1e7dd; color: #0f5132; padding: 20px; border-radius: 10px; border-left: 5px solid #198754;}
-    """
-) as demo:
+# UI
+with gr.Blocks(title="Gym Workout Generator") as demo:
     
-    gr.HTML("""
-    <div class="header">
-        <h1>🏋️ PROFESSIONAL GYM GENERATOR</h1>
-        <p><strong>HD Video (1920x1080) + Premium PDF</strong></p>
-    </div>
-    """)
+    gr.Markdown("# Gym Workout Generator\nPDF + HD Video + Screenshot Templates")
     
     gr.Markdown("""
-    ### 🚀 Features:
-    - HD Video: 1920x1080 with workout names on each slide
-    - Premium PDF: Professional execution protocols
-    - Auto-generates gym templates from your images
-    - Each slide shows: WORKOUT # + NAME + Your image
+    ### How to Use:
+    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 Professional Strength Cycle",
-                elem_classes="input-box"
-            )
-            workout_names = gr.Textbox(
-                label="💪 WORKOUT NAMES * (Comma separated)",
-                placeholder="Chest Development, Leg Power, Back Strength, Arms & Shoulders, Core Blast",
-                lines=4,
-                elem_classes="input-box"
-            )
-        with gr.Column(scale=1):
-            images_input = gr.File(
-                label="📸 Workout Images *",
-                file_count="multiple",
-                file_types=["image"],
-                elem_classes="input-box"
-            )
+    main_title = gr.Textbox(label="MAIN PROGRAM TITLE *")
+    workout_names = gr.Textbox(label="WORKOUT NAMES * (Comma separated)")
     
-    generate_btn = gr.Button("🎬 Generate HD Video + Premium PDF", variant="primary", elem_classes="btn-pro")
+    images_input = gr.File(label="Images/Screenshots (Optional)", file_count="multiple", file_types=["image"])
     
-    with gr.Row():
-        pdf_output = gr.File(label="📄 Premium PDF Download")
-        video_output = gr.File(label="🎥 HD Video Download (1920x1080)")
+    generate_btn = gr.Button("Generate")
     
-    status = gr.Markdown("Ready to create professional gym content...", elem_classes="status-pro")
+    pdf_output = gr.File(label="PDF")
+    video_output = gr.File(label="HD Video")
+    status = gr.Markdown("Ready...")
     
     generate_btn.click(
-        fn=generate_professional_content,
+        fn=generate_content,
         inputs=[main_title, workout_names, images_input],
         outputs=[pdf_output, video_output, status]
     )