Update app.py

app.py

@@ -1,368 +1,508 @@
-import streamlit as st
-import argparse
-import requests
-import os
-from gtts import gTTS
-from PIL import Image, ImageDraw, ImageFont, ImageFilter
-from io import BytesIO
-import time
-import json
-from moviepy.editor import *
-from moviepy.video.tools.segmenting import findObjects
-from groq import Groq
-import numpy as np
-import random
-import base64
-#from huggingface_hub import InferenceClient
-import torch
-#from diffusers import CogVideoXImageToVideoPipeline
-#from diffusers.utils import export_to_video, load_image
-from scipy.ndimage import zoom
-from together import Together
-
-# Set page config
-st.set_page_config(
-    page_title="AI Video Ad Generator",
-    page_icon="🎥",
-    layout="wide"
-)
-
-# Add custom CSS
-st.markdown("""
-    <style>
-    .stButton>button {
-        width: 100%;
-        height: 3em;
-        background-color: #FF4B4B;
-        color: white;
-    }
-    .stTextInput>div>div>input {
-        background-color: #f0f2f6;
-    }
-    </style>
-    """, unsafe_allow_html=True)
-
-# API Keys
-GROQ_API_KEY = "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"
-TOGETHER_API_KEY = "dff7082474cf3265ac478ad65fb984f6f1bb773026ca099903291518bc76810a"  # Replace with your Together AI API key
-
-def text_to_speech(text, output_path):
-    tts = gTTS(text)
-    tts.save(output_path)
-
-def generate_image(prompt, max_retries=3, delay=5):
-    client = Together(api_key=TOGETHER_API_KEY)
-    
-    for attempt in range(max_retries):
-        try:
-            response = client.images.generate(
-                prompt=prompt,
-                model="black-forest-labs/FLUX.1-schnell-Free",
-                width=1024,
-                height=1024,
-                steps=4,
-                n=1,
-                response_format="b64_json"
-            )
-            
-            image_data = base64.b64decode(response.data[0].b64_json)
-            image = Image.open(BytesIO(image_data))
-            
-            print(f"Successfully generated image for prompt: {prompt}")
-            return image
-        except Exception as e:
-            print(f"Error generating image (attempt {attempt + 1}/{max_retries}): {e}")
-            if attempt < max_retries - 1:
-                wait_time = delay + random.uniform(0, 2)
-                print(f"Waiting for {wait_time:.2f} seconds before retrying...")
-                time.sleep(wait_time)
-            else:
-                print("Max retries reached. Returning default image.")
-                return Image.new('RGB', (1024, 1024), color='red')
-
-def generate_script(product_description):
-    client = Groq(api_key=GROQ_API_KEY)
-    prompt = f"""Create a 20-second advertisement script based on this description: {product_description}
-    
-    Create 3-4 scenes that total exactly 20 seconds. For each scene include:
-    1. A detailed visual description for image generation
-    2. Voice-over narration text (break into individual words for timed display)
-    3. On-screen caption text
-    4. Duration in seconds (use only numbers, e.g. 5 not '5 seconds')
-    
-    Format each scene like this:
-    SCENE 1
-    Visual: [detailed description]
-    Narration: [voice-over text]  
-    Caption: [on-screen text]
-    Duration: [number]
-    Format the output as JSON with this structure:
-    {{
-        "scenes": [
-            {{
-                "image_description": "detailed visual description",
-                "narration": "voiceover text",
-                "caption": "overlay text",
-                "words": ["word1", "word2", "word3"]
-            }}
-        ]
-    }}
-    
-    Make the scenes flow naturally and build excitement."""
-
-    response = client.chat.completions.create(
-        messages=[
-            {"role": "system", "content": "You are a professional advertising scriptwriter who creates compelling visual and narrative scripts."},
-            {"role": "user", "content": prompt}
-        ],
-        model="llama-3.1-70b-versatile",
-        max_tokens=1000
-    )
-    
-    try:
-        script_data = json.loads(response.choices[0].message.content)
-        for scene in script_data['scenes']:
-            scene['words'] = scene['narration'].split()
-    except json.JSONDecodeError:
-        script_data = {
-            "scenes": [
-                {
-                    "image_description": f"Professional product shot of {product_description} on clean white background with dramatic lighting and some text on the image and do not show the playbutton signe in the image",
-                    "narration": f"Introducing the revolutionary {product_description}",
-                    "caption": "Discover Innovation",
-                    "words": [f"Introducing", "the", "revolutionary", product_description]
-                },
-                {
-                    "image_description": f"Close-up shot showing key features of {product_description} with hands demonstrating use and some text on the image and do not show the playbutton signe in the image",
-                    "narration": "Experience unmatched quality and performance",
-                    "caption": "Superior Features",
-                    "words": ["Experience", "unmatched", "quality", "and", "performance"]
-                },
-                {
-                    "image_description": f"Lifestyle shot of people using {product_description} in real-world setting, warm lighting and some text on the image and do not show the playbutton signe in the image",
-                    "narration": "Transform your daily life",
-                    "caption": "Real Results",
-                    "words": ["Transform", "your", "daily", "life"]
-                },
-                {
-                    "image_description": f"Dynamic product shot of {product_description} with call-to-action graphics and some text on the image and do not show the playbutton signe in the image",
-                    "narration": "Don't wait - get yours today!",
-                    "caption": "Order Now",
-                    "words": ["Don't", "wait", "get", "yours", "today"]
-                }
-            ]
-        }
-    
-    return json.dumps(script_data)
-
-def create_text_image(text, size, font_color, font_path, font_size=80):
-    padding = 40
-    img = Image.new('RGBA', (size[0] + padding * 2, size[1] + padding * 2), (0, 0, 0, 0))
-    draw = ImageDraw.Draw(img)
-
-    try:
-        font = ImageFont.truetype(font_path, font_size, encoding="unic")
-    except IOError:
-        print(f"Warning: Could not load {font_path}. Using default font.")
-        font = ImageFont.load_default().font_variant(size=font_size)
-
-    text_bbox = draw.textbbox((0, 0), text, font=font)
-    text_width = text_bbox[2] - text_bbox[0]
-    text_height = text_bbox[3] - text_bbox[1]
-    x_text = (size[0] - text_width) / 2
-    y_text = (size[1] - text_height) / 2
-
-    # Draw text stroke
-    stroke_color = "black"
-    for adj in range(-3, 4):
-        draw.text((x_text+adj, y_text), text, font=font, fill=stroke_color)
-        draw.text((x_text, y_text+adj), text, font=font, fill=stroke_color)
-    
-    draw.text((x_text, y_text), text, font=font, fill=font_color)
-
-    img = img.filter(ImageFilter.GaussianBlur(radius=1))
-    return np.array(img)
-
-def image_to_video_ml(image, prompt, num_frames=49, fps=8):
-    try:
-        image_np = np.array(image) / 255.0
-        
-        def create_animation(frame):
-            # Enhanced zoom animation
-            zoom_factor = 1 + 0.15 * np.sin(frame * 2 * np.pi / num_frames)
-            zoomed = zoom(image_np, (zoom_factor, zoom_factor, 1), order=1)
-            
-            # Center crop
-            crop_start = [(zoomed.shape[i] - image_np.shape[i]) // 2 for i in range(2)]
-            cropped = zoomed[crop_start[0]:crop_start[0]+image_np.shape[0],
-                             crop_start[1]:crop_start[1]+image_np.shape[1]]
-            
-            # Enhanced pan animation
-            pan_x = int(80 * np.sin(frame * 2 * np.pi / num_frames))
-            pan_y = int(80 * np.cos(frame * 2 * np.pi / num_frames))
-            panned = np.roll(cropped, shift=(pan_y, pan_x), axis=(0, 1))
-            
-            # Add rotation
-            angle = 5 * np.sin(frame * 2 * np.pi / num_frames)
-            rotated = rotate(panned, angle, reshape=False)
-            
-            return rotated
-
-        animated_frames = []
-        for i in range(num_frames):
-            frame = create_animation(i)
-            if frame.shape[2] == 3:
-                animated_frames.append(frame)
-            else:
-                print(f"Skipping frame {i} due to unexpected shape: {frame.shape}")
-        
-        if len(animated_frames) == 0:
-            raise ValueError("No valid frames were generated")
-        
-        animated_frames = np.array(animated_frames)
-        noise = np.random.normal(0, 0.03, animated_frames.shape)
-        animated_frames = np.clip(animated_frames + noise, 0, 1)
-        animated_frames = (animated_frames * 255).astype(np.uint8)
-        
-        temp_video_path = f"temp_video_{int(time.time())}.mp4"
-        export_to_video(animated_frames, temp_video_path, fps=fps)
-        
-        return temp_video_path
-    except Exception as e:
-        print(f"Error in image_to_video_ml: {e}")
-        return None
-
-def generate_video(product_description, output_path, duration, font_color, font_path):
-    script_json = generate_script(product_description)
-    script_data = json.loads(script_json)
-    scenes = script_data['scenes']
-
-    print(f"Generated script with {len(scenes)} scenes")
-
-    full_narration = " ".join([scene['narration'] for scene in scenes])
-    audio_path = "audio.mp3"
-    text_to_speech(full_narration, audio_path)
-
-    print(f"Generated audio: {audio_path}")
-
-    scene_images = []
-    for scene in scenes:
-        image = generate_image(scene['image_description'])
-        scene_images.append(image)
-
-    print(f"Generated {len(scene_images)} images for scenes")
-
-    video_clips = []
-    scene_duration = duration / len(scenes)
-    for i, (scene, image) in enumerate(zip(scenes, scene_images)):
-        video_path = image_to_video_ml(image, scene['image_description'], num_frames=int(scene_duration * 24), fps=24)
-        if video_path:
-            video_clip = VideoFileClip(video_path)
-            # Add flip effect
-            if i % 2 == 0:  # Alternate between horizontal and vertical flips
-                video_clip = video_clip.fx(vfx.mirror_x)
-            else:
-                video_clip = video_clip.fx(vfx.mirror_y)
-            video_clips.append(video_clip)
-        else:
-           # print(f"Failed to generate video for scene {i+1}. Using static image instead.")
-            video_clip = ImageClip(np.array(image)).set_duration(scene_duration)
-            video_clips.append(video_clip)
-
-    # Create word-by-word text clips
-    text_clips = []
-    current_time = 0
-    for i, scene in enumerate(scenes):
-        words = scene['words']
-        word_duration = scene_duration / len(words)
-        
-        for word in words:
-            text_image = create_text_image(word, scene_images[0].size, font_color, font_path, font_size=100)
-            text_clip = ImageClip(text_image).set_duration(word_duration)
-            text_clip = text_clip.set_start(current_time)
-            text_clip = text_clip.set_position('center')
-            
-            # Add random animation effect for each word
-            effect = random.choice(['zoom', 'rotate', 'slide'])
-            if effect == 'zoom':
-                text_clip = text_clip.resize(lambda t: 1 + 0.3 * np.sin(t * 2 * np.pi))
-            elif effect == 'rotate':
-                text_clip = text_clip.rotate(lambda t: 20 * np.sin(t * 2 * np.pi))
-            else:  # slide
-                text_clip = text_clip.set_position(lambda t: ('center', 540 + 50 * np.sin(t * 2 * np.pi)))
-            
-            text_clip = text_clip.fadein(0.2).fadeout(0.2)
-            text_clips.append(text_clip)
-            current_time += word_duration
-
-    final_video = concatenate_videoclips(video_clips)
-    final_video = CompositeVideoClip([final_video] + text_clips)
-    audio_clip = AudioFileClip(audio_path)
-    final_clip = final_video.set_audio(audio_clip)
-
-    def vignette(image):
-        y, x = np.ogrid[:image.shape[0], :image.shape[1]]
-        center_x, center_y = image.shape[1] / 2, image.shape[0] / 2
-        mask = ((x - center_x)**2 + (y - center_y)**2) > (center_x**2 + center_y**2)
-        image[mask] = image[mask] * 0.8
-        return image
-
-    final_clip = final_clip.fl_image(vignette)
-    final_clip.write_videofile(output_path, fps=24)
-
-    os.remove(audio_path)
-    for clip in video_clips:
-        if hasattr(clip, 'filename') and os.path.exists(clip.filename):
-            os.remove(clip.filename)
-
-    print("Video generation completed successfully")
-    return True
-
-def main():
-    st.title("🎥 AI Video Ad Generator")
-    st.markdown("### Create professional video ads with AI")
-
-    with st.container():
-        col1, col2 = st.columns([2,1])
-        
-        with col1:
-            product_description = st.text_area(
-                "Product Description",
-                placeholder="Enter a detailed description of your product and its key features...",
-                height=150
-            )
-            
-        with col2:
-            output_path = st.text_input("Output Filename", value="ad.mp4")
-            duration = st.slider("Video Duration (seconds)", min_value=10, max_value=60, value=20)
-            font_color = st.color_picker("Text Color", value="#FFFFFF")
-            font_path = st.selectbox("Font Style", ["arial.ttf", "times.ttf", "calibri.ttf"])
-
-    if st.button("🚀 Generate Video Ad", type="primary"):
-        if not product_description:
-            st.error("Please enter a product description")
-            return
-            
-        with st.spinner("Generating your video ad..."):
-            success = generate_video(product_description, output_path, duration, font_color, font_path)
-            
-        if success:
-            st.success(f"Video generated successfully!")
-            
-            # Display the video
-            video_file = open(output_path, 'rb')
-            video_bytes = video_file.read()
-            st.video(video_bytes)
-            
-            # Download button
-            st.download_button(
-                label="Download Video",
-                data=video_bytes,
-                file_name=output_path,
-                mime="video/mp4"
-            )
-        else:
-            st.error("Failed to generate video. Please try again.")
-
-if __name__ == "__main__":
-    main()
+import streamlit as st
+from dataclasses import dataclass
+from typing import List, Dict, Optional
+from datetime import datetime
+import google.generativeai as genai
+import os
+from dotenv import load_dotenv
+from PIL import Image
+from langchain_groq import ChatGroq
+from langchain.schema import HumanMessage, SystemMessage
+import torch
+import numpy as np
+import plotly.graph_objects as go
+from fpdf import FPDF
+import time
+
+# Load environment variables
+load_dotenv()
+
+# Configure LLMs
+llm = ChatGroq(
+    temperature=0.2,
+    groq_api_key=os.environ.get("GROQ_API_KEY"),
+    model_name="llama-3.1-70b-versatile"
+)
+
+genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+model = genai.GenerativeModel(
+    model_name="gemini-1.5-pro",
+    generation_config={
+        "temperature": 0.2,
+        "top_p": 0.8,
+        "top_k": 40,
+        "max_output_tokens": 2048,
+    }
+)
+
+# Initialize session state for realtime.py components
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
+if 'user_data' not in st.session_state:
+    st.session_state.user_data = {
+        'progress': [],
+        'meal_logs': [],
+        'workout_logs': []
+    }
+
+# Code from acountable.py
+@dataclass
+class TransformationJourney:
+    user_id: str
+    goal_type: str  # fitness, skill, personal growth etc
+    start_date: datetime
+    progress_images: List[Dict[str, str]]  # [{date: image_path}]
+    feedback_history: List[Dict[str, str]]  # [{date: feedback}]
+    chat_history: List[Dict[str, str]]  # [{role: content}]
+
+class TransformationCoach:
+    def __init__(self):
+        self.model = model
+        self.llm = llm
+        
+    def analyze_image(self, image: Image) -> str:
+        prompt = """
+        As a transformation coach, analyze this image in relation to the user's goals.
+        Provide detailed observations about:
+        1. Current state/progress visible in the image
+        2. Areas of improvement
+        3. Notable achievements
+        Be specific and objective in your analysis.
+        """
+        response = self.model.generate_content([prompt, image])
+        return response.text
+    
+    def generate_feedback(self, analysis: str, goal_type: str) -> Dict[str, List[str]]:
+        prompt = f"""
+        Based on the following analysis of the user's progress image for their {goal_type} transformation:
+        {analysis}
+        
+        Provide structured feedback in the following format:
+        1. Specific "DO" recommendations (3-5 points)
+        2. Specific "DON'T" recommendations (2-3 points)
+        3. A motivational message
+        Make all feedback actionable and tailored to the analysis.
+        """
+        response = self.model.generate_content(prompt)
+        feedback_parts = response.text.split("\n\n")
+        return {
+            "dos": feedback_parts[0].split("\n")[1:],
+            "donts": feedback_parts[1].split("\n")[1:],
+            "motivation": feedback_parts[2]
+        }
+
+    def chat_response(self, question: str, context: List[Dict[str, str]], analysis: str = None) -> str:
+        prompt = f"""
+        You are a supportive transformation coach. Based on the following context:
+        
+        Previous chat: {str(context)}
+        Latest analysis: {analysis if analysis else 'No recent analysis'}
+        
+        User question: {question}
+        
+        Provide a helpful, encouraging response focused on their transformation journey.
+        """
+        response = self.llm.invoke(prompt)
+        return response.content
+
+# Functions from realtime.py
+def load_llm():
+    api_key = os.environ.get("GROQ_API_KEY")
+    if api_key is None:
+        st.error("GROQ_API_KEY is not set in the environment variables.")
+        return None
+    llm = ChatGroq(
+        api_key=api_key,
+        model_name="llama-3.1-70b-versatile",
+        temperature=0.7,
+        max_tokens=2048
+    )
+    return llm
+
+def analyze_image_realtime(image, task="meal"):
+    try:
+        if task == "meal":
+            prompt = """
+            As a nutrition expert, analyze this meal image and provide:
+            1. Estimated caloric content
+            2. Macro-nutrient breakdown
+            3. Nutritional assessment
+            4. Suggestions for improvement
+            5. Any potential health concerns
+            Be specific and detailed in your analysis.
+            """
+        else:  # workout form analysis
+            prompt = """
+            As a fitness expert, analyze this workout form and provide:
+            1. Form assessment
+            2. Potential injury risks
+            3. Specific corrections needed
+            4. Benefits of proper form
+            Be specific and detailed in your analysis.
+            """
+        response = model.generate_content([prompt, image])
+        return response.text
+    except Exception as e:
+        return f"Error analyzing image: {str(e)}"
+
+def track_progress(metric, value, date=None):
+    if date is None:
+        date = datetime.now().strftime("%Y-%m-%d")
+    
+    st.session_state.user_data['progress'].append({
+        'date': date,
+        'metric': metric,
+        'value': value
+    })
+
+def display_progress_chart():
+    if not st.session_state.user_data['progress']:
+        return
+    
+    data = st.session_state.user_data['progress']
+    fig = go.Figure()
+    
+    metrics = set(item['metric'] for item in data)
+    for metric in metrics:
+        metric_data = [item for item in data if item['metric'] == metric]
+        dates = [item['date'] for item in metric_data]
+        values = [item['value'] for item in metric_data]
+        
+        fig.add_trace(go.Scatter(x=dates, y=values, name=metric))
+    
+    fig.update_layout(title="Your Progress Over Time",
+                     xaxis_title="Date",
+                     yaxis_title="Value")
+    st.plotly_chart(fig)
+
+# Functions from workout.py
+def generate_meal_plan(weight, height, age, gender, activity_level, goal, dietary_restrictions, health_history, current_eating_habits, meal_preparation, budget, sleep):
+    """Generate personalized meal plan using LLM"""
+    prompt = f"""
+    Based on the following user data, generate a highly personalized and detailed daily meal plan with easily available ingredients:
+    
+    User Profile:
+    - Weight: {weight} kg
+    - Height: {height} cm 
+    - Age: {age}
+    - Gender: {gender}
+    - Activity Level: {activity_level}
+    - Goal: {goal}
+    - Dietary Restrictions: {', '.join(dietary_restrictions)}
+    - Health History: {health_history}
+    - Current Eating Habits: {current_eating_habits}
+    - Meal Preparation: {meal_preparation}
+    - Budget: {budget}
+    - Sleep: {sleep}
+
+    Generate a clear and structured meal plan with:
+
+    1. Total Daily Calorie Requirements
+    2. Macronutrient Distribution (in grams):
+       - Protein
+       - Carbohydrates  
+       - Fats
+
+    Daily Meal Schedule:
+    [Detailed meal schedule content...]
+    """
+    
+    response = llm.invoke(prompt)
+    return response.content
+
+def generate_workout_plan(goal, activity_level, target_areas, workout_time, current_fitness_level, exercise_preferences):
+    """Generate personalized workout plan using LLM"""
+    prompt = f"""
+    Based on:
+    - Fitness Goal: {goal}
+    - Activity Level: {activity_level}
+    - Target Areas: {target_areas}
+    - Workout Time: {workout_time}
+    - Current Fitness Level: {current_fitness_level}
+    - Exercise Preferences: {exercise_preferences}
+
+    Generate a clear and structured weekly workout plan:
+    [Detailed workout plan content...]
+    """
+    
+    response = llm.invoke(prompt)
+    return response.content
+
+def create_pdf(name, meal_plan, workout_plan):
+    pdf = FPDF()
+    pdf.add_page()
+    
+    pdf.set_font('Arial', 'B', 20)
+    pdf.cell(0, 10, f'Personalized Fitness Plan for {name}', ln=True, align='C')
+    pdf.ln(10)
+    
+    pdf.set_font('Arial', 'B', 16)
+    pdf.cell(0, 10, 'Meal Plan', ln=True)
+    pdf.set_font('Arial', '', 12)
+    pdf.multi_cell(0, 10, meal_plan)
+    
+    pdf.add_page()
+    pdf.set_font('Arial', 'B', 16)
+    pdf.cell(0, 10, 'Workout Plan', ln=True)
+    pdf.set_font('Arial', '', 12)
+    pdf.multi_cell(0, 10, workout_plan)
+    
+    return pdf
+
+def main():
+    st.set_page_config(page_title="AI Fitness Coach", layout="wide")
+    
+    # Chat input needs to be outside tabs
+    user_input = st.chat_input("Type your message here...")
+    if user_input:
+        st.session_state.chat_history.append({"role": "user", "content": user_input})
+        
+        # Process user input with LLM
+        llm = load_llm()
+        if llm is not None:
+            messages = [
+                SystemMessage(content="You are an expert health and fitness coach. Provide detailed and personalized advice."),
+                HumanMessage(content=user_input)
+            ]
+            response = llm(messages)
+            
+            st.session_state.chat_history.append({"role": "assistant", "content": response.content})
+    
+    tab1, tab2, tab3 = st.tabs(["Transformation Journey", "Realtime Tracking", "Workout & Meal Plans"])
+    
+    with tab1:
+        # Implementation from acountable.py
+        st.title("Transformation Journey Tracker")
+        
+        if 'coach' not in st.session_state:
+            st.session_state.coach = TransformationCoach()
+        if 'journey' not in st.session_state:
+            st.session_state.journey = None
+            
+        # Initialize or load journey
+        if not st.session_state.journey:
+            with st.form("journey_setup"):
+                st.write("Let's start your transformation journey!")
+                user_id = st.text_input("Enter your user ID")
+                goal_type = st.selectbox(
+                    "What type of transformation?",
+                    ["Fitness", "Skill Development", "Personal Growth", "Other"]
+                )
+                if st.form_submit_button("Start Journey"):
+                    st.session_state.journey = TransformationJourney(
+                        user_id=user_id,
+                        goal_type=goal_type,
+                        start_date=datetime.now(),
+                        progress_images=[],
+                        feedback_history=[],
+                        chat_history=[]
+                    )
+        
+        # Main interaction area
+        if st.session_state.journey:
+            st.subheader("Upload Progress Image")
+            uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"], key="transform_uploader")
+            
+            if uploaded_file:
+                image = Image.open(uploaded_file)
+                st.image(image, caption="Uploaded Image", use_column_width=True)
+                
+                if st.button("Analyze and Get Feedback"):
+                    with st.spinner("Analyzing your progress..."):
+                        analysis = st.session_state.coach.analyze_image(image)
+                        feedback = st.session_state.coach.generate_feedback(
+                            analysis, 
+                            st.session_state.journey.goal_type
+                        )
+                        
+                        # Display feedback
+                        st.subheader("Your Personalized Feedback")
+                        
+                        st.write("🎯 DO:")
+                        for do in feedback["dos"]:
+                            st.write(f"✓ {do}")
+                            
+                        st.write("⚠️ DON'T:")
+                        for dont in feedback["donts"]:
+                            st.write(f"✗ {dont}")
+                            
+                        st.write("💪 Motivation:")
+                        st.write(feedback["motivation"])
+                        
+                        # Store progress
+                        current_time = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+                        image_path = f"progress_images/{st.session_state.journey.user_id}_{current_time}.jpg"
+                        st.session_state.journey.progress_images.append({
+                            current_time: image_path
+                        })
+                        st.session_state.journey.feedback_history.append({
+                            current_time: feedback
+                        })
+            
+            # Chat interface
+            st.write("---")
+            st.subheader("Chat with Your Coach")
+            
+            # Display chat history
+            for message in st.session_state.journey.chat_history:
+                if message["role"] == "user":
+                    st.write("You: " + message["content"])
+                else:
+                    st.write("Coach: " + message["content"])
+            
+            # Chat input
+            user_question = st.text_input("Ask your coach anything:", key="transform_chat")
+            if st.button("Send", key="transform_send"):
+                if user_question:
+                    # Add user message
+                    st.session_state.journey.chat_history.append({
+                        "role": "user",
+                        "content": user_question
+                    })
+                    
+                    # Get coach's response
+                    latest_analysis = st.session_state.coach.analyze_image(image) if uploaded_file else None
+                    response = st.session_state.coach.chat_response(
+                        user_question,
+                        st.session_state.journey.chat_history,
+                        latest_analysis
+                    )
+                    
+                    # Add coach's response
+                    st.session_state.journey.chat_history.append({
+                        "role": "coach",
+                        "content": response
+                    })
+                    
+                    st.experimental_rerun()
+
+    with tab2:
+        # Implementation from realtime.py
+        st.title("AI Health Coach")
+        
+        st.warning("""This system is for informational purposes only and is not a substitute for professional medical advice, 
+                    diagnosis, or treatment. Always seek the advice of your physician or other qualified health provider.""")
+        
+        # Display chat history
+        for message in st.session_state.chat_history:
+            with st.chat_message(message["role"]):
+                st.write(message["content"])
+        
+        # Image upload and analysis
+        uploaded_file = st.file_uploader("Upload an image for analysis (meal or workout form)", type=['png', 'jpg', 'jpeg'], key="realtime_uploader")
+        if uploaded_file:
+            image = Image.open(uploaded_file)
+            st.image(image, caption="Uploaded Image")
+            
+            analysis_type = st.radio("What would you like to analyze?", ["Meal", "Workout Form"])
+            if st.button("Analyze Image", key="realtime_analyze"):
+                with st.spinner("Analyzing image..."):
+                    results = analyze_image_realtime(image, analysis_type.lower())
+                    st.write("Analysis Results:", results)
+        
+        # Progress tracking section
+        with st.expander("Track Your Progress"):
+            metric = st.selectbox("Select metric to track", ["Weight", "Body Fat %", "Workout Duration", "Calories"])
+            value = st.number_input("Enter value", key="progress_value")
+            if st.button("Log Progress", key="log_progress"):
+                track_progress(metric, value)
+                st.success("Progress logged successfully!")
+        
+        # Display progress charts
+        display_progress_chart()
+
+    with tab3:
+        # Implementation from workout.py
+        st.title("AI Fitness Coach")
+        st.markdown("<h1 style='text-align: center; color: #4CAF50;'>Welcome to Your Personalized Fitness Journey!</h1>", unsafe_allow_html=True)
+        
+        # Get user inputs
+        st.header("Personal Information")
+
+        col1, col2, col3 = st.columns(3)
+
+        with col1:
+            name = st.text_input("What's your name?", placeholder="Enter your name")
+            age = st.number_input("What's your age?", min_value=1, max_value=120, value=25)
+            gender = st.selectbox("What's your gender?", ["Male", "Female"])
+            health_history = st.text_input("Do you have any medical conditions?")
+
+        with col2:
+            weight = st.number_input("What's your weight (in kg)?", min_value=1, value=70)
+            height = st.number_input("What's your height (in cm)?", min_value=1, value=170)
+            goal = st.selectbox(
+                "What's your fitness goal?",
+                ["Weight Loss", "Muscle Gain", "Maintenance", "General Fitness"],
+                index=0
+            )
+            activity_level = st.selectbox(
+                "What's your activity level?",
+                [
+                    "Sedentary (little to no exercise)",
+                    "Lightly Active (1-3 days/week)",
+                    "Moderately Active (3-5 days/week)",
+                    "Very Active (6-7 days/week)",
+                    "Extra Active (very intense exercise daily)"
+                ]
+            )
+
+        with col3:
+            dietary_restrictions = st.multiselect(
+                "Do you have any dietary restrictions?",
+                ["None", "Vegetarian", "Vegan", "Gluten-Free", "Dairy-Free", "Keto"]
+            )
+            current_eating_habits = st.text_input("What does your current diet look like?")
+            meal_preparation = st.text_input("Do you cook your meals or rely on takeout?")
+            budget = st.number_input("What is your monthly budget for groceries/food?", min_value=0)
+
+        if st.button("Generate Plans", key="generate_plans"):
+            if not name or not goal or not age or not gender or not weight or not height or not activity_level:
+                st.error("Please fill in all required fields")
+                return
+                
+            with st.spinner("Generating your personalized plans..."):
+                meal_plan = generate_meal_plan(
+                    weight=weight,
+                    height=height,
+                    age=age,
+                    gender=gender,
+                    activity_level=activity_level,
+                    goal=goal,
+                    dietary_restrictions=dietary_restrictions if dietary_restrictions else ["None"],
+                    health_history=health_history,
+                    current_eating_habits=current_eating_habits,
+                    meal_preparation=meal_preparation,
+                    budget=budget,
+                    sleep="8 hours"  # Default value
+                )
+                workout_plan = generate_workout_plan(
+                    goal=goal,
+                    activity_level=activity_level,
+                    target_areas="full body",  # Default value
+                    workout_time=60,  # Default value
+                    current_fitness_level="Beginner",  # Default value
+                    exercise_preferences="None"  # Default value
+                )
+                
+                # Create PDF
+                pdf = create_pdf(name, meal_plan, workout_plan)
+                
+                # Display plans in two columns
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.subheader("Your Meal Plan")
+                    st.write(meal_plan)
+                with col2:
+                    st.subheader("Your Workout Plan")
+                    st.write(workout_plan)
+                
+                # Add download button
+                st.download_button(
+                    label="Download Plan as PDF",
+                    data=pdf.output(dest='S').encode('latin-1'),
+                    file_name=f"fitness_plan_{name}.pdf",
+                    mime="application/pdf"
+                )
+
+if __name__ == "__main__":
+    main()