Refactored and removed controlnet

app.py

@@ -12,7 +12,6 @@ card_with_message_1_image = Image.open("img/card_with_message_1.png")
 card_with_message_2_image = Image.open("img/card_with_message_2.png")
 
 
-
 # Fireworks Logo at the top
 st.image(logo_image)
 
@@ -23,8 +22,41 @@ st.title("🎨 Flux Holiday Magic: Custom Card Creator")
 # Description using Streamlit text and markdown
 st.markdown("""
 Welcome to the ultimate holiday card design experience! 🎄❄️ 
-            
-\n Powered by **Flux models** through **Fireworks API**, this app lets you effortlessly create stunning, personalized holiday cards with just a few clicks. Here’s what you can do:
+
+Powered by **Flux models** through **Fireworks API**, this app lets you effortlessly create stunning, personalized holiday cards with just a few clicks. Here’s what each page allows you to do:
+""")
+
+# Overview of the pages with descriptions
+st.markdown("""
+### 1. **Generate Holiday Postcard: 🎇 FLUX-tastic Holiday Postcard Generator 🎨**
+Get ready to make your holiday greetings pop with a personalized, AI-generated postcard! 🎅🎨 No more boring, store-bought cards. Customize a dazzling holiday scene with your own snazzy message and festive designs, brought to life by **FLUX models**.
+
+**How it works:**
+- Choose a holiday-themed prompt or write your own 🎉
+- Select a FLUX model to bring your vision to life ✨
+- Customize with fonts, text backgrounds, and colors 🎨
+- Generate and share your festive masterpiece with friends and family 📬
+
+### 2. **Generate Multiple Holiday Borders: 🎨 Holiday Multi-Card Generator 🎨**
+This page is your first stop for crafting a holiday card with multiple festive border designs. 🌟 Play around with different styles, prompts, and parameters to design the perfect card border before adding your message in the next step.
+
+**How it works:**
+- 🖼️ **Upload Your Image**: Choose the image that will be the centerpiece of your card.
+- ✂️ **Crop & Adjust**: Fine-tune the crop to highlight the most important parts of your image.
+- 💡 **Choose Your Style**: Select from festive borders or input your own custom prompt.
+- ⚙️ **Fine-Tune**: Experiment with guidance scales, seeds, inference steps, and more for the perfect aesthetic.
+- 👀 **Preview & Download**: See your designs, tweak them, and download them as a ZIP file.
+
+After perfecting your border, head over to Part B to add a personal message!
+
+### 3. **Customize Holiday Borders: 🎄 Holiday Card Customizer 🎅**
+✨ Welcome to the final part of your holiday card creation journey! It’s time to add a festive border and a personal message to your card.
+
+**How it works:**
+- 🎁 **Upload Your Image**: Select a photo or design to be the star of your holiday card.
+- ✨ **Design Your Holiday Border**: Choose from seasonal prompts or create a unique custom border.
+- 💌 **Add Your Personal Message**: Write a heartfelt, funny, or warm message to spread holiday cheer.
+- 📦 **Download Your Finished Card**: Ready to send to friends and family as a gift of joy! 🎉
 """)
 
 # Features list with emojis
@@ -36,7 +68,7 @@ st.markdown("""
 - **Advanced Customization**: Take control of parameters like ControlNet conditioning, guidance scale, inference steps, and more for tailored results.
 - **Save & Share**: Download your final creations or save them for later in a handy ZIP file.
             
-And be sure to share with us on social!
+And be sure to share with us on social media!
             
 ![Holiday Vibes](https://i.giphy.com/media/v1.Y2lkPTc5MGI3NjExMXo5Y3RhOGNzaTkzZHFmandsZmF0MW9jNHN4M3VjMjdpOGhyYnRxMSZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/637gfK5GJdv552H9ab/giphy.gif)
 """)
@@ -46,9 +78,17 @@ st.markdown("""
 Get started now and add a magical touch to your holiday greetings! 🎅🌟
 """)
 
+# Divider for sections
 st.divider()
-st.subheader("Experiment with Flux to figure out the perfect look for your holiday card")
-st.markdown(""" ![For science!](https://i.giphy.com/media/v1.Y2lkPTc5MGI3NjExbGwwdGh4czc3bnU3czNzaWRhaXl4YXYzdm53Nmw1OXhpd2E4emFuYSZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/RdJIM4Uesg37eN1ZNL/giphy.gif)""")
+
+# Subheader for experimenting with Flux models
+st.subheader("🎨 Experiment with Flux to design your perfect holiday card border 🎄")
+st.markdown("""
+Use different parameters and prompts to customize your holiday card design.  
+Play around with borders, colors, and styles to find the festive magic you're looking for. 🎁
+
+![For science!](https://i.giphy.com/media/v1.Y2lkPTc5MGI3NjExbGwwdGh4czc3bnU3czNzaWRhaXl4YXYzdm53Nmw1OXhpd2E4emFuYSZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/RdJIM4Uesg37eN1ZNL/giphy.gif)
+""")
 col1, col2 = st.columns(2)
 
 with col1:
@@ -59,13 +99,19 @@ with col2:
     st.image(parameters_2_image)
     st.image(parameters_4_image)
 
+# Divider for sections
+st.divider()
 
