Spaces:
Running
Running
| import gradio as gr | |
| import google.generativeai as genai | |
| import re | |
| import json | |
| import os # Good practice to import os if using env variables later | |
| # --- Constants for Limits --- | |
| TITLE_MAX_LEN = 60 | |
| BRAND_NAME_MAX_LEN = 50 | |
| BULLET_POINT_MAX_LEN = 256 | |
| BULLET_POINT_MIN_LEN = 240 # Keep this if you want to check minimum length later | |
| def count_characters(text): | |
| """Count characters in text.""" | |
| return len(text) if text else 0 | |
| def format_output(title, brand_name, bullet1, bullet2, suggested_keywords=None): | |
| """Format the output with character counts (reflecting potentially truncated lengths).""" | |
| # Display the actual length after potential truncation | |
| output = f"Title ({count_characters(title)}/{TITLE_MAX_LEN} characters):\n{title}\n\n" | |
| output += f"Brand Name ({count_characters(brand_name)}/{BRAND_NAME_MAX_LEN} characters):\n{brand_name}\n\n" | |
| output += f"Bullet Point 1 ({count_characters(bullet1)}/{BULLET_POINT_MAX_LEN} characters):\n{bullet1}\n\n" | |
| output += f"Bullet Point 2 ({count_characters(bullet2)}/{BULLET_POINT_MAX_LEN} characters):\n{bullet2}" | |
| if suggested_keywords: | |
| output += f"\n\nSuggested Additional Keywords:\n{suggested_keywords}" | |
| return output | |
| def generate_prompt(quote, niche, target, keywords): | |
| """Generate the prompt for Gemini API.""" | |
| # Keep the detailed prompt instructions as they help guide the AI | |
| combined_prompt = f"""You are an Amazon Merch on Demand SEO expert specializing in creating optimized t-shirt and apparel listings. | |
| MY INPUT IS ABOUT: A {niche} t-shirt with the design/quote: "{quote}" for {target}. | |
| YOU MUST ONLY create an Amazon apparel listing about that EXACT input - no substitutions or different themes allowed. | |
| Generate a listing that includes: | |
| 1. Title (try for exactly {TITLE_MAX_LEN} characters): Must include "{niche}" and reference the design/quote "{quote}" and target audience "{target}" | |
| 2. Brand Name (try for 34-{BRAND_NAME_MAX_LEN} characters): Create a fitting brand name for this specific {niche} apparel for {target} | |
| 3. Bullet Point 1 (try for {BULLET_POINT_MIN_LEN}-{BULLET_POINT_MAX_LEN} characters): Highlight key features using ALL CAPS for the first 2-3 words. Focus ONLY on the design, quote, and niche theme. | |
| 4. Bullet Point 2 (try for {BULLET_POINT_MIN_LEN}-{BULLET_POINT_MAX_LEN} characters): Highlight additional features using ALL CAPS for the first 2-3 words. Focus ONLY on the design, quote, and niche theme. | |
| IMPORTANT RULES — STRICT ENFORCEMENT: | |
| - DO NOT include generic phrases like "PREMIUM QUALITY" or references to material quality | |
| - DO NOT include phrases like "This comfortable and stylish tee is made with high-quality materials for a soft feel and long-lasting wear" | |
| - Bullet point 1 must be between {BULLET_POINT_MIN_LEN} and {BULLET_POINT_MAX_LEN} characters. Aim for the higher end. | |
| - Bullet point 2 must be between {BULLET_POINT_MIN_LEN} and {BULLET_POINT_MAX_LEN} characters. Aim for the higher end. | |
| - DO NOT exceed the character limits ({TITLE_MAX_LEN} for title, {BRAND_NAME_MAX_LEN} for brand, {BULLET_POINT_MAX_LEN} for bullets). | |
| - Count characters carefully. Ensure compliance before outputting. | |
| - Focus ONLY on the specific design, niche, and quote provided | |
| - Every sentence must directly relate to the quote, niche theme, and target audience | |
| - Do not include any content that strays from the specific theme provided | |
| The listing should be specifically for t-shirts, hoodies, or sweaters for the Amazon Merch on Demand program. | |
| The listing MUST be about: {niche} + {quote} + for {target}. Do not generate content about other holidays, quotes, or audiences. | |
| Use these specific keywords in your listing: {keywords} | |
| Respond ONLY with a JSON object in this format: | |
| {{ | |
| "title": "The title aiming for {TITLE_MAX_LEN} characters", | |
| "brand_name": "Brand name aiming for 34-{BRAND_NAME_MAX_LEN} characters", | |
| "bullet_point_1": "First bullet point aiming for {BULLET_POINT_MIN_LEN}-{BULLET_POINT_MAX_LEN} characters", | |
| "bullet_point_2": "Second bullet point aiming for {BULLET_POINT_MIN_LEN}-{BULLET_POINT_MAX_LEN} characters", | |
| "suggested_keywords": "5 additional keywords separated by commas" | |
| }} | |
| REMINDER: Make sure to count the characters carefully. Aim for Title exactly {TITLE_MAX_LEN} characters. Aim for Bullet points 1 and 2 between {BULLET_POINT_MIN_LEN}-{BULLET_POINT_MAX_LEN} characters. | |
| STRICT ENFORCEMENT: Bullet point 1 and 2 MUST be between {BULLET_POINT_MIN_LEN} and {BULLET_POINT_MAX_LEN} characters. If it's {BULLET_POINT_MAX_LEN+1}+, the result is invalid. Carefully count and ensure compliance. | |
| """ | |
| return combined_prompt | |
| def generate_multiple_variations_prompt(quote, niche, target, keywords): | |
| """Generate the prompt for multiple variations of title and brand name.""" | |
| combined_prompt = f"""You are an Amazon Merch on Demand SEO expert specializing in creating optimized t-shirt and apparel listings. | |
| MY INPUT IS ABOUT: A {niche} t-shirt with the design/quote: "{quote}" for {target}. | |
| YOU MUST ONLY create variations about that EXACT input - no substitutions or different themes allowed. | |
| Generate 3 different variations for the Title and Brand Name based on the provided information. | |
| All variations MUST be about {niche} + "{quote}" + for {target} audience. | |
| The titles MUST include: | |
| - The specific holiday/event: {niche} | |
| - Reference to the quote/design: "{quote}" | |
| - The target audience: {target} | |
| Focus only on t-shirts, sweaters, and hoodies for the Amazon Merch on Demand program. | |
| All titles must aim for exactly {TITLE_MAX_LEN} characters and brand names between 34-{BRAND_NAME_MAX_LEN} characters. | |
| Respond ONLY with a JSON object in this format: | |
| {{ | |
| "title_variations": [ | |
| "Title variation 1 - aim for {TITLE_MAX_LEN} characters, count carefully", | |
| "Title variation 2 - aim for {TITLE_MAX_LEN} characters, count carefully", | |
| "Title variation 3 - aim for {TITLE_MAX_LEN} characters, count carefully" | |
| ], | |
| "brand_name_variations": [ | |
| "Brand name variation 1 (aim for 34-{BRAND_NAME_MAX_LEN} characters)", | |
| "Brand name variation 2 (aim for 34-{BRAND_NAME_MAX_LEN} characters)", | |
| "Brand name variation 3 (aim for 34-{BRAND_NAME_MAX_LEN} characters)" | |
| ] | |
| }} | |
| REMINDER: Make sure each title aims for EXACTLY {TITLE_MAX_LEN} characters. Count carefully!""" | |
| return combined_prompt | |
| def generate_amazon_listing(api_key, quote, niche, target, keywords): | |
| """Generate Amazon listing using Gemini API, enforcing character limits.""" | |
| # Input validation | |
| if not api_key: | |
| return "Error: Please enter a valid Gemini API key" | |
| if not quote or not niche or not target: | |
| return "Error: Please fill in all required fields (Quote, Holiday/Event, and Target Audience)" | |
| try: | |
| # Configure the Gemini API with the provided key | |
| # Consider using environment variables for production: | |
| # api_key = os.getenv("GEMINI_API_KEY") or api_key_input | |
| genai.configure(api_key=api_key) | |
| # Create model with optimized settings | |
| model = genai.GenerativeModel( | |
| 'gemini-1.5-pro', # Or 'gemini-1.5-flash' for potentially faster/cheaper generation | |
| generation_config={ | |
| "temperature": 0.3, # Lower temperature for more predictable output | |
| "top_p": 0.8, | |
| "max_output_tokens": 1024, # Maximum tokens the API can *return* | |
| # Note: 'max_output_tokens' doesn't directly control character count precisely | |
| "response_mime_type": "application/json" # Request JSON directly | |
| } | |
| ) | |
| # Generate the main listing | |
| prompt = generate_prompt(quote, niche, target, keywords) | |
| try: | |
| # --- Generate Main Listing Content --- | |
| response = model.generate_content(prompt) | |
| # Since we requested JSON, parse it directly. Add error handling. | |
| try: | |
| # Access the text part and load as JSON | |
| response_text = response.text | |
| # Sometimes the API might still wrap it in markdown, try to strip it | |
| json_match = re.search(r'```json\s*({.*?})\s*```', response_text, re.DOTALL | re.IGNORECASE) | |
| if json_match: | |
| json_str = json_match.group(1) | |
| else: | |
| # Fallback if no markdown backticks are found | |
| json_str = response_text.strip() | |
| result = json.loads(json_str) | |
| except (json.JSONDecodeError, AttributeError, IndexError) as json_err: | |
| # Handle cases where response.text is empty, not valid JSON, or API returned unexpected format | |
| print(f"JSON Parsing Error: {json_err}") | |
| print(f"Raw response text: {getattr(response, 'text', 'N/A')}") # Log raw response for debugging | |
| # Check for safety blocks | |
| if response.prompt_feedback.block_reason: | |
| return f"Error: Generation blocked due to: {response.prompt_feedback.block_reason}. Content filters may have been triggered." | |
| return "Error: Could not parse JSON response from Gemini API. The API might have returned an unexpected format or an empty response. Please try again." | |
| # --- ENFORCE CHARACTER LIMITS --- | |
| # Get raw values and immediately truncate if they exceed the MAX limit | |
| title = result.get("title", "")[:TITLE_MAX_LEN] | |
| brand_name = result.get("brand_name", "")[:BRAND_NAME_MAX_LEN] | |
| bullet1 = result.get("bullet_point_1", "")[:BULLET_POINT_MAX_LEN] | |
| bullet2 = result.get("bullet_point_2", "")[:BULLET_POINT_MAX_LEN] | |
| suggested_keywords = result.get("suggested_keywords", "Error generating suggested keywords") # Keywords don't usually need truncation | |
| # --- VALIDATION (using potentially truncated values) --- | |
| # Validate that the output actually matches the input criteria (optional but good) | |
| # Check if *any* part of the target audience is in the title if it's comma-separated | |
| target_parts = [t.strip().lower() for t in target.split(',')] | |
| title_lower = title.lower() | |
| if not (quote.lower() in title_lower or | |
| niche.lower() in title_lower or | |
| any(t_part in title_lower for t_part in target_parts)): | |
| return f"Error: Generated title ('{title}') doesn't seem to strongly match the requested theme: '{quote}', '{niche}', or '{target}'. Please try again or adjust input." | |
| # --- Optional: Validate the *lower* bound for bullet points --- | |
| # Uncomment these lines if you strictly need the bullets to be AT LEAST min_len characters | |
| # Note: This check happens *after* truncation, so if truncation occurred, it might pass this check. | |
| # if len(bullet1) < BULLET_POINT_MIN_LEN: | |
| # return f"Error: Bullet point 1 length ({len(bullet1)}) is less than the required minimum {BULLET_POINT_MIN_LEN} characters after generation/truncation. Please try again." | |
| # if len(bullet2) < BULLET_POINT_MIN_LEN: | |
| # return f"Error: Bullet point 2 length ({len(bullet2)}) is less than the required minimum {BULLET_POINT_MIN_LEN} characters after generation/truncation. Please try again." | |
| # Check for generic content in bullet points | |
| generic_phrases = ["premium quality", "high-quality materials", "soft feel", "long-lasting wear", | |
| "comfortable and stylish"] | |
| bullet1_lower = bullet1.lower() | |
| bullet2_lower = bullet2.lower() | |
| for phrase in generic_phrases: | |
| if phrase in bullet1_lower or phrase in bullet2_lower: | |
| return f"Error: Generated bullet points contain disallowed generic phrase '{phrase}'. Please try again." | |
| # Format main output first - using the enforced length values | |
| main_output = format_output( | |
| title, | |
| brand_name, | |
| bullet1, | |
| bullet2, | |
| suggested_keywords | |
| ) | |
| # --- Generate Variations (Optional Second Call) --- | |
| try: | |
| variations_prompt = generate_multiple_variations_prompt(quote, niche, target, keywords) | |
| # Use a separate model instance or reuse if configuration is the same | |
| # Using the same model instance here | |
| response_var = model.generate_content( | |
| variations_prompt, | |
| generation_config={ # Can reuse or adjust config for variations | |
| "temperature": 0.4, # Slightly higher temp for more variety | |
| "top_p": 0.8, | |
| "max_output_tokens": 1024, | |
| "response_mime_type": "application/json" | |
| } | |
| ) | |
| # Parse variations JSON | |
| try: | |
| response_var_text = response_var.text | |
| # Try stripping markdown again | |
| json_match_var = re.search(r'```json\s*({.*?})\s*```', response_var_text, re.DOTALL | re.IGNORECASE) | |
| if json_match_var: | |
| json_str_var = json_match_var.group(1) | |
| else: | |
| json_str_var = response_var_text.strip() | |
| variations = json.loads(json_str_var) | |
| # Format variations output, enforcing limits here too | |
| variations_output = "\n\nADDITIONAL VARIATIONS:\n\n" | |
| variations_output += "Title Variations:\n" | |
| for i, var in enumerate(variations.get("title_variations", []), 1): | |
| truncated_var = var[:TITLE_MAX_LEN] # Enforce limit | |
| variations_output += f"{i}. {truncated_var} ({count_characters(truncated_var)}/{TITLE_MAX_LEN} characters)\n" | |
| variations_output += "\nBrand Name Variations:\n" | |
| for i, var in enumerate(variations.get("brand_name_variations", []), 1): | |
| truncated_var = var[:BRAND_NAME_MAX_LEN] # Enforce limit | |
| variations_output += f"{i}. {truncated_var} ({count_characters(truncated_var)}/{BRAND_NAME_MAX_LEN} characters)\n" | |
| # Combine main output with variations | |
| return main_output + variations_output | |
| except (json.JSONDecodeError, AttributeError, IndexError) as json_var_err: | |
| print(f"JSON Parsing Error (Variations): {json_var_err}") | |
| print(f"Raw variations response text: {getattr(response_var, 'text', 'N/A')}") | |
| # Check for safety blocks on variations | |
| if response_var.prompt_feedback.block_reason: | |
| return main_output + f"\n\n(Could not generate variations: Blocked - {response_var.prompt_feedback.block_reason})" | |
| return main_output + "\n\n(Could not parse variations response)" | |
| except genai.types.generation_types.BlockedPromptException as var_block_error: | |
| return main_output + f"\n\n(Variations prompt blocked: {var_block_error})" | |
| except Exception as var_error: | |
| # Catch other errors during variation generation | |
| print(f"Error generating variations: {var_error}") # Log the error | |
| return main_output + f"\n\n(Could not generate variations due to an error)" | |
| except genai.types.generation_types.BlockedPromptException as block_error: | |
| # Catch blocked prompts specifically for better feedback | |
| return f"Error: The main prompt was blocked by Gemini API safety filters: {block_error}. Please modify your input and try again." | |
| except Exception as e: | |
| # Catch other potential errors during the main API call | |
| print(f"Error during main listing generation: {e}") # Log the error | |
| # You might want to check response.candidates[0].finish_reason if available | |
| # finish_reason = getattr(response.candidates[0], 'finish_reason', 'UNKNOWN') | |
| # safety_ratings = getattr(response.candidates[0].safety_ratings, 'name', 'UNKNOWN') | |
| return f"Error generating main listing. Please check logs or try again." | |
| except Exception as e: | |
| # Catch configuration errors or other unexpected issues | |
| print(f"General Error: {e}") # Log the error | |
| return f"An unexpected error occurred: {str(e)}" | |
| # --- Create the Gradio Interface --- | |
| def create_interface(): | |
| with gr.Blocks(title="Amazon Merch on Demand Listing Generator", theme=gr.themes.Soft()) as app: | |
| gr.Markdown("# Amazon Merch on Demand Listing Generator") | |
| gr.Markdown("Generate SEO-optimized t-shirt and apparel listings for Amazon Merch on Demand using Gemini AI. Character limits are enforced.") | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| # Recommend using environment variable for API key in real deployments | |
| api_key = gr.Textbox( | |
| label="Gemini API Key", | |
| placeholder="Enter your Gemini API key (or leave blank if set as environment variable)", | |
| type="password", | |
| # value=os.getenv("GEMINI_API_KEY", "") # Pre-fill if env var exists | |
| ) | |
| quote = gr.Textbox(label="Quote/Design/Idea", placeholder="e.g., Lucky To Be A Teacher", value="Rainbow with a quote \"Lucky To Be A Teacher\"") | |
| niche = gr.Textbox(label="Niche/Holiday/Event", placeholder="e.g., St Patrick's Day", value="St Patricks Day") | |
| target = gr.Textbox(label="Target Audience", placeholder="e.g., Teacher, Mom, Dad", value="Teacher, Teacher Mom") | |
| keywords = gr.Textbox( | |
| label="Target Keywords (comma-separated)", | |
| placeholder="Enter keywords relevant to your design", | |
| lines=5, | |
| value="lucky, teacher, rainbow, st, patricks, day, t-shirt, patrick's, outfit, design, leopard, cheetah, print, shamrock, clover, perfect, men, women, teachers, celebrate, saint, patrick, special, unique, makes, great, gifts, idea, substitute, love, irish, culture, pattys, holiday, teach, shamrocks, cute, design, awesome, show, students" | |
| ) | |
| submit_btn = gr.Button("Generate Amazon Listing", variant="primary") | |
| with gr.Column(scale=2): | |
| status = gr.Textbox(label="Status", value="Ready", interactive=False, lines=1) | |
| output = gr.Textbox(label="Generated Amazon Listing", lines=25, interactive=True) # Make output selectable | |
| def on_submit(api_key_input, quote, niche, target, keywords): | |
| # Use environment variable if input is blank (optional but good practice) | |
| # final_api_key = os.getenv("GEMINI_API_KEY") or api_key_input | |
| final_api_key = api_key_input # Keep it simple for now | |
| if not final_api_key: | |
| # Update status first before returning error message | |
| yield "Error: Gemini API Key is required.", "" | |
| return # Stop execution | |
| # Update status to indicate processing | |
| yield "Generating listing... This may take a moment.", "Processing..." | |
| # Generate the listing | |
| result = generate_amazon_listing(final_api_key, quote, niche, target, keywords) | |
| # Update status and output based on the result | |
| if "Error:" in result: | |
| yield f"Finished with Error.", result | |
| else: | |
| yield "Listing generated successfully!", result | |
| submit_btn.click( | |
| fn=on_submit, | |
| inputs=[api_key, quote, niche, target, keywords], | |
| outputs=[status, output], | |
| show_progress="full" # Show more detailed progress | |
| ) | |
| gr.Markdown("## Example Input") | |
| gr.Markdown(''' | |
| Use the pre-filled example above or enter your own details: | |
| * **Quote/Design:** The core text or visual idea on the shirt. | |
| * **Niche/Holiday:** The specific event, theme, or category (e.g., Halloween, Fishing, Dog Lover). | |
| * **Target Audience:** Who is this shirt for? (e.g., Nurse, Engineer, Grandpa). | |
| * **Keywords:** Relevant terms customers might search for. | |
| ''') | |
| gr.Markdown(""" | |
| ## Notes & Troubleshooting | |
| * **Character Limits:** The app attempts to generate text close to the limits requested in the prompt, but **strictly enforces maximum lengths** by truncating if necessary (Title: 60, Brand: 50, Bullets: 256). The displayed count reflects the final length. | |
| * **API Key:** For security, consider setting your Gemini API Key as an environment variable (`GEMINI_API_KEY`) instead of pasting it directly, especially if deploying publicly. | |
| * **Errors:** If you see errors related to 'BlockedPromptException' or 'Safety', your input might have triggered content filters. Try rephrasing. Other errors might relate to API connectivity or quota. | |
| * **Variations:** The app generates the main listing first, then attempts to generate title/brand variations. Variation generation might fail separately without affecting the main listing. | |
| * **JSON Request:** The app now explicitly requests JSON output from the API (`response_mime_type`). | |
| """) | |
| return app | |
| # --- Create and Launch the Gradio App --- | |
| app = create_interface() | |
| # Launch the app (remove debug=True for production) | |
| if __name__ == "__main__": | |
| # Set share=True to get a public link (useful for temporary sharing) | |
| app.launch(debug=True) | |
| # app.launch() # For deployment (e.g., Hugging Face Spaces) |