+# Subheader for adding custom messages
+st.subheader("💌 Customize Your Holiday Card with a Special Message 💌")
+st.markdown("""
+Add the final touch with a heartfelt, funny, or creative message!  
+Choose your font, color, and size to make your holiday message pop! 🎉
 
-st.divider()
-st.subheader("Customize your holiday card with a special message")
-st.markdown(""" ![Special message, so special](https://i.giphy.com/media/v1.Y2lkPTc5MGI3NjExenVkdmZzZTdxNjIxcDk2b2NrdXUxbDBneTNqdHUyamFxNTQzd2dleiZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/qDJSK8oxEkBV0XJE7B/giphy.gif)""")
+![Special message, so special](https://i.giphy.com/media/v1.Y2lkPTc5MGI3NjExenVkdmZzZTdxNjIxcDk2b2NrdXUxbDBneTNqdHUyamFxNTQzd2dleiZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/qDJSK8oxEkBV0XJE7B/giphy.gif)
+""")
 col3, col4 = st.columns(2)
 with col3:
     st.image(card_with_message_1_image)
 with col4:
-    st.image(card_with_message_2_image)
+    st.image(card_with_message_2_image)

pages/1_Generate_Holiday_Postcard.py

@@ -1,236 +1,153 @@
-import os
-import requests
-from dotenv import load_dotenv
-from PIL import Image, ImageDraw, ImageFont
-from io import BytesIO
-import streamlit as st
-import textwrap
-from PIL import ImageColor
+# Generate_Holiday_Postcard.py
 
+import streamlit as st
+from utils.helper_utilities import generate_flux_image, add_custom_message
+from utils.configuration import fonts, holiday_scene_prompts, example_holiday_messages
+from dotenv import load_dotenv
+import os
 
 # Set page configuration
 st.set_page_config(page_title="FLUX Image Generation Tool", page_icon="🎇")
 
-# Correct the path to the .env file to reflect its location
-dotenv_path = os.path.join(os.path.dirname(__file__), '../env/.env')
-
-# Load environment variables from the .env file
-load_dotenv(dotenv_path, override=True)
-
-# Get the Fireworks API key from the .env file
-fireworks_api_key = os.getenv("FIREWORKS_API_KEY")
-
-if not fireworks_api_key:
-    st.error("API key not found. Make sure FIREWORKS_API_KEY is set in the .env file.")
-
-# Define the fonts you want to allow
-fonts = {
-    "DejaVu Sans Bold": "./fonts/dejavu-sans-bold.ttf",
-    "Covered By You": "./fonts/CoveredByYourGrace-Regular.ttf",
-    "Julee Regular": "./fonts/Julee-Regular.ttf",
-    "Kalam Regular": "./fonts/Kalam-Regular.ttf",
-    "Knewave Regular": "./fonts/Knewave-Regular.ttf",
-    "Sancreek Regular": "./fonts/Sancreek-Regular.ttf",
-    "Vast Shadow Regular": "./fonts/VastShadow-Regular.ttf",
-}
-
-# Holiday-themed prompts list
-holiday_prompts = [
-    "A peaceful winter landscape covered in fresh snow, with delicate snowflakes drifting through the air and soft, frosty patterns along the edges, creating a serene holiday card",
-    "A cozy Christmas scene featuring a warmly lit cabin in the woods, surrounded by snow-covered trees and twinkling holiday lights, with a sky glowing softly in the background",
-    "A fireplace with stockings, garlands, and a glowing hearth, set in a cozy room decorated for the holidays, capturing the warmth and tranquility of the season",
-    "A colorful Hanukkah celebration with glowing menorahs, dreidels, and shimmering holiday lights illuminating the night, set against a rich, deep blue backdrop for a festive scene",
-    "A vibrant New Year's Eve cityscape with bright fireworks exploding in the sky, colorful confetti drifting through the air, and stars twinkling above the skyline, radiating excitement",
-    "A mystical Samhain forest scene, with pumpkins glowing softly among tall trees, and a full moon casting light over an ancient Celtic stone circle, evoking an air of magic and mystery",
-    "A lively Día de Muertos altar adorned with colorful calaveras, bright marigold flowers, and glowing candles, set against a traditional Mexican backdrop, celebrating the holiday’s joy",
-    "A wintery Yule forest scene under a starry sky, with snow-covered pine trees, holly bushes, and traditional Norse winter symbols decorating the landscape, capturing the warmth of the season",
-    "A bright and vibrant Diwali celebration with glowing diyas lining a courtyard, intricate rangoli patterns on the ground, and colorful fireworks lighting up the night sky",
-    "A serene Kwanzaa scene featuring a kinara with glowing candles, surrounded by decorations in red, black, and green, set in a peaceful and reflective atmosphere",
-    "A bountiful Thanksgiving table scene set outdoors, surrounded by autumn leaves, pumpkins, and a golden sunset, capturing the essence of gratitude and togetherness",
-    "A tranquil Winter Solstice night with a glowing full moon above, bare trees, stars twinkling in the sky, and a peaceful blanket of snow covering the quiet landscape",
-    "A festive St. Patrick's Day scene featuring a green countryside, with shamrocks covering the rolling hills, a rainbow stretching across the sky, and a pot of gold in the distance",
-    "A colorful Lunar New Year street scene with red lanterns hanging from the rooftops, dragon dancers parading down the street, and vibrant fireworks lighting up the night",
-    "A peaceful Easter garden filled with blooming spring flowers, pastel-colored eggs hidden among the grass, and soft sunlight streaming through the trees",
-    "A romantic Valentine's Day scene with glowing candles, heart-shaped decorations hanging from tree branches, and a soft pink and red sunset in the sky",
-    "A lively Holi celebration in an open field, with bursts of vibrant color powder filling the air, and people joyfully celebrating under a bright blue sky",
-    "A tranquil Ramadan evening scene with a crescent moon and stars hanging in the night sky, glowing lanterns decorating the streets, and peaceful reflections along a quiet river",
-    "A lively Independence Day celebration with colorful fireworks lighting up the night sky, flags waving in the breeze, and a peaceful lakeside reflecting the celebration"
-]
-
-# Example messages corresponding to each holiday prompt
-example_messages = [
-    "Wishing you peace and serenity this winter season. May the snow bring you joy and tranquility!",
-    "May your Christmas be as cozy and warm as a cabin in the woods, filled with holiday lights and love.",
-    "Warm wishes for the holidays! May your hearth and home be filled with love and joy this season.",
-    "Happy Hanukkah! May the light of the menorah shine brightly and bring joy to your heart.",
-    "Wishing you a vibrant New Year's Eve filled with excitement, fireworks, and joy for the year ahead!",
-    "May the magic and mystery of Samhain fill your spirit with wonder. Have a mystical holiday!",
-    "Celebrating the joy of Día de Muertos! May the memories of your loved ones bring peace and happiness.",
-    "Wishing you a Yule season filled with the warmth of the Norse tradition and the beauty of snowy forests.",
-    "Happy Diwali! May the lights of the diyas and the colors of rangoli bring you prosperity and joy.",
-    "Wishing you a reflective and peaceful Kwanzaa. May your home be filled with love, light, and unity.",
-    "Happy Thanksgiving! May your table be filled with gratitude, and your heart with the warmth of togetherness.",
-    "Wishing you a peaceful Winter Solstice night under the full moon. May the season bring you reflection and rest.",
-    "May the luck of the Irish be with you! Wishing you a joyful St. Patrick's Day filled with rainbows and gold.",
-    "Happy Lunar New Year! May the dragon dancers bring joy, and the fireworks light up a prosperous new year.",
-    "Wishing you a peaceful Easter surrounded by blooming flowers and the warmth of springtime sunshine.",
-    "Happy Valentine's Day! May your day be filled with love, glowing candles, and heartwarming moments.",
-    "Wishing you a joyful Holi! May the colors of the festival fill your life with vibrancy and happiness.",
-    "Ramadan Mubarak! May the crescent moon bring you peace, and the lanterns light up your spiritual path.",
-    "Happy Independence Day! May the fireworks light up the sky, and may freedom continue to inspire us all."
-]
-
-
-
-# Function to make requests to the FLUX models
-def generate_flux_image(model_path, prompt, steps):
-    url = f"https://api.fireworks.ai/inference/v1/workflows/accounts/fireworks/models/{model_path}/text_to_image"
-    headers = {
-        "Authorization": f"Bearer {fireworks_api_key}",
-        "Content-Type": "application/json",
-        "Accept": "image/jpeg"
-    }
-    data = {
-        "prompt": prompt,
-        "aspect_ratio": "16:9",
-        "guidance_scale": 3.5,
-        "num_inference_steps": steps,
-        "seed": 0
-    }
-
-    # Send the request
-    response = requests.post(url, headers=headers, json=data)
-    
-    if response.status_code == 200:
-        # Convert the response to an image
-        img_data = response.content
-        img = Image.open(BytesIO(img_data))
-        return img
-    else:
-        raise RuntimeError(f"Error with FLUX model {model_path}: {response.text}")
-
-# Function to wrap text to a specified number of characters
-def wrap_text(text, max_chars):
-    """Wrap text to a specified number of characters per line."""
-    return "\n".join(textwrap.fill(line, width=max_chars) for line in text.split("\n"))
-
-# Function to add the holiday message to the image
-from PIL import ImageColor, ImageDraw, ImageFont, Image
-
-# Function to add the holiday message to the image
-def add_custom_message(image, message, font_path, font_size, position_vertical, position_horizontal, max_chars, bg_color, font_color, alpha):
-    try:
-        font = ImageFont.truetype(font_path, font_size)
-    except IOError:
-        font = ImageFont.load_default()
+# Streamlit UI Elements
+st.title("🎇 FLUX-tastic Holiday Postcard Generator 🎨")
+st.markdown(
+    """Welcome to the FLUX Holiday Postcard Generator! 
 
-    # Convert image to RGBA if it's not already
-    if image.mode != "RGBA":
-        image = image.convert("RGBA")
+- 🎅🎨 It's time to make your holiday greetings pop with a personalized, AI-generated postcard! 
+- ✨ No more boring, store-bought cards! Instead, flex your creative muscles with the FLUX models, adding your unique touch. 
+- Customize a dazzling holiday scene with your own message and share your festive vibes! 🎁🎄
 
-    # Create an overlay image with the same size and transparency (RGBA mode)
-    overlay = Image.new("RGBA", image.size, (255, 255, 255, 0))  # Fully transparent
+### How it works:
 
-    draw = ImageDraw.Draw(overlay)
+1. Choose a holiday-themed prompt or write your own 🎉
+2. Select a FLUX model to bring your vision to life ✨
+3. Customize with a snazzy holiday message and choose from a variety of fonts 🖋️ 
+4. Design your text's background and color to perfectly match the vibe 🎨 
+5. Generate your masterpiece and share the joy with friends and family! 📬
 
-    # Wrap the text based on the max_chars input
-    message = wrap_text(message, max_chars)
+Get ready to deck the halls with creativity! 🎄✨
 
-    img_width, img_height = image.size
+"""
+)
 
-    # Calculate the text bounding box dynamically
-    text_lines = message.split("\n")
-    line_height = draw.textbbox((0, 0), "A", font=font)[3]  # Get height of one line of text
-    total_text_height = line_height * len(text_lines)
-    text_width = max([draw.textbbox((0, 0), line, font=font)[2] for line in text_lines])
+st.divider()
+st.subheader("Load Fireworks API Key")
 
-    # Horizontal positioning
-    if position_horizontal == "Left":
-        x_pos = 10  # Padding from the left
-    elif position_horizontal == "Center":
-        x_pos = (img_width - text_width) // 2
-    else:  # "Right"
-        x_pos = img_width - text_width - 10  # Padding from the right
+# Load API Key
+# Define and ensure the .env directory and file exist
+dotenv_path = os.path.join(os.path.dirname(__file__), '..', 'env', '.env')
+os.makedirs(os.path.dirname(dotenv_path), exist_ok=True)
 
-    # Vertical positioning
-    if position_vertical == "Top":
-        y_pos = 10  # Padding from the top
-    elif position_vertical == "Center":
-        y_pos = (img_height - total_text_height) // 2
-    else:  # "Bottom"
-        y_pos = img_height - total_text_height - 10  # Padding from the bottom
+# Create the .env file if it doesn't exist
+if not os.path.exists(dotenv_path):
+    with open(dotenv_path, "w") as f:
+        st.success(f"Created {dotenv_path}")
 
-    # Define the padding for the background box behind the text
-    padding = 10
-
-    # Convert the user-specified background color to RGBA and apply the alpha transparency value
-    bg_color_rgba = (*ImageColor.getrgb(bg_color), alpha)  # Apply user-controlled transparency
-
-    # Draw the semi-transparent background rectangle on the overlay
-    draw.rectangle([x_pos - padding, y_pos - padding, x_pos + text_width + padding, y_pos + total_text_height + padding], fill=bg_color_rgba)
-
-    # Draw the text line by line with the user-specified font color
-    for i, line in enumerate(text_lines):
-        draw.text((x_pos, y_pos + i * line_height), line, font=font, fill=font_color)
-
-    # Composite the overlay with the original image
-    combined = Image.alpha_composite(image, overlay)
-
-    return combined.convert("RGB")  # Convert back to RGB for saving/display
+# Load environment variables from the .env file
+load_dotenv(dotenv_path, override=True)
 
+# Check if the Fireworks API key is set or blank
+fireworks_api_key = os.getenv("FIREWORKS_API_KEY")
 
+# Show the entire app but disable running parts if no API key
+if not fireworks_api_key or fireworks_api_key.strip() == "":
+    fireworks_api_key = st.text_input("Enter Fireworks API Key", type="password")
 
+    # Optionally, allow the user to save the API key to the .env file
+    if fireworks_api_key and st.checkbox("Save API key for future use"):
+        with open(dotenv_path, "a") as f:
+            f.write(f"FIREWORKS_API_KEY={fireworks_api_key}\n")
+        st.success("API key saved to .env file.")
+else:
+    st.success(f"API key loaded successfully: partial preview {fireworks_api_key[:5]}")
 
-# Streamlit UI
-st.title("FLUX Image Generation")
-st.write("Generate images using the FLUX models and customize them with a holiday message.")
 
 # Dropdown to select a holiday-themed prompt or enter a custom prompt
-selected_prompt = st.selectbox("Choose a holiday-themed prompt or enter your own", options=["Custom"] + holiday_prompts)
+st.divider()
+st.subheader("1️⃣ Step 1: Pick Your Holiday Theme or Create Your Own 🎄✨")
+st.markdown(""" 
+Get into the festive spirit by choosing from a range of holiday-inspired prompts. Feeling extra creative? Enter your own prompt and let the holiday magic begin! 🎅✨
+""")
+
+selected_prompt = st.selectbox("Choose a holiday-themed prompt or enter your own", options=["Custom"] + holiday_scene_prompts)
 custom_prompt = st.text_input("Enter your custom prompt") if selected_prompt == "Custom" else ""
 prompt = custom_prompt if selected_prompt == "Custom" else selected_prompt
 
 # Dropdown to select the model
-model_choice = st.selectbox("Select the model:", ["flux-1-schnell", "flux-1-dev"])
+st.divider()
+st.subheader("2️⃣ Step 2: Select Your FLUX Model 🚀")
+st.markdown(""" 
+Choose from two FLUX models: whether you’re aiming for lightning speed or extra detail, we’ve got you covered! 💥✨
+""")
+
+model_choice = st.selectbox("Select the model:", ["flux-1-schnell-fp8", "flux-1-dev-fp8"])
 
 # Dropdown to select an example message or write a custom one
-selected_message = st.selectbox("Choose an example message or write your own:", options=["Custom"] + example_messages)
+st.divider()
+st.subheader("3️⃣ Step 3: Craft the Perfect Message 🎁")
+st.markdown(""" 
+What’s a holiday card without a heartfelt (or hilarious) message? Choose from example holiday greetings or write your own to make the card so you! 🖋️🎉
+""")
+
+selected_message = st.selectbox("Choose an example message or write your own:", options=["Custom"] + example_holiday_messages)
 message = st.text_input("Enter a holiday message to add:", value=selected_message if selected_message != "Custom" else "")
 
 # Additional inputs for customizing the message
+st.divider()
+st.subheader("4️⃣ Step 4: Style Your Message with Flair ✨")
+st.markdown(""" 
+From fancy fonts to colorful backgrounds, you’re in control. Pick your favorite font, adjust the size, and add a splash of color to make your message truly shine. 🌈🎨
+""")
+
 font_choice = st.selectbox("Select a font:", list(fonts.keys()))
-font_size = st.slider("Select font size:", 10, 100, 40)
+font_size = st.slider("Select font size:", 1, 300, 40)
 max_chars = st.slider("Max characters per line:", 10, 100, 40)  # Slider to select character wrap limit
 
 # Background color and font color pickers
 bg_color = st.color_picker("Pick a background color for the text box:", "#FFFFFF")
 font_color = st.color_picker("Pick a font color:", "#000000")
 
-# **Add a transparency slider for controlling the alpha channel**
+# Transparency level slider
 alpha = st.slider("Select transparency level for the background (0: fully transparent, 255: fully opaque)", 0, 255, 220)
 
 # Position options for the message (vertical and horizontal)
 position_vertical = st.radio("Select message vertical position:", ["Top", "Center", "Bottom"])
 position_horizontal = st.radio("Select message horizontal position:", ["Left", "Center", "Right"])
 
+st.divider()
+st.subheader("5️⃣ Step 5: Preview and Share the Holiday Cheer! 🎅📬")
+st.markdown(""" 
+Click "Generate Image" and watch the magic happen! Your holiday card is just moments away from spreading joy to everyone on your list. 🎄🎁✨
+""")
 
 # Button to generate images
-if st.button("Generate Image"):
+if not fireworks_api_key or fireworks_api_key.strip() == "":
+    st.warning("Enter a valid Fireworks API key to enable image generation.")
+    generate_button = st.button("Generate Image", disabled=True)
+else:
+    generate_button = st.button("Generate Image")
+
+
+if generate_button:
+    st.markdown(""" 
+        🎉 You're one click away from holiday magic! 🎉 Hit that Generate Image button and let FLUX create your personalized postcard—ready for sharing! 📬
+        """)
     if not prompt.strip():
         st.error("Please provide a prompt.")
     else:
         try:
             with st.spinner("Generating image..."):
                 # Determine steps based on model
-                steps = 30 if model_choice == "flux-1-dev" else 4
+                steps = 30 if model_choice == "flux-1-dev-fp8" else 4
 
-                # Generate image
-                generated_image = generate_flux_image(model_choice, prompt, steps)
+                # Generate image using the helper utility
+                generated_image = generate_flux_image(model_choice, prompt, steps, fireworks_api_key)
 
-                # Get the selected font path
+                # Get the selected font path from configuration
                 font_path = fonts[font_choice]
 
-                # Add the holiday message to the generated image
+                # Add the holiday message to the generated image using the helper utility
                 image_with_message = add_custom_message(
                     generated_image.copy(), message, font_path, font_size, 
                     position_vertical, position_horizontal, max_chars, bg_color, font_color, alpha
@@ -239,8 +156,18 @@ if st.button("Generate Image"):
                 # Display the image with the message
                 st.image(image_with_message, caption=f"Generated using {model_choice} with custom message", use_column_width=True)
 
-                # Preview the placement
+                # Preview the placement details
                 st.write(f"Message preview (vertical position: {position_vertical}, horizontal position: {position_horizontal}, font: {font_choice}, size: {font_size}, max chars: {max_chars}, bg color: {bg_color}, font color: {font_color}, transparency: {alpha})")
                 
         except Exception as e:
             st.error(f"An error occurred: {e}")
+
+# Footer Section
+st.divider()
+st.markdown(
+    """
+    Thank you for using the Holiday Card Generator powered by **Fireworks**! 🎉  
+    Share your creations with the world and spread the holiday cheer!  
+    Happy Holidays from the **Fireworks Team**. 💥  
+    """
+)

pages/2_Generate_Holiday_Borders.py

@@ -1,371 +0,0 @@
-import streamlit as st
-import cv2
-import requests
-from io import BytesIO
-from PIL import Image, ImageDraw
-import numpy as np
-import os
-from dotenv import load_dotenv
-import zipfile
-
-
-# Load environment variables
-dotenv_path = os.path.join(os.path.dirname(__file__), '../env/.env')
-load_dotenv(dotenv_path, override=True)
-api_key = os.getenv("FIREWORKS_API_KEY")
-
-if not api_key:
-    st.error("API key not found. Make sure FIREWORKS_API_KEY is set in the .env file.")
-    st.stop()
-
-VALID_ASPECT_RATIOS = {
-    (1, 1): "1:1", (21, 9): "21:9", (16, 9): "16:9", (3, 2): "3:2", (5, 4): "5:4",
-    (4, 5): "4:5", (2, 3): "2:3", (9, 16): "9:16", (9, 21): "9:21",
-}
-
-def get_closest_aspect_ratio(width, height):
-    aspect_ratio = width / height
-    closest_ratio = min(VALID_ASPECT_RATIOS.keys(), key=lambda x: abs((x[0] / x[1]) - aspect_ratio))
-    return VALID_ASPECT_RATIOS[closest_ratio]
-
-def process_image(uploaded_image):
-    image = np.array(Image.open(uploaded_image).convert('L'))
-    edges = cv2.Canny(image, 100, 200)
-    edges_rgb = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
-    pil_image = Image.fromarray(edges_rgb)
-    byte_arr = BytesIO()
-    pil_image.save(byte_arr, format='JPEG')
-    byte_arr.seek(0)
-    return byte_arr, pil_image
-
-def call_control_net_api(uploaded_image, prompt, control_mode=0, guidance_scale=3.5, num_inference_steps=30, seed=0, controlnet_conditioning_scale=1.0):
-    control_image, processed_image = process_image(uploaded_image)
-    files = {'control_image': ('control_image.jpg', control_image, 'image/jpeg')}
-    original_image = Image.open(uploaded_image)
-    width, height = original_image.size
-    aspect_ratio = get_closest_aspect_ratio(width, height)
-    data = {
-        'prompt': prompt,
-        'control_mode': control_mode,
-        'aspect_ratio': aspect_ratio,
-        'guidance_scale': guidance_scale,
-        'num_inference_steps': num_inference_steps,
-        'seed': seed,
-        'controlnet_conditioning_scale': controlnet_conditioning_scale
-    }
-    headers = {
-        'accept': 'image/jpeg',
-        'authorization': f'Bearer {api_key}',
-    }
-    response = requests.post('https://api.fireworks.ai/inference/v1/workflows/accounts/fireworks/models/flux-1-dev-controlnet-union/control_net', 
-                             files=files, data=data, headers=headers)
-    if response.status_code == 200:
-        return Image.open(BytesIO(response.content)), processed_image, original_image
-    else:
-        st.error(f"Request failed with status code: {response.status_code}, Response: {response.text}")
-        return None, None, None
-
-def draw_crop_preview(image, x, y, width, height):
-    draw = ImageDraw.Draw(image)
-    draw.rectangle([x, y, x + width, y + height], outline="red", width=2)
-    return image
-
-
-# Fireworks Logo at the top
-logo_image = Image.open("img/fireworksai_logo.png")
-st.image(logo_image)
-
-st.title("🎨 Holiday Card Generator - Part A: Design & Ideation 🎨")
-st.markdown(
-    """Welcome to the first part of your holiday card creation journey! 🌟 Here, you’ll play around with different styles, prompts, and parameters to design the perfect card border before adding a personal message in Part B. Let your creativity flow! 🎉
-
-### How it works:
-
-1. **🖼️ Upload Your Image:** Choose the image that will be the center of your card.
-2. **✂️ Crop It:** Adjust the crop to highlight the most important part of your image.
-3. **💡 Choose Your Style:** Select from festive border themes or input your own custom prompt to design something unique.
-4. **⚙️ Fine-Tune Parameters:** Experiment with guidance scales, seeds, inference steps, and more for the perfect aesthetic.
-5. **👀 Preview & Download:** See your generated holiday cards, tweak them until they’re just right, and download the final designs and metadata in a neat ZIP file!
-
-Once you’ve got the perfect look, head over to **Part B** to add your personal message and finalize your holiday card! 💌
-
-"""
-)
-
-# Add divider and subheader for uploading section
-st.divider()
-st.subheader("🖼️ Step 1: Upload Your Picture!")
-st.markdown(""" 
-- Click on the **Upload Image** button to select the image you want to feature on your holiday card.  
-- Accepted formats: **JPG** or **PNG**.
-- Once uploaded, your image will appear on the screen—easy peasy!
-""")
-st.write("Upload the image that will be used for generating your holiday card.")
-
-# Initialize session state variables if they don't exist
-if 'uploaded_file' not in st.session_state:
-    st.session_state.uploaded_file = None
-if 'card_params' not in st.session_state:
-    st.session_state.card_params = [{} for _ in range(4)]  # Initialize for 4 cards
-if 'generated_cards' not in st.session_state:
-    st.session_state.generated_cards = [None for _ in range(4)]  # Store generated images and metadata
-
-# File uploader - if a file is uploaded, save it in session_state
-uploaded_file = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
-st.divider()
-
-if uploaded_file is not None:
-    st.session_state.uploaded_file = uploaded_file  # Save to session state
-
-# Load the image from session state
-if st.session_state.uploaded_file is not None:
-    original_image = Image.open(st.session_state.uploaded_file)
-    st.image(original_image, caption="Uploaded Image", use_column_width=True)
-
-    img_width, img_height = original_image.size
-
-    # Add a divider and subheader for the crop section
-    st.divider()
-    st.subheader("✂️ Step 2: Crop It Like It's Hot!")
-    st.markdown(""" 
-    - Adjust the **crop** sliders to select the perfect area of your image.  
-    - This cropped section will be the centerpiece of your festive card. 🎨  
-    - A preview will show you exactly how your crop looks before moving to the next step!
-""")
-    st.write("Select the area you want to crop from the original image. This cropped portion will be used in the final card.")
-
-    col1, col2 = st.columns(2)
-    with col1:
-        x_pos = st.slider("X position (Left-Right)", 0, img_width, img_width // 4,
-                          help="Move the slider to adjust the crop's left-right position.")
-        crop_width = st.slider("Width", 10, img_width - x_pos, min(img_width // 2, img_width - x_pos),
-                               help="Adjust the width of the crop.")
-    with col2:
-        y_pos = st.slider("Y position (Up-Down)", 0, img_height, img_height // 4,
-                          help="Move the slider to adjust the crop's up-down position.")
-        crop_height = st.slider("Height", 10, img_height - y_pos, min(img_height // 2, img_height - y_pos),
-                                help="Adjust the height of the crop.")
-
-    preview_image = draw_crop_preview(original_image.copy(), x_pos, y_pos, crop_width, crop_height)
-    st.image(preview_image, caption="Crop Preview", use_column_width=True)
-    st.divider()
-
-    st.subheader("⚙️ Step 3: Set Your Festive Border Design with Flux + Fireworks!")
-    st.markdown(""" 
-        - Choose from a selection of holiday-themed borders like **snowflakes**, **Christmas lights**, or even **New Year's Eve fireworks**—all generated through **Flux models on Fireworks!** ✨
-        - Want to get creative? No problem—enter your own **custom prompt** to create a border that's as unique as you are, all powered by **Fireworks' inference API**.
-""")
-    st.write("Customize the parameters for generating each holiday card. Each parameter will influence the final design and style of the card.")
-
-    # Define the list of suggested holiday prompts
-    holiday_prompts = [
-            "A border of Festive snowflakes and winter patterns for a holiday card",
-            "A border of Joyful Christmas ornaments and lights decorating the edges",
-            "A border of Warm and cozy fireplace scene with stockings and garlands",
-            "A border of Colorful Hanukkah menorahs and dreidels along the border",
-            "A border of New Year's Eve fireworks with stars and confetti framing the image",
-            "A border of Samhain symbols with Celtic knots, pumpkins, and candles for a mystical October celebration",
-            "A border of Día de Muertos skulls (calaveras), marigold flowers, and candles in vibrant colors",
-            "A border of Yule imagery with holly, pine trees, and Norse winter symbols under the starry night sky",
-            "A border of Diwali lamps (diyas), rangoli patterns, and lotus flowers for a bright and colorful festival",
-            "A border of Dongzhi Festival glutinous rice balls and cozy winter imagery, celebrating family gatherings",
-            "A border of Soyal dancers, sun symbols, and traditional Zuni and Hopi winter motifs to welcome the sun's return",
-            "A border of Winter Solstice symbols with bare trees, stars, and the moon against a cold winter night",
-            "A border of spooky Halloween elements like pumpkins, bats, ghosts, and cobwebs for a haunted theme",
-            "A border of fall harvest items like pumpkins, cornucopias, autumn leaves, and turkeys",
-            "A border of Christmas ornaments, wreaths, and lights for a joyful, festive holiday look"
-            ]
-
-    # Define input fields for each holiday card's parameters in expanders
-    for i in range(4):
-        with st.expander(f"Holiday Card {i + 1} Parameters"):
-            st.write(f"### Holiday Card {i + 1}")
-            
-            # Get the card params from session_state if they exist
-            card_params = st.session_state.card_params[i]
-            card_params.setdefault("prompt", f"Custom Prompt {i + 1}")
-            card_params.setdefault("guidance_scale", 3.5)
-            card_params.setdefault("num_inference_steps", 30)
-            card_params.setdefault("seed", i * 100)
-            card_params.setdefault("controlnet_conditioning_scale", 0.5)
-            card_params.setdefault("control_mode", 0)
-            
-            # Dropdown to choose a suggested holiday prompt or enter custom prompt
-            selected_prompt = st.selectbox(f"Choose a holiday-themed prompt for Holiday Card {i + 1}", options=["Custom"] + holiday_prompts)
-            custom_prompt = st.text_input(f"Enter custom prompt for Holiday Card {i + 1}", value=card_params["prompt"]) if selected_prompt == "Custom" else selected_prompt
-            
-            # Parameter sliders for each holiday card with tooltips
-            guidance_scale = st.slider(f"Guidance Scale for Holiday Card {i + 1}", min_value=0.0, max_value=20.0, value=card_params["guidance_scale"], step=0.1,
-                                       help="Adjusts how strongly the model follows the prompt. Higher values mean stronger adherence to the prompt.")
-            num_inference_steps = st.slider(f"Number of Inference Steps for Holiday Card {i + 1}", min_value=1, max_value=100, value=card_params["num_inference_steps"], step=1,
-                                            help="More inference steps can lead to a higher quality image but will take longer to generate.")
-            seed = st.slider(f"Random Seed for Holiday Card {i + 1}", min_value=0, max_value=1000, value=card_params["seed"],
-                             help="The seed value allows you to recreate the same image each time, or explore variations by changing the seed.")
-            controlnet_conditioning_scale = st.slider(f"ControlNet Conditioning Scale for Holiday Card {i + 1}", min_value=0.0, max_value=1.0, value=card_params["controlnet_conditioning_scale"], step=0.1,
-                                                      help="Controls how much the ControlNet input influences the output. A lower value reduces its influence.")
-            control_mode = st.slider(f"Control Mode for Holiday Card {i + 1}", min_value=0, max_value=2, value=card_params["control_mode"],
-                                     help="Choose how much ControlNet should influence the final image. 0: None, 1: Partial, 2: Full.")
-            
-            # Update session state with the latest parameters
-            st.session_state.card_params[i] = {
-                "prompt": custom_prompt,
-                "guidance_scale": guidance_scale,
-                "num_inference_steps": num_inference_steps,
-                "seed": seed,
-                "controlnet_conditioning_scale": controlnet_conditioning_scale,
-                "control_mode": control_mode
-            }
-
-    st.divider()  # Add a divider before the "Generate" button
-
-    # Generate the holiday cards
-    st.subheader("Just hit play!")
-    if st.button("Generate Holiday Cards"):
-        with st.spinner("Processing..."):
-            # Create a column layout for displaying cards side by side
-            col1, col2 = st.columns(2)
-            col3, col4 = st.columns(2)
-            columns = [col1, col2, col3, col4]  # To display images in a 2x2 grid
-
-            # Store image bytes and metadata in lists
-            image_files = []
-            metadata = []
-
-            # Loop through each card's parameters and generate the holiday card
-            for i, params in enumerate(st.session_state.card_params):
-                prompt = params['prompt']
-                guidance_scale = params['guidance_scale']
-                num_inference_steps = params['num_inference_steps']
-                seed = params['seed']
-                controlnet_conditioning_scale = params['controlnet_conditioning_scale']
-                control_mode = params['control_mode']
-                
-                # Generate the holiday card using the current parameters
-                generated_image, processed_image, _ = call_control_net_api(
-                    st.session_state.uploaded_file, prompt, control_mode=control_mode, 
-                    guidance_scale=guidance_scale, num_inference_steps=num_inference_steps,
-                    seed=seed, controlnet_conditioning_scale=controlnet_conditioning_scale
-                )
-
-                if generated_image is not None:
-                    # Resize generated_image to match original_image size
-                    generated_image = generated_image.resize(original_image.size)
-
-                    # Create a copy of the generated image
-                    final_image = generated_image.copy()
-
-                    # Crop the selected portion of the original image
-                    cropped_original = original_image.crop((x_pos, y_pos, x_pos + crop_width, y_pos + crop_height))
-
-                    # Get the size of the cropped image
-                    cropped_width, cropped_height = cropped_original.size
-
-                    # Calculate the center of the generated image
-                    center_x = (final_image.width - cropped_width) // 2
-                    center_y = (final_image.height - cropped_height) // 2
-
-                    # Paste the cropped portion of the original image onto the generated image at the calculated center
-                    final_image.paste(cropped_original, (center_x, center_y))
-
-                    # Save image to BytesIO
-                    img_byte_arr = BytesIO()
-                    final_image.save(img_byte_arr, format="PNG")
-                    img_byte_arr.seek(0)
-                    image_files.append((f"holiday_card_{i + 1}.png", img_byte_arr))
-
-                    # Store metadata
-                    metadata.append({
-                        "Card": f"Holiday Card {i + 1}",
-                        "Prompt": prompt,
-                        "Guidance Scale": guidance_scale,
-                        "Inference Steps": num_inference_steps,
-                        "Seed": seed,
-                        "ControlNet Conditioning Scale": controlnet_conditioning_scale,
-                        "Control Mode": control_mode
-                    })
-
-                    # Persist image and metadata in session state
-                    st.session_state.generated_cards[i] = {
-                        "image": final_image,
-                        "metadata": metadata[-1]
-                    }
-
-                    # Display the final holiday card in one of the columns
-                    columns[i].image(final_image, caption=f"Holiday Card {i + 1}", use_column_width=True)
-
-                    # Display the parameters used for this card
-                    columns[i].write(f"**Prompt:** {prompt}")
-                    columns[i].write(f"**Guidance Scale:** {guidance_scale}")
-                    columns[i].write(f"**Inference Steps:** {num_inference_steps}")
-                    columns[i].write(f"**Seed:** {seed}")
-                    columns[i].write(f"**ControlNet Conditioning Scale:** {controlnet_conditioning_scale}")
-                    columns[i].write(f"**Control Mode:** {control_mode}")
-                else:
-                    st.error(f"Failed to generate holiday card {i + 1}. Please try again.")
-
-            # Create ZIP file for download
-            if image_files:
-                zip_buffer = BytesIO()
-                with zipfile.ZipFile(zip_buffer, "w") as zf:
-                    # Add images to the ZIP file
-                    for file_name, img_data in image_files:
-                        zf.writestr(file_name, img_data.getvalue())
-                    
-                    # Add metadata to the ZIP file
-                    metadata_str = "\n\n".join([f"{m['Card']}:\nPrompt: {m['Prompt']}\nGuidance Scale: {m['Guidance Scale']}\nInference Steps: {m['Inference Steps']}\nSeed: {m['Seed']}\nControlNet Conditioning Scale: {m['ControlNet Conditioning Scale']}\nControl Mode: {m['Control Mode']}" for m in metadata])
-                    zf.writestr("metadata.txt", metadata_str)
-
-                zip_buffer.seek(0)
-                st.subheader("Step 4: Download & Share Your Masterpiece! 📥")
-                st.markdown(""" 
-                - Once you're happy with your card, simply hit the download button to save your card and message as a **PNG** image.
-                - You can also view and download any **previously generated holiday cards** from this session!
-                            """)
-                st.download_button(
-                    label="Download all images and metadata as ZIP",
-                    data=zip_buffer,
-                    file_name="holiday_cards.zip",
-                    mime="application/zip"
-                )
-
-# Display previously generated cards if they exist and create a ZIP download button
-st.divider()
-st.subheader("Previously Generated Holiday Cards")
-if any(st.session_state.generated_cards):
-    col1, col2 = st.columns(2)
-    col3, col4 = st.columns(2)
-    columns = [col1, col2, col3, col4]  # Display in 2x2 grid
-
-    image_files = []
-    metadata = []  # Ensure metadata is initialized as a list
-
-    # Loop through previously generated cards
-    for i, card in enumerate(st.session_state.generated_cards):
-        if card and "metadata" in card:  # Ensure the card exists and has metadata
-            columns[i].image(card['image'], caption=f"Holiday Card {i + 1} (Saved)")
-            card_metadata = card['metadata']  # Retrieve the metadata for the current card
-            columns[i].write(f"**Prompt:** {card_metadata['Prompt']}")
-            columns[i].write(f"**Guidance Scale:** {card_metadata['Guidance Scale']}")
-            columns[i].write(f"**Inference Steps:** {card_metadata['Inference Steps']}")
-            columns[i].write(f"**Seed:** {card_metadata['Seed']}")
-            columns[i].write(f"**ControlNet Conditioning Scale:** {card_metadata['ControlNet Conditioning Scale']}")
-            columns[i].write(f"**Control Mode:** {card_metadata['Control Mode']}")
-
-            # Add each image and its metadata to prepare for ZIP download
-            img_byte_arr = BytesIO()
-            card['image'].save(img_byte_arr, format="PNG")
-            img_byte_arr.seek(0)
-            image_files.append((f"holiday_card_{i + 1}.png", img_byte_arr))
-            metadata.append(card_metadata)  # Append card's metadata to the metadata list
-
-    # Provide a ZIP download button for previously generated cards
-    if image_files:
-        zip_buffer = BytesIO()
-        with zipfile.ZipFile(zip_buffer, "w") as zf:
-            # Add images to the ZIP file
-            for file_name, img_data in image_files:
-                zf.writestr(file_name, img_data.getvalue())
-
-            # Add metadata to the ZIP file
-            metadata_str = "\n\n".join([f"{m['Card']}:\nPrompt: {m['Prompt']}\nGuidance Scale: {m['Guidance Scale']}\nInference Steps: {m['Inference Steps']}\nSeed: {m['Seed']}\nControlNet Conditioning Scale: {m['ControlNet Conditioning Scale']}\nControl Mode: {m['Control Mode']}" for m in metadata])
-            zf.writestr("metadata.txt", metadata_str)

pages/2_Generate_Multiple_Holiday_Borders.py

@@ -0,0 +1,249 @@
+# Generate_holiday_borders.py
+
+import streamlit as st
+import os
+from PIL import Image
+from io import BytesIO
+import zipfile
+from dotenv import load_dotenv
+
+# Import from helper_utilities.py
+from utils.helper_utilities import (
+    get_closest_aspect_ratio, process_image, generate_flux_image,  # Replace ControlNet API call with Flux API call
+    draw_crop_preview, combine_images, get_next_largest_aspect_ratio
+)
+
+# Import from configuration.py
+from utils.configuration import (
+    default_guidance_scale, 
+    default_num_inference_steps, default_seed, 
+    holiday_border_prompts
+)
+
+
+
+# Initialize session state
+if 'uploaded_file' not in st.session_state:
+    st.session_state.uploaded_file = None
+if 'card_params' not in st.session_state:
+    st.session_state.card_params = [{} for _ in range(4)]
+if 'generated_cards' not in st.session_state:
+    st.session_state.generated_cards = [None for _ in range(4)]
+
+# Streamlit app starts here
+st.image("img/fireworksai_logo.png")
+st.title("🎨 Holiday Multi-Card Generator🎨")
+st.markdown(
+    """Welcome to the first part of your holiday card creation journey! 🌟 Here, you'll play around with different styles, prompts, and parameters to design the perfect card border before adding a personal message in the section 'Customize Holiday Borders'. Let your creativity flow! 🎉
+
+### How it works:
+
+1. **🖼️ Upload Your Image:** Choose the image that will be the center of your card.
+2. **✂️ Crop It:** Adjust the crop to highlight the most important part of your image.
+3. **💡 Choose Your Style:** Select from festive border themes or input your own custom prompt to design something unique.
+4. **⚙️ Fine-Tune Parameters:** Experiment with guidance scales, seeds, inference steps, and more for the perfect aesthetic.
+5. **👀 Preview & Download:** See your generated holiday cards, tweak them until they're just right, and download the final designs and metadata in a neat ZIP file!
+
+Once you've got the perfect look, head over to **Part B** to add your personal message and finalize your holiday card! 💌
+"""
+)
+
+# Load API Key
+st.divider()
+st.subheader("Load Fireworks API Key")
+
+# Define and ensure the .env directory and file exist
+dotenv_path = os.path.join(os.path.dirname(__file__), '..', 'env', '.env')
+os.makedirs(os.path.dirname(dotenv_path), exist_ok=True)
+
+# Create the .env file if it doesn't exist
+if not os.path.exists(dotenv_path):
+    with open(dotenv_path, "w") as f:
+        st.success(f"Created {dotenv_path}")
+
+# Load environment variables from the .env file
+load_dotenv(dotenv_path, override=True)
+
+# Check if the Fireworks API key is set or blank
+fireworks_api_key = os.getenv("FIREWORKS_API_KEY")
+
+# Show the entire app but disable running parts if no API key
+if not fireworks_api_key or fireworks_api_key.strip() == "":
+    fireworks_api_key = st.text_input("Enter Fireworks API Key", type="password")
+
+    # Optionally, allow the user to save the API key to the .env file
+    if fireworks_api_key and st.checkbox("Save API key for future use"):
+        with open(dotenv_path, "a") as f:
+            f.write(f"FIREWORKS_API_KEY={fireworks_api_key}\n")
+        st.success("API key saved to .env file.")
+else:
+    st.success(f"API key loaded successfully: partial preview {fireworks_api_key[:5]}")
+
+# Step 1: Upload Image
+st.divider()
+st.subheader("🖼️ Step 1: Upload Your Picture!")
+uploaded_file = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
+if uploaded_file is not None:
+    st.session_state.uploaded_file = uploaded_file
+    original_image = Image.open(uploaded_file)
+    img_width, img_height = original_image.size
+    
+    # Calculate the next largest valid aspect ratio
+    aspect_ratio = get_next_largest_aspect_ratio(img_width, img_height)  # Ensure the aspect ratio is valid
+
+    st.image(original_image, caption="Uploaded Image", use_column_width=True)
+
+    # Step 2: Crop Image
+    st.divider()
+    st.subheader("✂️ Step 2: Crop It Like It's Hot!")
+    img_width, img_height = original_image.size
+    col1, col2 = st.columns(2)
+    with col1:
+        x_pos = st.slider("X position (Left-Right)", 0, img_width, img_width // 4)
+        crop_width = st.slider("Width", 10, img_width - x_pos, min(img_width // 2, img_width - x_pos))
+    with col2:
+        y_pos = st.slider("Y position (Up-Down)", 0, img_height, img_height // 4)
+        crop_height = st.slider("Height", 10, img_height - y_pos, min(img_height // 2, img_height - y_pos))
+
+    preview_image = draw_crop_preview(original_image.copy(), x_pos, y_pos, crop_width, crop_height)
+    st.image(preview_image, caption="Crop Preview", use_column_width=True)
+
+    # Step 3: Set Card Parameters
+    st.divider()
+    st.subheader("⚙️ Step 3: Set Your Festive Border Design with Flux + Fireworks!")
+    for i in range(4):
+        with st.expander(f"Holiday Card {i + 1} Parameters"):
+            card_params = st.session_state.card_params[i]
+
+            # Set default values for card parameters if not already set
+            card_params.setdefault("prompt", holiday_border_prompts[i % len(holiday_border_prompts)])  # Set default from holiday prompts
+            card_params.setdefault("guidance_scale", default_guidance_scale)
+            card_params.setdefault("num_inference_steps", default_num_inference_steps)
+            card_params.setdefault("seed", i * 100)
+        
+            selected_prompt = st.selectbox(f"Choose a holiday-themed prompt for Holiday Card {i + 1}", options=["Custom"] + holiday_border_prompts)
+            custom_prompt = st.text_input(f"Enter custom prompt for Holiday Card {i + 1}", value=card_params["prompt"]) if selected_prompt == "Custom" else selected_prompt
+            
+            # Allow the user to tweak other parameters
+            guidance_scale = st.slider(
+                f"Guidance Scale for Holiday Card {i + 1}",
+                min_value=0.0, max_value=20.0, value=card_params["guidance_scale"], step=0.1
+            )
+            num_inference_steps = st.slider(
+                f"Number of Inference Steps for Holiday Card {i + 1}",
+                min_value=1, max_value=100, value=card_params["num_inference_steps"], step=1
+            )
+            seed = st.slider(
+                f"Random Seed for Holiday Card {i + 1}",
+                min_value=0, max_value=1000, value=card_params["seed"]
+            )
+            
+            st.session_state.card_params[i] = {
+                "prompt": custom_prompt,
+                "guidance_scale": guidance_scale,
+                "num_inference_steps": num_inference_steps,
+                "seed": seed
+            }
+
+# Generate Holiday Cards
+st.divider()
+st.subheader("Preview and Share the Holiday Cheer! 🎅📬")
+st.markdown(""" 
+Click "Generate Image" and watch the magic happen! Your holiday card is just moments away from spreading joy to everyone on your list. 🎄🎁✨
+""")
+
+# Disable the generate button if the API key is missing
+if not fireworks_api_key or fireworks_api_key.strip() == "":
+    st.warning("Enter a valid Fireworks API key to enable card generation.")
+    generate_button = st.button("Generate Holiday Cards", disabled=True)
+else:
+    generate_button = st.button("Generate Holiday Cards")
+
+if generate_button:
+    with st.spinner("Processing..."):
+        cols = st.columns(4)
+        image_files = []
+        metadata = []
+
+        for i, params in enumerate(st.session_state.card_params):
+            # Generate image using Flux API with the next largest valid aspect ratio
+            generated_image = generate_flux_image(
+                model_path="flux-1-schnell-fp8",  
+                prompt=params['prompt'],
+                steps=params['num_inference_steps'],  
+                guidance_scale=params['guidance_scale'],  
+                seed=params['seed'],  
+                api_key=fireworks_api_key,
+                aspect_ratio=f"{aspect_ratio[0]}:{aspect_ratio[1]}"  # Ensure aspect ratio is passed as a string in "width:height" format
+            )
+
+            if generated_image:
+                generated_image = generated_image.resize(original_image.size)
+
+                # Center the cropped original image onto the generated image
+                cropped_original = original_image.crop((x_pos, y_pos, x_pos + crop_width, y_pos + crop_height))
+                flux_width, flux_height = generated_image.size
+                cropped_width, cropped_height = cropped_original.size
+                center_x = (flux_width - cropped_width) // 2
+                center_y = (flux_height - cropped_height) // 2
+                final_image = generated_image.copy()
+                final_image.paste(cropped_original, (center_x, center_y))
+
+                # Save final image and metadata
+                img_byte_arr = BytesIO()
+                final_image.save(img_byte_arr, format="PNG")
+                img_byte_arr.seek(0)
+                image_files.append((f"holiday_card_{i + 1}.png", img_byte_arr))
+
+                metadata.append({
+                    "Card": f"Holiday Card {i + 1}",
+                    "Prompt": params['prompt'],
+                    "Guidance Scale": params['guidance_scale'],
+                    "Inference Steps": params['num_inference_steps'],
+                    "Seed": params['seed']
+                })
+
+                st.session_state.generated_cards[i] = {
+                    "image": final_image,
+                    "metadata": metadata[-1]
+                }
+
+                # Display the final holiday card
+                cols[i].image(final_image, caption=f"Holiday Card {i + 1}", use_column_width=True)
+                cols[i].write(f"**Prompt:** {params['prompt']}")
+                cols[i].write(f"**Guidance Scale:** {params['guidance_scale']}")
+                cols[i].write(f"**Inference Steps:** {params['num_inference_steps']}")
+                cols[i].write(f"**Seed:** {params['seed']}")
+            else:
+                st.error(f"Failed to generate holiday card {i + 1}. Please try again.")
+
+        # Create the ZIP file with all images and metadata
+        if image_files:
+            zip_buffer = BytesIO()
+            with zipfile.ZipFile(zip_buffer, "w") as zf:
+                for file_name, img_data in image_files:
+                    zf.writestr(file_name, img_data.getvalue())
+                
+                metadata_str = "\n\n".join([f"{m['Card']}:\nPrompt: {m['Prompt']}\nGuidance Scale: {m['Guidance Scale']}\nInference Steps: {m['Inference Steps']}\nSeed: {m['Seed']}" for m in metadata])
+                zf.writestr("metadata.txt", metadata_str)
+
+            zip_buffer.seek(0)
+
+            # Single download button for all images and metadata
+            st.download_button(
+                label="Download all images and metadata as ZIP",
+                data=zip_buffer,
+                file_name="holiday_cards.zip",
+                mime="application/zip"
+            )
+
+
+# Footer Section
+st.divider()
+st.markdown(
+    """
+    Thank you for using the Holiday Card Generator powered by **Fireworks**! 🎉  
+    Share your creations with the world and spread the holiday cheer!  
+    Happy Holidays from the **Fireworks Team**. 💥  
+    """
+)

pages/3_Customize_Holiday_Borders.py

@@ -1,348 +1,244 @@
 import streamlit as st
-import cv2
-import requests
-from io import BytesIO
-from PIL import Image, ImageDraw, ImageFont, ImageFile
-import numpy as np
 import os
-from dotenv import load_dotenv
+from PIL import Image
+from io import BytesIO
 import zipfile
+from dotenv import load_dotenv
 
-# Allow truncated images to be loaded
-ImageFile.LOAD_TRUNCATED_IMAGES = True
+# Import from helper_utilities.py
+from utils.helper_utilities import (
+    get_next_largest_aspect_ratio, draw_crop_preview, 
+    add_custom_message, generate_flux_image
+)
 
-# Load environment variables
-dotenv_path = os.path.join(os.path.dirname(__file__), '../env/.env')
-load_dotenv(dotenv_path, override=True)
-api_key = os.getenv("FIREWORKS_API_KEY")
-
-# Folder to store generated images
-GENERATED_IMAGES_DIR = "generated_images"
-os.makedirs(GENERATED_IMAGES_DIR, exist_ok=True)
-
-if not api_key:
-    st.error("API key not found. Make sure FIREWORKS_API_KEY is set in the .env file.")
-    st.stop()
-
-VALID_ASPECT_RATIOS = {
-    (1, 1): "1:1", (21, 9): "21:9", (16, 9): "16:9", (3, 2): "3:2", (5, 4): "5:4",
-    (4, 5): "4:5", (2, 3): "2:3", (9, 16): "9:16", (9, 21): "9:21",
-}
-
-def get_closest_aspect_ratio(width, height):
-    aspect_ratio = width / height
-    closest_ratio = min(VALID_ASPECT_RATIOS.keys(), key=lambda x: abs((x[0] / x[1]) - aspect_ratio))
-    return VALID_ASPECT_RATIOS[closest_ratio]
-
-def process_image(uploaded_image):
-    image = np.array(Image.open(uploaded_image).convert('L'))
-    edges = cv2.Canny(image, 100, 200)
-    edges_rgb = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
-    pil_image = Image.fromarray(edges_rgb)
-    byte_arr = BytesIO()
-    pil_image.save(byte_arr, format='JPEG')
-    byte_arr.seek(0)
-    return byte_arr, pil_image
-
-def call_control_net_api(uploaded_image, prompt, control_mode=0, guidance_scale=3.5, num_inference_steps=30, seed=0, controlnet_conditioning_scale=1.0):
-    control_image, processed_image = process_image(uploaded_image)
-    files = {'control_image': ('control_image.jpg', control_image, 'image/jpeg')}
-    original_image = Image.open(uploaded_image)
-    width, height = original_image.size
-    aspect_ratio = get_closest_aspect_ratio(width, height)
-    data = {
-        'prompt': prompt,
-        'control_mode': control_mode,
-        'aspect_ratio': aspect_ratio,
-        'guidance_scale': guidance_scale,
-        'num_inference_steps': num_inference_steps,
-        'seed': seed,
-        'controlnet_conditioning_scale': controlnet_conditioning_scale
-    }
-    headers = {
-        'accept': 'image/jpeg',
-        'authorization': f'Bearer {api_key}',
-    }
-    response = requests.post('https://api.fireworks.ai/inference/v1/workflows/accounts/fireworks/models/flux-1-dev-controlnet-union/control_net', 
-                             files=files, data=data, headers=headers)
-    if response.status_code == 200:
-        return Image.open(BytesIO(response.content)), processed_image, original_image
-    else:
-        st.error(f"Request failed with status code: {response.status_code}, Response: {response.text}")
-        return None, None, None
-
-def draw_crop_preview(image, x, y, width, height):
-    draw = ImageDraw.Draw(image)
-    draw.rectangle([x, y, x + width, y + height], outline="red", width=2)
-    return image
-
-def add_message_to_image(image, cropped_bottom_y, message, font_path, font_size):
-    draw = ImageDraw.Draw(image)
-
-    # Try to load the selected font file with user-defined size
-    try:
-        font = ImageFont.truetype(font_path, font_size)
-        st.write(f"Loaded font from {font_path} with font size {font_size}")
-    except IOError as e:
-        st.error(f"Error loading font: {e}. Loading default font.")
-        font = ImageFont.load_default()
-
-    # Calculate the text size dynamically
-    text_bbox = draw.textbbox((0, 0), message, font=font)
-    text_width = text_bbox[2] - text_bbox[0]
-    text_height = text_bbox[3] - text_bbox[1]
-    st.write(f"Text width: {text_width}, Text height: {text_height}")
-
-    # Calculate the space between the bottom of the cropped image and the bottom of the card
-    bottom_space = image.height - cropped_bottom_y
-
-    # Place the text box centered along the Y axis in the bottom space
-    y_position = cropped_bottom_y + (bottom_space - text_height) // 2
-
-    # Position the text box at the center of the width of the image
-    x_position = (image.width - text_width) // 2
-
-    # Define the padding for the text box
-    padding_x = 50  # Adjust the padding width as needed
-    padding_y = 50  # Adjust the padding height as needed
-
-    # Define the text box (background) coordinates with padding
-    box_coords = [
-        x_position - padding_x, y_position - padding_y,
-        x_position + text_width + padding_x, y_position + text_height + padding_y
-    ]
-
-    # Draw a white rectangle as the background for the text box
-    draw.rectangle(box_coords, fill="white")
-
-    # Draw the text in black on top of the white background
-    draw.text((x_position, y_position), message, font=font, fill="black")
-
-    return image
-
-# Define the fonts you want to allow
-fonts = {
-    "DejaVu Sans Bold": "./fonts/dejavu-sans-bold.ttf",
-    "Covered By You": "./fonts/CoveredByYourGrace-Regular.ttf",  # Update this path to your actual font paths
-    "Julee Regular": "./fonts/Julee-Regular.ttf",  # Example font
-    "Kalam Regular": "./fonts/Kalam-Regular.ttf",
-    "Knewave Regular": "./fonts/Knewave-Regular.ttf",
-    "Sancreek Regular": "./fonts/Sancreek-Regular.ttf",
-    "Vast Shadow Regular": "./fonts/VastShadow-Regular.ttf",
-}
-
-# Fireworks Logo at the top
-logo_image = Image.open("img/fireworksai_logo.png")
-st.image(logo_image)
-
-st.title("🎨 Holiday Card Generator - Part B: Finalize Your Holiday Card")
+# Import from configuration.py
+from utils.configuration import (
+    default_guidance_scale, default_num_inference_steps, 
+    default_seed, holiday_border_prompts, example_holiday_messages, fonts
+)
 
-st.markdown("""
-Welcome back! You've already set your favorite parameters, and now it's time to finalize your custom holiday card.
+# Streamlit app starts here
+st.image("img/fireworksai_logo.png")
+st.title("🎄 Holiday Card Customizer 🎅")
 
-**Steps**:
-1. **Choose a Border**: Select or confirm a holiday-themed border to frame your image—choose from snowflakes, ornaments, cozy fireplaces, and more!
-2. **Add a Personalized Message**: Write your holiday greeting and customize it with font and size options to match your style.
-3. **Review & Download**: Preview your finished card and download it for sharing.
+st.markdown("""
+✨ Welcome to the **Holiday Card Generator**! Get ready to sprinkle some holiday magic onto your custom card with a festive border and a heartfelt message. Here's how you can spread the holiday cheer: 
 
-**Features**:
-- Confirm your AI-generated border with your preferred parameters
-- Personalize the message with a variety of fonts and sizes
-- Save your card with metadata for future use
+1. 🎁 **Upload your image** – Select a photo or design to be the star of your holiday card.
+2. ✨ **Design your holiday card border** – Choose from seasonal prompts or create your own unique design.
+3. 💌 **Add your personal holiday message** – Make it meaningful, funny, or warm-hearted!
+4. 📦 **Download your finished card** – Ready to send to friends and family.
 
-🎁 Get your perfect holiday card ready to share! 🌟
+Let’s bring your holiday greetings to life! 🎉
 """)
 
-
-st.divider()
-
-# Initialize session state variables if they don't exist
+# Initialize session state variables
 if 'uploaded_file' not in st.session_state:
     st.session_state.uploaded_file = None
 if 'generated_image' not in st.session_state:
     st.session_state.generated_image = None
+if 'metadata' not in st.session_state:
+    st.session_state.metadata = {}
+
+st.divider()
+st.subheader("🎅 Step 1: Load Your Fireworks API Key 🎄")
 
-# File uploader - if a file is uploaded, save it in session_state
-st.subheader("🖼️ Step 1: Upload Your Picture!")
+# Load API Key
+# Define and ensure the .env directory and file exist
+dotenv_path = os.path.join(os.path.dirname(__file__), '..', 'env', '.env')
+os.makedirs(os.path.dirname(dotenv_path), exist_ok=True)
+
+# Create the .env file if it doesn't exist
+if not os.path.exists(dotenv_path):
+    with open(dotenv_path, "w") as f:
+        st.success(f"Created {dotenv_path}")
+
+# Load environment variables from the .env file
+load_dotenv(dotenv_path, override=True)
+
+# Check if the Fireworks API key is set or blank
+fireworks_api_key = os.getenv("FIREWORKS_API_KEY")
+
+# Show the entire app but disable running parts if no API key
+if not fireworks_api_key or fireworks_api_key.strip() == "":
+    fireworks_api_key = st.text_input("Enter Fireworks API Key", type="password")
+
+    # Optionally, allow the user to save the API key to the .env file
+    if fireworks_api_key and st.checkbox("Save API key for future use"):
+        with open(dotenv_path, "a") as f:
+            f.write(f"FIREWORKS_API_KEY={fireworks_api_key}\n")
+        st.success("API key saved to .env file.")
+else:
+    st.success(f"API key loaded successfully: partial preview {fireworks_api_key[:5]}")
+
+# Step 1: Upload Image
+st.subheader("🎁 Step 2: Upload Your Festive Picture 🎨")
 st.markdown("""
-- Click on the "Upload Image" button to select the image you want to feature on your holiday card. Make sure it's a **JPG** or **PNG** file.
-- Once uploaded, your image will appear on the screen—easy peasy!
-            """)
+It's time to pick your image! This will be the centerpiece of your holiday card.  
+- **Pro Tip**: Choose something that brings out the warmth and joy of the season! 🎄🎅  
+Upload a **PNG** or **JPEG** image to get started.
+""")
 uploaded_file = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
 if uploaded_file is not None:
-    st.session_state.uploaded_file = uploaded_file  # Save to session state
-st.divider()
+    st.session_state.uploaded_file = uploaded_file
 
-# Load the image from session state if it exists
+# Process uploaded image
 if st.session_state.uploaded_file is not None:
     try:
         original_image = Image.open(st.session_state.uploaded_file)
-        st.subheader("Your uploaded image")
         st.image(original_image, caption="Uploaded Image", use_column_width=True)
 
-        img_width, img_height = original_image.size
-        st.divider()
-
-        st.subheader("✂️ Step 2: Crop It Like It's Hot!")
+        # Step 2: Crop Image
+        st.subheader("✂️ Step 3: Trim Your Image Just Right! 🎄")
         st.markdown("""
-        - Adjust the **crop** sliders to select the perfect area of your image. This cropped section will be the centerpiece of your festive card. 🎨
-        - A preview will show you exactly how your crop looks before moving to the next step!
-                    """)
+        Adjust the crop sliders to capture the most festive part of your image.  
+        A preview will show you how your holiday card is shaping up! ✨
+        """)
+        img_width, img_height = original_image.size
         col1, col2 = st.columns(2)
         with col1:
-            x_pos = st.slider("X position (Left-Right)", 0, img_width, img_width // 4,
-                            help="Move the slider to adjust the crop's left-right position.")
-            crop_width = st.slider("Crop Width", 10, img_width - x_pos, min(img_width // 2, img_width - x_pos),
-                                help="Adjust the width of the crop.")
+            x_pos = st.slider("X position (Left-Right)", 0, img_width, img_width // 4)
+            crop_width = st.slider("Width", 10, img_width - x_pos, min(img_width // 2, img_width - x_pos))
         with col2:
-            y_pos = st.slider("Y position (Up-Down)", 0, img_height, img_height // 4,
-                            help="Move the slider to adjust the crop's up-down position.")
-            crop_height = st.slider("Crop Height", 10, img_height - y_pos, min(img_height // 2, img_height - y_pos),
-                                    help="Adjust the height of the crop.")
+            y_pos = st.slider("Y position (Up-Down)", 0, img_height, img_height // 4)
+            crop_height = st.slider("Height", 10, img_height - y_pos, min(img_height // 2, img_height - y_pos))
 
         preview_image = draw_crop_preview(original_image.copy(), x_pos, y_pos, crop_width, crop_height)
         st.image(preview_image, caption="Crop Preview", use_column_width=True)
 
-        
-        # Holiday card prompt and parameters
-        st.divider()
-        holiday_prompts = [
-            "A border of Festive snowflakes and winter patterns for a holiday card",
-            "A border of Joyful Christmas ornaments and lights decorating the edges",
-            "A border of Warm and cozy fireplace scene with stockings and garlands",
-            "A border of Colorful Hanukkah menorahs and dreidels along the border",
-            "A border of New Year's Eve fireworks with stars and confetti framing the image",
-            "A border of Samhain symbols with Celtic knots, pumpkins, and candles for a mystical October celebration",
-            "A border of Día de Muertos skulls (calaveras), marigold flowers, and candles in vibrant colors",
-            "A border of Yule imagery with holly, pine trees, and Norse winter symbols under the starry night sky",
-            "A border of Diwali lamps (diyas), rangoli patterns, and lotus flowers for a bright and colorful festival",
-            "A border of Dongzhi Festival glutinous rice balls and cozy winter imagery, celebrating family gatherings",
-            "A border of Soyal dancers, sun symbols, and traditional Zuni and Hopi winter motifs to welcome the sun's return",
-            "A border of Winter Solstice symbols with bare trees, stars, and the moon against a cold winter night",
-            "A border of spooky Halloween elements like pumpkins, bats, ghosts, and cobwebs for a haunted theme",
-            "A border of fall harvest items like pumpkins, cornucopias, autumn leaves, and turkeys",
-            "A border of Christmas ornaments, wreaths, and lights for a joyful, festive holiday look"
-            ]
-        st.subheader("⚙️ Step 3: Design Your Festive Border with Flux + Fireworks!")
+        # Step 3: Set Border Parameters and Generate Image
+        st.subheader("🎨 Step 4: Design Your Holiday Border! 🎅")
         st.markdown("""
-                    - Choose from a selection of holiday-themed borders like **snowflakes**, **Christmas lights**, or even **New Year's Eve fireworks**—all generated through **Flux models on Fireworks!** ✨
-                    - Want to get creative? No problem—enter your own **custom prompt** to create a border that's as unique as you are, all powered by **Fireworks' inference API**. """)
-        selected_prompt = st.selectbox("Choose a holiday-themed prompt or enter your own", options=["Custom"] + holiday_prompts)
+        Choose from a range of holiday themes like snowflakes, cozy fireplaces, or fireworks!  
+        Want to create your own magical scene? Enter a **custom prompt** to make it truly unique! 🎄
+        """)
+        selected_prompt = st.selectbox("Choose a holiday-themed prompt or enter your own", options=["Custom"] + holiday_border_prompts)
         custom_prompt = st.text_input("Enter your custom prompt") if selected_prompt == "Custom" else ""
         prompt = custom_prompt if selected_prompt == "Custom" else selected_prompt
 
-        with st.expander("Advanced Parameters"):
-            control_mode = st.slider("Control Mode", min_value=0, max_value=2, value=0)
-            controlnet_conditioning_scale = st.slider("ControlNet Conditioning Scale", min_value=0.0, max_value=1.0, value=0.5, step=0.1)
-            guidance_scale = st.slider("Guidance Scale", min_value=0.0, max_value=20.0, value=3.5, step=0.1)
-            num_inference_steps = st.slider("Number of Inference Steps", min_value=1, max_value=100, value=30, step=1)
-            seed = st.slider("Random Seed", min_value=0, max_value=1000, value=0)
+        guidance_scale = st.slider("Guidance Scale", min_value=0.0, max_value=20.0, value=default_guidance_scale, step=0.1)
+        num_inference_steps = st.slider("Number of Inference Steps", min_value=1, max_value=100, value=default_num_inference_steps, step=1)
+        seed = st.slider("Random Seed", min_value=0, max_value=1000, value=default_seed)
 
         if st.button("Generate Holiday Card"):
             if not prompt.strip():
                 st.error("Please enter a prompt.")
             else:
-                with st.spinner("Processing..."):
-                    generated_image, processed_image, _ = call_control_net_api(
-                        st.session_state.uploaded_file, prompt, control_mode=control_mode, 
-                        guidance_scale=guidance_scale, num_inference_steps=num_inference_steps,
-                        seed=seed, controlnet_conditioning_scale=controlnet_conditioning_scale
+                with st.spinner("Adding holiday magic..."):
+                    aspect_ratio = get_next_largest_aspect_ratio(img_width, img_height)
+                    generated_image = generate_flux_image(
+                        model_path="flux-1-schnell-fp8",
+                        api_key=fireworks_api_key,
+                        prompt=prompt,
+                        steps=num_inference_steps,
+                        guidance_scale=guidance_scale,
+                        seed=seed,
+                        aspect_ratio=f"{aspect_ratio[0]}:{aspect_ratio[1]}"
                     )
-
+                    
                     if generated_image is not None:
-                        # Resize generated_image to match original_image size
                         generated_image = generated_image.resize(original_image.size)
-
-                        # Create a copy of the generated image
-                        final_image = generated_image.copy()
-
-                        # Crop the selected portion of the original image
                         cropped_original = original_image.crop((x_pos, y_pos, x_pos + crop_width, y_pos + crop_height))
-
-                        # Get the size of the cropped image
-                        cropped_width, cropped_height = cropped_original.size
-
-                        # Calculate the center of the generated image
-                        center_x = (final_image.width - cropped_width) // 2
-                        center_y = (final_image.height - cropped_height) // 2
-
-                        # Paste the cropped portion of the original image onto the generated image at the calculated center
+                        center_x = (generated_image.width - crop_width) // 2
+                        center_y = (generated_image.height - crop_height) // 2
+                        final_image = generated_image.copy()
                         final_image.paste(cropped_original, (center_x, center_y))
-
-                        # Save the generated image in session state for persistence
                         st.session_state.generated_image = final_image
 
-                        # Save the image locally
-                        final_image.save(f"{GENERATED_IMAGES_DIR}/holiday_card.png")
+                        # Save metadata
+                        st.session_state.metadata = {
+                            "Prompt": prompt,
+                            "Guidance Scale": guidance_scale,
+                            "Inference Steps": num_inference_steps,
+                            "Seed": seed
+                        }
 
-                        # Display the final holiday card
-                        st.image(final_image, caption="Final Holiday Card", use_column_width=True)
-                    else:
-                        st.error("Failed to generate holiday card. Please try again.")
+                        st.image(final_image, caption="🎁 Final Holiday Card 🎁", use_column_width=True)
 
-        # Add a text box to input a custom message (limit to 280 characters like a tweet)
-        st.divider()
-        if 'generated_image' in st.session_state:
-            st.subheader("✏️ Step 4: Add Your Custom Holiday Message!")
-            st.markdown("""
-                        - Add a fun, heartfelt, or witty holiday message to the bottom of your card. 🎉
-                        - Choose from a variety of **festive fonts** and adjust the **font size** to make your message stand out! 🎅 """)
+                        # Print the metadata below the image
+                        st.markdown("### ✨ Card Metadata")
+                        for key, value in st.session_state.metadata.items():
+                            st.write(f"**{key}:** {value}")
 
-            # Text input for custom message
-            custom_message = st.text_input("Add a custom holiday message to the card (max 280 characters)", max_chars=280)
+        # Step 4: Add Custom Message
+        if 'generated_image' in st.session_state and st.session_state.generated_image is not None:
+            st.subheader("💌 Step 5: Add Your Heartfelt Holiday Message! 🎅")
+            st.markdown("""
+            Select a pre-written festive message or craft your own!  
+            Customize the font, size, and color to make it pop! 🌟
+            """)
 
-            # Font selection dropdown
+            selected_message = st.selectbox("Choose an example holiday message or write your own", options=["Custom"] + example_holiday_messages)
+            custom_message = st.text_input("Enter your holiday message") if selected_message == "Custom" else selected_message
+            
             selected_font = st.selectbox("Choose a font for your message", options=list(fonts.keys()))
-
-            # Slider to allow the user to adjust the font size
-            font_size = st.slider("Adjust font size", min_value=10, max_value=500, value=100, step=10)
-
-            # Get the corresponding font path
+            font_size = st.slider("Adjust font size", min_value=1, max_value=500, value=100, step=5)
+            # Slider to choose the max characters per line for text wrapping
+            max_chars = st.slider("Max characters per line:", min_value=20, max_value=100, value=40)
             font_path = fonts[selected_font]
+            bg_color = st.color_picker("Pick a background color for the text", "#FFFFFF")
+            font_color = st.color_picker("Pick a font color", "#000000")
+            alpha = st.slider("Background transparency (0: fully transparent, 255: fully opaque)", 0, 255, 200)
+            position_vertical = st.radio("Vertical position", ["Top", "Center", "Bottom"])
+            position_horizontal = st.radio("Horizontal position", ["Left", "Center", "Right"])
+
+            
 
             if st.button("Generate Holiday Card with Message"):
                 final_image_with_message = st.session_state.generated_image.copy()
 
-                # Get the dimensions of the cropped image and final image
-                cropped_bottom_y = y_pos + crop_height  # y_pos is the top Y position of the cropped area
-
-                # Add the custom message to the image
-                if custom_message:
-                    final_image_with_message = add_message_to_image(final_image_with_message, cropped_bottom_y, custom_message, font_path, font_size)
+                final_image_with_message = add_custom_message(
+                    final_image_with_message,
+                    custom_message,
+                    font_path,
+                    font_size,
+                    position_vertical,
+                    position_horizontal,
+                    max_chars=max_chars,
+                    bg_color=bg_color,
+                    font_color=font_color,
+                    alpha=alpha
+                )
 
-                # Display the final holiday card with the message
-                st.image(final_image_with_message, caption="Holiday Card with Custom Message", use_column_width=True)
+                st.image(final_image_with_message, caption="🎄 Holiday Card with Custom Message 🎄", use_column_width=True)
 
-                # Save image for download
+                # Save image and metadata to zip
                 img_byte_arr = BytesIO()
                 final_image_with_message.save(img_byte_arr, format="PNG")
                 img_byte_arr.seek(0)
 
-                # Download button for the final image
-                st.divider()
-                st.subheader("📥 Step 5: Download & Share Your Masterpiece!")
-                st.markdown("""
-                            - Once you're happy with your card, simply hit the download button to save your card and message as a PNG image.
-                            - You can also view and download any **previously generated holiday cards** from this session!""")
+                # Create a zip file containing the image and metadata
+                zip_buffer = BytesIO()
+                with zipfile.ZipFile(zip_buffer, "w") as zf:
+                    # Add the image to the zip
+                    zf.writestr("holiday_card_with_message.png", img_byte_arr.getvalue())
+
+                    # Add the metadata as a text file to the zip
+                    metadata_str = "\n".join([f"{key}: {value}" for key, value in st.session_state.metadata.items()])
+                    zf.writestr("metadata.txt", metadata_str)
+
+                zip_buffer.seek(0)
+
+                # Step 5: Download as zip
                 st.download_button(
-                    label="Download Holiday Card with Message",
-                    data=img_byte_arr,
-                    file_name="holiday_card_with_message.png",
-                    mime="image/png"
+                    label="🎁 Download Holiday Card and Metadata as ZIP 🎁",
+                    data=zip_buffer,
+                    file_name="holiday_card_with_message.zip",
+                    mime="application/zip"
                 )
 
-                # Save image locally
-                final_image_with_message.save(f"{GENERATED_IMAGES_DIR}/holiday_card_with_message.png", format="PNG")
     except OSError:
         st.error("The uploaded image seems to be truncated or corrupted. Please try with a different image.")
 else:
     st.warning("Please upload an image to get started.")
 
-# Load and display previously generated images
-st.divider()
-st.subheader("Previously Generated Holiday Cards")
 
-saved_image_path = f"{GENERATED_IMAGES_DIR}/holiday_card_with_message.png"
-if os.path.exists(saved_image_path):
-    saved_image = Image.open(saved_image_path)
-    st.image(saved_image, caption="Previously Generated Holiday Card", use_column_width=True)
+    # Footer Section
+st.divider()
+st.markdown(
+    """
+    Thank you for using the Holiday Card Generator powered by **Fireworks**! 🎉  
+    Share your creations with the world and spread the holiday cheer!  
+    Happy Holidays from the **Fireworks Team**. 💥  
+    """
+)

pages/4_Morph_Holiday_Card.py

@@ -1,268 +0,0 @@
-import streamlit as st
-import cv2
-import requests
-from io import BytesIO
-from PIL import Image, ImageDraw, ImageFont, ImageFilter
-import numpy as np
-import os
-from dotenv import load_dotenv
-
-# Load environment variables
-dotenv_path = os.path.join(os.path.dirname(__file__), '../env/.env')
-load_dotenv(dotenv_path, override=True)
-api_key = os.getenv("FIREWORKS_API_KEY")
-
-if not api_key:
-    st.error("API key not found. Make sure FIREWORKS_API_KEY is set in the .env file.")
-    st.stop()
-
-# Initialize session state variables if they don't exist
-if 'uploaded_file' not in st.session_state:
-    st.session_state.uploaded_file = None
-if 'generated_image' not in st.session_state:
-    st.session_state.generated_image = None
-if 'control_image' not in st.session_state:
-    st.session_state.control_image = None
-
-VALID_ASPECT_RATIOS = {
-    (1, 1): "1:1", (21, 9): "21:9", (16, 9): "16:9", (3, 2): "3:2", (5, 4): "5:4",
-    (4, 5): "4:5", (2, 3): "2:3", (9, 16): "9:16", (9, 21): "9:21",
-}
-
-def get_closest_aspect_ratio(width, height):
-    aspect_ratio = width / height
-    closest_ratio = min(VALID_ASPECT_RATIOS.keys(), key=lambda x: abs((x[0] / x[1]) - aspect_ratio))
-    return closest_ratio, VALID_ASPECT_RATIOS[closest_ratio]
-
-def add_padding_to_aspect_ratio(image, target_aspect_ratio):
-    width, height = image.size
-    target_width, target_height = target_aspect_ratio
-
-    if width / height > target_width / target_height:
-        new_height = int(width * target_height / target_width)
-        new_width = width
-    else:
-        new_width = int(height * target_width / target_height)
-        new_height = height
-
-    # Create a new image with the target aspect ratio and paste the original image in the center
-    padded_image = Image.new('RGB', (new_width, new_height), (128, 128, 128))  # Grey padding
-    paste_x = (new_width - width) // 2
-    paste_y = (new_height - height) // 2
-    padded_image.paste(image, (paste_x, paste_y))
-
-    return padded_image
-
-def create_control_image(original_image, x_pos, y_pos, crop_width, crop_height):
-    # Crop the selected area
-    cropped_area = original_image.crop((x_pos, y_pos, x_pos + crop_width, y_pos + crop_height))
-    
-    # Add 20% padding around the cropped area
-    pad_width = int(crop_width * 0.2)
-    pad_height = int(crop_height * 0.2)
-    padded_width = crop_width + 2 * pad_width
-    padded_height = crop_height + 2 * pad_height
-    padded_image = Image.new('RGB', (padded_width, padded_height), (128, 128, 128))  # Grey padding
-    padded_image.paste(cropped_area, (pad_width, pad_height))
-
-    # Adjust the padded image to match the closest valid aspect ratio
-    closest_aspect_ratio, _ = get_closest_aspect_ratio(padded_width, padded_height)
-    control_image = add_padding_to_aspect_ratio(padded_image, closest_aspect_ratio)
-
-    return control_image
-
-def process_image(image):
-    gray_image = image.convert('L')
-    np_image = np.array(gray_image)
-    edges = cv2.Canny(np_image, 100, 200)
-    edges_rgb = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
-    edge_image = Image.fromarray(edges_rgb)
-    byte_arr = BytesIO()
-    edge_image.save(byte_arr, format='JPEG')
-    byte_arr.seek(0)
-    return byte_arr, edge_image
-
-def call_control_net_api(control_image, prompt, control_mode=0, guidance_scale=3.5, num_inference_steps=30, seed=0, controlnet_conditioning_scale=1.0):
-    processed_image_bytes, processed_image = process_image(control_image)
-    files = {'control_image': ('control_image.jpg', processed_image_bytes, 'image/jpeg')}
-    
-    width, height = control_image.size
-    aspect_ratio = get_closest_aspect_ratio(width, height)[1]
-    
-    data = {
-        'prompt': prompt,
-        'control_mode': control_mode,
-        'aspect_ratio': aspect_ratio,
-        'guidance_scale': guidance_scale,
-        'num_inference_steps': num_inference_steps,
-        'seed': seed,
-        'controlnet_conditioning_scale': controlnet_conditioning_scale
-    }
-    
-    headers = {
-        'accept': 'image/jpeg',
-        'authorization': f'Bearer {api_key}',
-    }
-    
-    response = requests.post(
-        'https://api.fireworks.ai/inference/v1/workflows/accounts/fireworks/models/flux-1-dev-controlnet-union/control_net', 
-        files=files, data=data, headers=headers
-    )
-    
-    if response.status_code == 200:
-        return Image.open(BytesIO(response.content)), processed_image
-    else:
-        st.error(f"Request failed with status code: {response.status_code}, Response: {response.text}")
-        return None, None
-
-def draw_crop_preview(image, x, y, width, height):
-    draw = ImageDraw.Draw(image)
-    for i in range(5):  # Draw multiple rectangles for thickness
-        draw.rectangle([x+i, y+i, x+width-i, y+height-i], outline="red")
-    return image
-
-def smooth_edges(image, crop_box, blur_radius=5):
-    # Create a mask for the cropped area
-    mask = Image.new("L", image.size, 0)
-    draw = ImageDraw.Draw(mask)
-    draw.rectangle(crop_box, fill=255)
-    mask = mask.filter(ImageFilter.GaussianBlur(blur_radius))
-    
-    # Create a new image for blending
-    blended_image = Image.composite(image, Image.new("RGB", image.size, (0, 0, 0)), mask)
-    return blended_image
-
-def add_custom_message(image, message, font_path, font_size):
-    # Load a font
-    try:
-        font = ImageFont.truetype(font_path, font_size)
-    except IOError:
-        font = ImageFont.load_default()
-
-    draw = ImageDraw.Draw(image)
-
-    # Calculate the text bounding box dynamically
-    text_bbox = draw.textbbox((0, 0), message, font=font)
-    text_width = text_bbox[2] - text_bbox[0]
-    text_height = text_bbox[3] - text_bbox[1]
-    img_width, img_height = image.size
-
-    # Center the text
-    x_pos = (img_width - text_width) // 2
-    y_pos = img_height - text_height - 10  # 10 px padding from the bottom
-
-    # Define the padding for the white box
-    padding = 10
-
-    # Draw a white rectangle (the background box) behind the text
-    draw.rectangle([x_pos - padding, y_pos - padding, x_pos + text_width + padding, y_pos + text_height + padding], fill="white")
-
-    # Draw the black text on top of the white box
-    draw.text((x_pos, y_pos), message, font=font, fill="black")
-
-    return image
-
-
-# Define available fonts
-fonts = {
-    "DejaVu Sans Bold": "./fonts/dejavu-sans-bold.ttf",
-    "Covered By You": "./fonts/CoveredByYourGrace-Regular.ttf",  # Update this path to your actual font paths
-    "Julee Regular": "./fonts/Julee-Regular.ttf",  # Example font
-    "Kalam Regular": "./fonts/Kalam-Regular.ttf",
-    "Knewave Regular": "./fonts/Knewave-Regular.ttf",
-    "Sancreek Regular": "./fonts/Sancreek-Regular.ttf",
-    "Vast Shadow Regular": "./fonts/VastShadow-Regular.ttf",
-}
-
-# Streamlit UI
-st.title("Holiday Card Generator with ControlNet")
-
-uploaded_file = st.file_uploader("Upload an image", type=["png", "jpg", "jpeg"])
-
-if uploaded_file is not None:
-    st.session_state.uploaded_file = uploaded_file  # Save the file to session state
-    original_image = Image.open(st.session_state.uploaded_file)
-    st.image(original_image, caption="Uploaded Image", use_column_width=True)
-
-    img_width, img_height = original_image.size
-
-    st.subheader("Crop Selection")
-    col1, col2 = st.columns(2)
-    with col1:
-        x_pos = st.slider("X position", 0, img_width, img_width // 4)
-        crop_width = st.slider("Width", 10, img_width - x_pos, min(img_width // 2, img_width - x_pos))
-    with col2:
-        y_pos = st.slider("Y position", 0, img_height, img_height // 4)
-        crop_height = st.slider("Height", 10, img_height - y_pos, min(img_height // 2, img_height - y_pos))
-
-    preview_image = draw_crop_preview(original_image.copy(), x_pos, y_pos, crop_width, crop_height)
-    st.image(preview_image, caption="Crop Preview", use_column_width=True)
-
-    holiday_prompts = [
-    "A portrait of a person framed by festive snowflakes and winter patterns, with soft, frosty details along the edges for a holiday card",
-    "A joyful portrait with Christmas ornaments and twinkling lights decorating the borders, framing the person in a warm, festive glow",
-    "A cozy portrait with a fireplace scene, stockings, and garlands along the edges, enhancing the warmth of the person in the center",
-    "A colorful Hanukkah-themed portrait with menorahs, dreidels, and holiday lights framing the person against a rich backdrop",
-    "A New Year's Eve portrait with celebratory fireworks, stars, and confetti surrounding the person, giving an energetic, celebratory vibe",
-    "A mystical portrait framed by Samhain symbols like Celtic knots, pumpkins, and candles, creating an enchanting October atmosphere",
-    "A vibrant Día de Muertos portrait with colorful skulls (calaveras), marigold flowers, and candles framing the subject with traditional flair",
-    "A Yule-themed portrait framed by holly, pine trees, and Norse winter symbols under a starry sky, bringing out the warmth of the subject",
-    "A bright and joyful Diwali portrait with lamps (diyas), intricate rangoli patterns, and lotus flowers framing the person for a festive look",
-    "A cozy winter portrait with Dongzhi Festival glutinous rice balls and family gathering symbols along the edges, giving a homely, warm feeling",
-    "A spiritual portrait framed by Zuni and Hopi winter motifs, including Soyal dancers and sun symbols, welcoming the return of the sun",
-    "A winter solstice portrait with bare trees, stars, and the moon softly framing the person in a serene, cold night atmosphere",
-    "A spooky Halloween-themed portrait framed by pumpkins, bats, ghosts, and cobwebs, adding a playful, haunting edge to the subject",
-    "A harvest-themed portrait surrounded by pumpkins, cornucopias, autumn leaves, and turkeys, capturing the essence of Thanksgiving",
-    "A joyful Christmas portrait framed by ornaments, wreaths, and glowing lights, creating a festive and heartwarming holiday look"
-]
-
-    selected_prompt = st.selectbox("Choose a holiday-themed prompt or enter your own", options=["Custom"] + holiday_prompts)
-    custom_prompt = st.text_input("Enter your custom prompt") if selected_prompt == "Custom" else ""
-    prompt = custom_prompt if selected_prompt == "Custom" else selected_prompt
-
-    with st.expander("Advanced Parameters"):
-        control_mode = st.slider("Control Mode", min_value=0, max_value=2, value=0)
-        controlnet_conditioning_scale = st.slider("ControlNet Conditioning Scale", min_value=0.0, max_value=1.0, value=0.5, step=0.1)
-        guidance_scale = st.slider("Guidance Scale", min_value=0.0, max_value=20.0, value=3.5, step=0.1)
-        num_inference_steps = st.slider("Number of Inference Steps", min_value=1, max_value=100, value=30, step=1)
-        seed = st.slider("Random Seed", min_value=0, max_value=1000, value=0)
-
-    custom_message = st.text_input("Enter a custom holiday message to add to the card")
-    
-    # Font selection dropdown and font size slider
-    selected_font = st.selectbox("Choose a font for your message", options=list(fonts.keys()))
-    font_size = st.slider("Font size", 10, 100, 40)
-
-    if st.button("Generate Flux Image"):
-        if not prompt.strip():
-            st.error("Please enter a prompt.")
-        else:
-            with st.spinner("Generating Flux image..."):
-                control_image = create_control_image(original_image, x_pos, y_pos, crop_width, crop_height)
-                st.image(control_image, caption="Control Image (Cropped and Padded)", use_column_width=True)
-
-                generated_image, processed_image = call_control_net_api(
-                    control_image, prompt, control_mode=control_mode, 
-                    guidance_scale=guidance_scale, num_inference_steps=num_inference_steps,
-                    seed=seed, controlnet_conditioning_scale=controlnet_conditioning_scale
-                )
-
-                if generated_image is not None:
-                    st.session_state.generated_image = generated_image
-                    st.session_state.control_image = control_image
-
-                    # Add custom message if provided
-                    if custom_message:
-                        font_path = fonts[selected_font]
-                        generated_image_with_message = add_custom_message(generated_image.copy(), custom_message, font_path, font_size)
-                        st.image(generated_image_with_message, caption="Generated Flux Image with Message", use_column_width=True)
-                    else:
-                        st.image(generated_image, caption="Generated Flux Image", use_column_width=True)
-
-                    st.success("Flux image generated successfully!")
-                else:
-                    st.error("Failed to generate image. Please try again.")
-
-else:
-    st.warning("Please upload an image to get started.")
-

test_endpoint.py

@@ -5,7 +5,8 @@ from PIL import Image
 from io import BytesIO
 
 # Correct the path to the .env file to reflect its location
-dotenv_path = os.path.join(os.path.dirname(__file__), '../env/.env')
+dotenv_path = os.path.join(os.path.dirname(__file__), 'env', '.env')
+#print("dotenv_path: ", dotenv_path)
 
 # Load environment variables from the .env file
 load_dotenv(dotenv_path, override=True)
@@ -26,8 +27,8 @@ if not prompt.strip():
 # Set the model endpoint for either flux-1-dev or flux-1-schnell
 # For dev: "flux-1-dev" (30 steps)
 # For schnell: "flux-1-schnell" (4 steps)
-model_path = "flux-1-schnell"
-# model_path = "flux-1-dev"  # Uncomment if you want to switch to the dev model
+#model_path = "flux-1-schnell-fp8"
+model_path = "flux-1-dev-fp8"  # Uncomment if you want to switch to the dev model
 
 # API URL for the model
 url = f"https://api.fireworks.ai/inference/v1/workflows/accounts/fireworks/models/{model_path}/text_to_image"

utils/configuration.py

@@ -0,0 +1,185 @@
+# configuration.py
+
+import os
+
+
+# ----------------------------------------------
+# Default Parameters for Image Generation
+# ----------------------------------------------
+
+# ControlNet and Image Generation defaults
+default_control_mode = 0
+default_guidance_scale = 3.5  # Adjust how strictly the model follows the prompt
+default_num_inference_steps = 30  # Number of inference steps for image generation
+default_seed = 0  # Seed for randomization (useful for reproducibility)
+default_controlnet_conditioning_scale = 0.5  # Influence scale for ControlNet
+
+# ----------------------------------------------
+# Font and Color Defaults
+# ----------------------------------------------
+
+# Default font sizes and colors for image captions
+default_font_size = 40  # Base font size for captions
+default_max_font_size = 300  # Maximum allowable font size
+default_min_font_size = 10  # Minimum allowable font size
+background_color = "#FFFFFF"  # Default background color for captions
+font_color = "#000000"  # Default font color for captions
+
+# ----------------------------------------------
+# API URL Configuration
+# ----------------------------------------------
+
+# Templates for FLUX and ControlNet API URLs (parameterized to allow flexibility)
+flux_model_url_template = "https://api.fireworks.ai/inference/v1/workflows/accounts/fireworks/models/{model_path}/text_to_image"
+control_net_url = "https://api.fireworks.ai/inference/v1/workflows/accounts/fireworks/models/flux-1-dev-controlnet-union/control_net"
+
+# ----------------------------------------------
+# API Headers Configuration
+# ----------------------------------------------
+
+# Function to generate headers for FLUX requests
+def get_headers(api_key):
+    return {
+        "Authorization": f"Bearer {api_key}",  # Bearer token for API authentication
+        "Content-Type": "application/json",  # Requests will send/receive JSON
+        "Accept": "image/jpeg"  # Expect images as the response format
+    }
+
+# Function to generate headers for ControlNet requests
+def get_control_net_headers(api_key):
+    return {
+        "accept": "image/jpeg",  # Expecting an image in response
+        "authorization": f"Bearer {api_key}",  # API Key for authentication
+    }
+
+# ----------------------------------------------
+# Fonts Configuration
+# ----------------------------------------------
+# Get the base directory dynamically (root project directory)
+BASE_DIR = os.path.dirname(os.path.dirname(__file__))
+
+# Define the fonts you want to allow, with paths relative to BASE_DIR
+fonts = {
+    "DejaVu Sans Bold": os.path.join(BASE_DIR, "fonts", "dejavu-sans-bold.ttf"),
+    "Covered By You": os.path.join(BASE_DIR, "fonts", "CoveredByYourGrace-Regular.ttf"),
+    "Julee Regular": os.path.join(BASE_DIR, "fonts", "Julee-Regular.ttf"),
+    "Kalam Regular": os.path.join(BASE_DIR, "fonts", "Kalam-Regular.ttf"),
+    "Knewave Regular": os.path.join(BASE_DIR, "fonts", "Knewave-Regular.ttf"),
+    "Sancreek Regular": os.path.join(BASE_DIR, "fonts", "Sancreek-Regular.ttf"),
+    "Vast Shadow Regular": os.path.join(BASE_DIR, "fonts", "VastShadow-Regular.ttf")
+}
+
+# ----------------------------------------------
+# Aspect Ratios Configuration
+# ----------------------------------------------
+
+# Dictionary of valid aspect ratios for generated images
+valid_aspect_ratios = {
+    (1, 1): "1:1",   # Square
+    (21, 9): "21:9", # Widescreen
+    (16, 9): "16:9", # Standard video
+    (3, 2): "3:2",   # Common photo ratio
+    (5, 4): "5:4",   # Almost square
+    (4, 5): "4:5",   # Portrait
+    (2, 3): "2:3",   # Another portrait ratio
+    (9, 16): "9:16"  # Vertical video
+}
+
+# ----------------------------------------------
+# Holiday-Themed Prompts
+# ----------------------------------------------
+
+# List of holiday scene prompts for generating themed images
+holiday_scene_prompts = [
+    "A peaceful winter landscape covered in fresh snow, with delicate snowflakes drifting through the air and soft, frosty patterns along the edges, creating a serene holiday card",
+    "A cozy Christmas scene featuring a warmly lit cabin in the woods, surrounded by snow-covered trees and twinkling holiday lights, with a sky glowing softly in the background",
+    "A fireplace with stockings, garlands, and a glowing hearth, set in a cozy room decorated for the holidays, capturing the warmth and tranquility of the season",
+    "A colorful Hanukkah celebration with glowing menorahs, dreidels, and shimmering holiday lights illuminating the night, set against a rich, deep blue backdrop for a festive scene",
+    "A vibrant New Year's Eve cityscape with bright fireworks exploding in the sky, colorful confetti drifting through the air, and stars twinkling above the skyline, radiating excitement",
+    "A mystical Samhain forest scene, with pumpkins glowing softly among tall trees, and a full moon casting light over an ancient Celtic stone circle, evoking an air of magic and mystery",
+    "A lively Día de Muertos altar adorned with colorful calaveras, bright marigold flowers, and glowing candles, set against a traditional Mexican backdrop, celebrating the holiday’s joy",
+    "A wintery Yule forest scene under a starry sky, with snow-covered pine trees, holly bushes, and traditional Norse winter symbols decorating the landscape, capturing the warmth of the season",
+    "A bright and vibrant Diwali celebration with glowing diyas lining a courtyard, intricate rangoli patterns on the ground, and colorful fireworks lighting up the night sky",
+    "A serene Kwanzaa scene featuring a kinara with glowing candles, surrounded by decorations in red, black, and green, set in a peaceful and reflective atmosphere",
+    "A bountiful Thanksgiving table scene set outdoors, surrounded by autumn leaves, pumpkins, and a golden sunset, capturing the essence of gratitude and togetherness",
+    "A tranquil Winter Solstice night with a glowing full moon above, bare trees, stars twinkling in the sky, and a peaceful blanket of snow covering the quiet landscape",
+    "A festive St. Patrick's Day scene featuring a green countryside, with shamrocks covering the rolling hills, a rainbow stretching across the sky, and a pot of gold in the distance",
+    "A colorful Lunar New Year street scene with red lanterns hanging from the rooftops, dragon dancers parading down the street, and vibrant fireworks lighting up the night",
+    "A peaceful Easter garden filled with blooming spring flowers, pastel-colored eggs hidden among the grass, and soft sunlight streaming through the trees",
+    "A romantic Valentine's Day scene with glowing candles, heart-shaped decorations hanging from tree branches, and a soft pink and red sunset in the sky",
+    "A lively Holi celebration in an open field, with bursts of vibrant color powder filling the air, and people joyfully celebrating under a bright blue sky",
+    "A tranquil Ramadan evening scene with a crescent moon and stars hanging in the night sky, glowing lanterns decorating the streets, and peaceful reflections along a quiet river",
+    "A lively Independence Day celebration with colorful fireworks lighting up the night sky, flags waving in the breeze, and a peaceful lakeside reflecting the celebration"
+]
+
+
+# List of holiday scene prompts for generating themed images
+holiday_portrait_prompts = [
+   "A portrait of a person framed by festive snowflakes and winter patterns, with soft, frosty details along the edges for a holiday card",
+    "A joyful portrait with Christmas ornaments and twinkling lights decorating the borders, framing the person in a warm, festive glow",
+    "A cozy portrait with a fireplace scene, stockings, and garlands along the edges, enhancing the warmth of the person in the center",
+    "A colorful Hanukkah-themed portrait with menorahs, dreidels, and holiday lights framing the person against a rich backdrop",
+    "A New Year's Eve portrait with celebratory fireworks, stars, and confetti surrounding the person, giving an energetic, celebratory vibe",
+    "A mystical portrait framed by Samhain symbols like Celtic knots, pumpkins, and candles, creating an enchanting October atmosphere",
+    "A vibrant Día de Muertos portrait with colorful skulls (calaveras), marigold flowers, and candles framing the subject with traditional flair",
+    "A Yule-themed portrait framed by holly, pine trees, and Norse winter symbols under a starry sky, bringing out the warmth of the subject",
+    "A bright and joyful Diwali portrait with lamps (diyas), intricate rangoli patterns, and lotus flowers framing the person for a festive look",
+    "A cozy winter portrait with Dongzhi Festival glutinous rice balls and family gathering symbols along the edges, giving a homely, warm feeling",
+    "A spiritual portrait framed by Zuni and Hopi winter motifs, including Soyal dancers and sun symbols, welcoming the return of the sun",
+    "A winter solstice portrait with bare trees, stars, and the moon softly framing the person in a serene, cold night atmosphere",
+    "A spooky Halloween-themed portrait framed by pumpkins, bats, ghosts, and cobwebs, adding a playful, haunting edge to the subject",
+    "A harvest-themed portrait surrounded by pumpkins, cornucopias, autumn leaves, and turkeys, capturing the essence of Thanksgiving",
+    "A joyful Christmas portrait framed by ornaments, wreaths, and glowing lights, creating a festive and heartwarming holiday look"
+]
+
+# List of prompts for holiday cards
+holiday_border_prompts = [
+    "A holiday card with a blank center, surrounded by a delicate border of falling snowflakes and frosty winter patterns along the edges, creating a peaceful winter scene",
+    "A cozy holiday card with a blank center, bordered by snow-covered pine trees, glowing cabin lights, and twinkling Christmas decorations framing the edges",
+    "A Lunar New Year holiday card with a blank center, surrounded by red lanterns, dragon dancers, and vibrant fireworks along the edges, celebrating the new year",
+    "An Easter holiday card with a blank center, bordered by blooming spring flowers, pastel-colored eggs, and soft sunlight, capturing the joy of new beginnings along the edges",
+    "A Valentine's Day holiday card with a blank center, surrounded by heart-shaped decorations, glowing candles, and pink and red floral patterns for a romantic atmosphere",
+    "A Holi holiday card with a blank center, framed by bursts of vibrant color powder and festive energy, capturing the lively spirit of the festival along the edges",
+    "A Ramadan holiday card with a blank center, bordered by a crescent moon, twinkling stars, and glowing lanterns, creating a peaceful and reflective holiday frame",
+    "An Independence Day holiday card with a blank center, framed by colorful fireworks, waving flags, and festive red, white, and blue decorations along the edges",
+    "A warm holiday card with a blank center, bordered by stockings, garlands, and a glowing hearth, evoking the coziness of a holiday fireplace",
+    "A Hanukkah holiday card with a blank center, surrounded by a glowing menorah, dreidels, and shimmering holiday lights along the edges, set against a deep blue background",
+    "A New Year's Eve holiday card with a blank center, framed by bright fireworks, colorful confetti, and twinkling stars, capturing the festive excitement around the edges",
+    "A mystical Samhain holiday card with a blank center, bordered by glowing pumpkins, Celtic knots, and a full moon shining through bare trees, creating an air of mystery",
+    "A Día de Muertos holiday card with a blank center, bordered by vibrant calaveras (skulls), bright marigolds, and glowing candles, celebrating the Mexican holiday along the edges",
+    "A Yule holiday card with a blank center, bordered by snow-covered pine trees, holly bushes, and traditional Norse winter symbols, creating a festive winter atmosphere",
+    "A Diwali holiday card with a blank center, framed by glowing diyas, intricate rangoli patterns, and colorful fireworks, lighting up the edges with festive energy",
+    "A Kwanzaa holiday card with a blank center, surrounded by a kinara with glowing candles and decorations in red, black, and green, creating a reflective and peaceful frame",
+    "A Thanksgiving holiday card with a blank center, bordered by autumn leaves, pumpkins, and a golden sunset, evoking the warmth and gratitude of the harvest season",
+    "A Winter Solstice holiday card with a blank center, framed by a glowing full moon, twinkling stars, and bare trees dusted with snow, creating a tranquil winter scene",
+    "A St. Patrick's Day holiday card with a blank center, bordered by shamrocks, a rainbow, and a pot of gold, framed by lush green fields for a festive Irish celebration",
+]
+
+
+
+# ----------------------------------------------
+# Example Holiday Messages
+# ----------------------------------------------
+
+# List of example holiday messages to pair with the scene prompts
+example_holiday_messages = [
+    "Wishing you peace and serenity this winter season. May the snow bring you joy and tranquility!",
+    "May your Christmas be as cozy and warm as a cabin in the woods, filled with holiday lights and love.",
+    "Warm wishes for the holidays! May your hearth and home be filled with love and joy this season.",
+    "Happy Hanukkah! May the light of the menorah shine brightly and bring joy to your heart.",
+    "Wishing you a vibrant New Year's Eve filled with excitement, fireworks, and joy for the year ahead!",
+    "May the magic and mystery of Samhain fill your spirit with wonder. Have a mystical holiday!",
+    "Celebrating the joy of Día de Muertos! May the memories of your loved ones bring peace and happiness.",
+    "Wishing you a Yule season filled with the warmth of the Norse tradition and the beauty of snowy forests.",
+    "Happy Diwali! May the lights of the diyas and the colors of rangoli bring you prosperity and joy.",
+    "Wishing you a reflective and peaceful Kwanzaa. May your home be filled with love, light, and unity.",
+    "Happy Thanksgiving! May your table be filled with gratitude, and your heart with the warmth of togetherness.",
+    "Wishing you a peaceful Winter Solstice night under the full moon. May the season bring you reflection and rest.",
+    "May the luck of the Irish be with you! Wishing you a joyful St. Patrick's Day filled with rainbows and gold.",
+    "Happy Lunar New Year! May the dragon dancers bring joy, and the fireworks light up a prosperous new year.",
+    "Wishing you a peaceful Easter surrounded by blooming flowers and the warmth of springtime sunshine.",
+    "Happy Valentine's Day! May your day be filled with love, glowing candles, and heartwarming moments.",
+    "Wishing you a joyful Holi! May the colors of the festival fill your life with vibrancy and happiness.",
+    "Ramadan Mubarak! May the crescent moon bring you peace, and the lanterns light up your spiritual path.",
+    "Happy Independence Day! May the fireworks light up the sky, and may freedom continue to inspire us all."
+]

utils/helper_utilities.py

@@ -0,0 +1,281 @@
+# helper_utilities.py
+
+import os
+from PIL import Image, ImageDraw, ImageFont, ImageColor
+import requests
+from io import BytesIO
+import textwrap
+import cv2
+import numpy as np
+from dotenv import load_dotenv
+
+# Import configuration values from configuration.py
+from utils.configuration import (
+    fonts,  # Now this should correctly import fonts
+    default_guidance_scale, 
+    default_control_mode, 
+    default_num_inference_steps, 
+    default_seed, 
+    default_controlnet_conditioning_scale,
+    flux_model_url_template,
+    control_net_url,
+    get_headers,
+    get_control_net_headers,
+    valid_aspect_ratios
+)
+
+# ----------------------------------------------
+# Environment Handling
+# ----------------------------------------------
+
+def load_env(dotenv_path):
+    """Loads environment variables from a .env file."""
+    load_dotenv(dotenv_path, override=True)
+
+# ----------------------------------------------
+# General Utilities
+# ----------------------------------------------
+
+def get_font(font_path, font_size):
+    """Tries to load a specified font. Falls back to default if not found."""
+    try:
+        font = ImageFont.truetype(font_path, font_size)
+    except IOError:
+        font = ImageFont.load_default()
+    return font
+
+def send_post_request(url, headers, data, files=None):
+    """A general function to send POST requests and handle responses."""
+    if files:
+        response = requests.post(url, headers=headers, files=files, data=data)
+    else:
+        response = requests.post(url, headers=headers, json=data)
+
+    if response.status_code == 200:
+        return response
+    else:
+        raise RuntimeError(f"Request failed with status code: {response.status_code}, Response: {response.text}")
+
+def resize_image(image, size):
+    """Resizes the image to the specified size."""
+    return image.resize(size)
+
+def combine_images(image1, image2):
+    """Combines two images side by side."""
+    combined = Image.new("RGB", (image1.width + image2.width, max(image1.height, image2.height)))
+    combined.paste(image1, (0, 0))
+    combined.paste(image2, (image1.width, 0))
+    return combined
+
+# ----------------------------------------------
+# FLUX API and ControlNet Functions
+# ----------------------------------------------
+
+def generate_flux_image(model_path, api_key, prompt, steps=default_num_inference_steps, 
+                        aspect_ratio="16:9", guidance_scale=default_guidance_scale, 
+                        seed=default_seed, deployment=None):
+    """
+    Generates an image using the FLUX model based on the provided parameters.
+    
+    :param model_path: Path to the FLUX model
+    :param api_key: API key for authentication
+    :param prompt: Text prompt to generate the image
+    :param steps: Number of inference steps for the model
+    :param aspect_ratio: Desired aspect ratio for the output image
+    :param guidance_scale: How strictly the model should follow the prompt
+    :param seed: Seed value for randomization (for reproducibility)
+    :param deployment: Optional deployment string for specific model deployments
+    :return: Generated image as a PIL image
+    """
+    # Build the request URL
+    base_url = flux_model_url_template.format(model_path=model_path)
+    
+    # If a specific deployment is provided, add it to the URL as a query parameter
+    if deployment:
+        url = f"{base_url}?deployment={deployment}"
+    else:
+        url = base_url
+
+    headers = get_headers(api_key)
+
+     # Data payload for the request
+    data = {
+        "prompt": prompt,
+        "aspect_ratio": aspect_ratio,
+        "guidance_scale": guidance_scale,
+        "num_inference_steps": steps,
+        "seed": seed
+    }
+    
+    # Send the POST request and handle the response
+    response = requests.post(url, headers=headers, json=data)
+    
+    if response.status_code == 200:
+        # If the response is successful, convert the response content into an image
+        img = Image.open(BytesIO(response.content))
+        return img
+    else:
+        # Raise an error if the request fails
+        raise RuntimeError(f"Failed to generate image: {response.status_code}, {response.text}")
+
+def call_control_net_api(control_image, prompt, api_key, 
+                         control_mode=0, 
+                         guidance_scale=default_guidance_scale, 
+                         num_inference_steps=default_num_inference_steps, 
+                         seed=default_seed, 
+                         controlnet_conditioning_scale=default_controlnet_conditioning_scale):
+    """
+    Calls the ControlNet API, sending a control image and prompt.
+    Generates a new image based on ControlNet, processes the control image, 
+    and handles aspect ratios.
+    """
+    # Process control image for ControlNet
+    processed_image_bytes, processed_image = process_image(control_image)
+    files = {'control_image': ('control_image.jpg', processed_image_bytes, 'image/jpeg')}
+    
+    # Calculate aspect ratio based on control image dimensions
+    width, height = control_image.size
+    aspect_ratio = f"{width}:{height}"
+    
+    data = {
+        'prompt': prompt,
+        'control_mode': control_mode,
+        'aspect_ratio': aspect_ratio,
+        'guidance_scale': guidance_scale,
+        'num_inference_steps': num_inference_steps,
+        'seed': seed,
+        'controlnet_conditioning_scale': controlnet_conditioning_scale
+    }
+    
+    url = control_net_url
+    headers = get_control_net_headers(api_key)
+
+    # Send the POST request to ControlNet API
+    response = send_post_request(url, headers, data, files)
+    
+    # Convert the response to an image
+    generated_image = Image.open(BytesIO(response.content))
+    return generated_image, processed_image
+
+# ----------------------------------------------
+# Image Manipulation Utilities
+# ----------------------------------------------
+
+def overlay_text_on_image(image, text, font_path, font_size, position):
+    """Draws text on the image at the specified position."""
+    draw = ImageDraw.Draw(image)
+    font = get_font(font_path, font_size)
+    draw.text(position, text, font=font, fill="black")
+    return image
+
+def get_closest_aspect_ratio(width, height):
+    """
+    Finds the closest valid aspect ratio for the given image dimensions.
+    Uses the valid_aspect_ratios from configuration.py.
+    """
+    aspect_ratio = width / height
+    closest_ratio = min(valid_aspect_ratios.keys(), key=lambda x: abs((x[0] / x[1]) - aspect_ratio))
+    return valid_aspect_ratios[closest_ratio]
+
+
+def get_next_largest_aspect_ratio(width, height):
+    """
+    Finds the next largest valid aspect ratio for the given image dimensions.
+    Returns the aspect ratio as a tuple, formatted as (width, height).
+    """
+    aspect_ratio = width / height
+    larger_ratios = [(x[0] / x[1], x) for x in valid_aspect_ratios.keys() if (x[0] / x[1]) >= aspect_ratio]
+    
+    if larger_ratios:
+        # Return the smallest of the larger valid aspect ratios
+        next_largest_ratio = min(larger_ratios, key=lambda x: x[0])
+        return next_largest_ratio[1]  # Return the tuple (width, height)
+    else:
+        # If no larger aspect ratio is found, fall back to the closest
+        closest_ratio = min(valid_aspect_ratios.keys(), key=lambda x: abs((x[0] / x[1]) - aspect_ratio))
+        return closest_ratio
+
+
+
+def process_image(image):
+    """
+    Processes an image by converting it to grayscale and detecting edges.
+    Returns the edge-detected image.
+    """
+    gray_image = image.convert('L')
+    np_image = np.array(gray_image)
+    edges = cv2.Canny(np_image, 100, 200)
+    edges_rgb = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
+    return Image.fromarray(edges_rgb)
+
+def draw_crop_preview(image, x, y, width, height):
+    """Draws a red rectangle on the image to preview a crop region."""
+    draw = ImageDraw.Draw(image)
+    draw.rectangle([x, y, x + width, y + height], outline="red", width=2)
+    return image
+
+def wrap_text(text, max_chars):
+    """Wraps text to a specified number of characters per line."""
+    return "\n".join(textwrap.fill(line, width=max_chars) for line in text.split("\n"))
+
+# ----------------------------------------------
+# Text and Image Combination Utilities
+# ----------------------------------------------
+
+def add_custom_message(image, message, font_path, font_size, position_vertical, position_horizontal, max_chars, bg_color, font_color, alpha):
+    """
+    Adds a custom message to the image with specified font, positioning, and background color.
+    Supports text wrapping and transparent background behind the text.
+    """
+    # Load font
+    try:
+        font = ImageFont.truetype(font_path, font_size)
+    except IOError:
+        font = ImageFont.load_default()
+
+    # Convert image to RGBA if it's not already
+    if image.mode != "RGBA":
+        image = image.convert("RGBA")
+
+    # Create an overlay for the text
+    overlay = Image.new("RGBA", image.size, (255, 255, 255, 0))  # Fully transparent
+    draw = ImageDraw.Draw(overlay)
+
+    # Wrap the message text
+    message = wrap_text(message, max_chars)
+
+    img_width, img_height = image.size
+    text_lines = message.split("\n")
+    line_height = draw.textbbox((0, 0), "A", font=font)[3]  # Calculate height of a line of text
+    total_text_height = line_height * len(text_lines)
+    text_width = max([draw.textbbox((0, 0), line, font=font)[2] for line in text_lines])
+
+    # Horizontal positioning
+    if position_horizontal == "Left":
+        x_pos = 10  # Padding from the left
+    elif position_horizontal == "Center":
+        x_pos = (img_width - text_width) // 2
+    else:  # "Right"
+        x_pos = img_width - text_width - 10  # Padding from the right
+
+    # Vertical positioning
+    if position_vertical == "Top":
+        y_pos = 10  # Padding from the top
+    elif position_vertical == "Center":
+        y_pos = (img_height - total_text_height) // 2
+    else:  # "Bottom"
+        y_pos = img_height - total_text_height - 10  # Padding from the bottom
+
+    # Draw the semi-transparent background rectangle behind the text
+    padding = 10
+    bg_color_rgba = (*ImageColor.getrgb(bg_color), alpha)  # Apply transparency
+    draw.rectangle([x_pos - padding, y_pos - padding, x_pos + text_width + padding, y_pos + total_text_height + padding], fill=bg_color_rgba)
+
+    # Draw the text line by line
+    for i, line in enumerate(text_lines):
+        draw.text((x_pos, y_pos + i * line_height), line, font=font, fill=font_color)
+
+    # Composite the overlay with the original image
+    combined = Image.alpha_composite(image, overlay)
+
+    return combined.convert("RGB")  # Convert back to RGB for saving/display