Update app.py

app.py

@@ -1,8 +1,20 @@
+# -*- coding: utf-8 -*-
+
+################################################################################
+# WARNING: API Key Security
+# This application requires you to enter your Gemini API key manually in the UI.
+# DO NOT paste your API key directly into this code if you plan to share it.
+# Ensure your API key is kept confidential. Sharing your key can lead to
+# unauthorized use and potential charges to your account.
+# Consider using secure methods like environment variables or secrets management
+# for deployed applications.
+################################################################################
+
 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
+import os # Still useful for potential future path operations, etc.
 
 # --- Constants for Limits ---
 TITLE_MAX_LEN = 60
@@ -95,19 +107,27 @@ REMINDER: Make sure each title aims for EXACTLY {TITLE_MAX_LEN} characters. Coun
 
     return combined_prompt
 
-def generate_amazon_listing(api_key, quote, niche, target, keywords):
+# Takes the API Key directly as an argument
+def generate_amazon_listing(api_key_input, 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"
+
+    # --- Input Validation ---
+    # Clean the API key first to handle potential whitespace issues
+    cleaned_api_key = api_key_input.strip() if api_key_input else ""
+
+    if not cleaned_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)"
+        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)
+        # --- Configure API ---
+        # Use the cleaned API key from the input
+        print(f"DEBUG: Configuring with API Key (length {len(cleaned_api_key)}): '{cleaned_api_key[:5]}...{cleaned_api_key[-5:]}'") # Log sanitized key
+        if '\n' in cleaned_api_key or '\r' in cleaned_api_key:
+             print("WARNING: API Key may contain newline characters!")
+
+        genai.configure(api_key=cleaned_api_key)
 
         # Create model with optimized settings
         model = genai.GenerativeModel(
@@ -116,7 +136,6 @@ def generate_amazon_listing(api_key, quote, niche, target, keywords):
                 "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
             }
         )
@@ -128,9 +147,8 @@ def generate_amazon_listing(api_key, quote, niche, target, keywords):
             # --- Generate Main Listing Content ---
             response = model.generate_content(prompt)
 
-            # Since we requested JSON, parse it directly. Add error handling.
+            # Parse JSON response
             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)
@@ -143,37 +161,30 @@ def generate_amazon_listing(api_key, quote, niche, target, keywords):
                 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:
+                print(f"Raw response text: {getattr(response, 'text', 'N/A')}")
+                if hasattr(response, 'prompt_feedback') and 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
+            suggested_keywords = result.get("suggested_keywords", "Error generating suggested keywords")
 
             # --- 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."
+                # This is a soft warning, not necessarily a hard error
+                print(f"Warning: Generated title ('{title}') might not strongly match the requested theme: '{quote}', '{niche}', or '{target}'.")
+
 
             # --- 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:
@@ -188,7 +199,7 @@ def generate_amazon_listing(api_key, quote, niche, target, keywords):
                 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
+            # Format main output first
             main_output = format_output(
                 title,
                 brand_name,
@@ -200,12 +211,10 @@ def generate_amazon_listing(api_key, quote, niche, target, 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
+                     generation_config={
+                        "temperature": 0.4,
                         "top_p": 0.8,
                         "max_output_tokens": 1024,
                         "response_mime_type": "application/json"
@@ -215,7 +224,6 @@ def generate_amazon_listing(api_key, quote, niche, target, keywords):
                  # 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)
@@ -224,52 +232,58 @@ def generate_amazon_listing(api_key, quote, niche, target, keywords):
 
                     variations = json.loads(json_str_var)
 
-                    # Format variations output, enforcing limits here too
+                    # Format variations output, enforcing limits
                     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
+                        truncated_var = var[:TITLE_MAX_LEN]
                         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
+                        truncated_var = var[:BRAND_NAME_MAX_LEN]
                         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:
+                    if hasattr(response_var, 'prompt_feedback') and 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
+                print(f"Error generating variations: {var_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."
-
+            print(f"Error during main listing generation: {e}")
+            # Attempt to get more specific feedback if available
+            finish_reason = "Unknown"
+            safety_ratings = "Unknown"
+            if hasattr(response, 'candidates') and response.candidates:
+                 finish_reason = getattr(response.candidates[0], 'finish_reason', 'UNKNOWN')
+                 safety_ratings = getattr(response.candidates[0], 'safety_ratings', 'UNKNOWN')
+            print(f"Finish Reason: {finish_reason}, Safety Ratings: {safety_ratings}")
+            return f"Error generating main listing (Reason: {finish_reason}). Please check logs or try again."
+
+    # Catch configuration errors or other unexpected issues outside the API call block
+    except google.api_core.exceptions.PermissionDenied as perm_denied:
+         print(f"Permission Denied Error: {perm_denied}")
+         return "Error: Permission Denied. Please check if your API key is valid, correctly entered, and has the necessary permissions enabled."
     except Exception as e:
-        # Catch configuration errors or other unexpected issues
-        print(f"General Error: {e}") # Log the error
+        print(f"General Error: {e}")
+        # Check if it's an authentication error which often manifests differently
+        if "authentication" in str(e).lower() or "credentials" in str(e).lower():
+             return "Error: Authentication failed. Please double-check your API key."
         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:
@@ -278,12 +292,12 @@ def create_interface():
 
         with gr.Row():
             with gr.Column(scale=1):
-                # Recommend using environment variable for API key in real deployments
-                api_key = gr.Textbox(
+                # API Key input is now mandatory here
+                api_key_ui = gr.Textbox(
                     label="Gemini API Key",
-                    placeholder="Enter your Gemini API key (or leave blank if set as environment variable)",
+                    placeholder="Enter your Gemini API key here",
                     type="password",
-                    # value=os.getenv("GEMINI_API_KEY", "") # Pre-fill if env var exists
+                    # Make sure this input component is mandatory in the logic below
                 )
                 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")
@@ -300,21 +314,23 @@ def create_interface():
                 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
+        # This function is called when the button is clicked
+        def on_submit(api_key_from_ui, quote, niche, target, keywords):
+            # --- Validation directly in the submit handler ---
+            if not api_key_from_ui or not api_key_from_ui.strip():
+                # Update status first before returning error message
                 yield "Error: Gemini API Key is required.", ""
-                return # Stop execution
+                return # Stop execution if API key is missing
+
+            if not quote or not niche or not target:
+                yield "Error: Quote, Niche/Holiday, and Target Audience are required.", ""
+                return # Stop if other core fields are missing
 
             # 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)
+            # Call the main generation function, passing the API key from the UI
+            result = generate_amazon_listing(api_key_from_ui, quote, niche, target, keywords)
 
             # Update status and output based on the result
             if "Error:" in result:
@@ -322,11 +338,13 @@ def create_interface():
             else:
                 yield "Listing generated successfully!", result
 
+        # Connect the button click to the on_submit function
         submit_btn.click(
             fn=on_submit,
-            inputs=[api_key, quote, niche, target, keywords],
+            # Pass the API key from the UI component as the first input
+            inputs=[api_key_ui, quote, niche, target, keywords],
             outputs=[status, output],
-            show_progress="full" # Show more detailed progress
+            show_progress="full"
         )
 
         gr.Markdown("## Example Input")
@@ -340,11 +358,11 @@ Use the pre-filled example above or enter your own details:
 
         gr.Markdown("""
         ## Notes & Troubleshooting
+        *   **API Key:** You MUST enter a valid Gemini API key in the field above for the generator to work. Keep your key secure.
         *   **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.
+        *   **Errors:** If you see errors related to 'BlockedPromptException' or 'Safety', your input might have triggered content filters. Try rephrasing. 'Permission Denied' or 'Authentication Failed' errors usually indicate an invalid or incorrectly entered API key. 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`).
+        *   **JSON Request:** The app explicitly requests JSON output from the API (`response_mime_type`).
         """)
 
     return app
@@ -352,8 +370,8 @@ Use the pre-filled example above or enter your own details:
 # --- Create and Launch the Gradio App ---
 app = create_interface()
 
-# Launch the app (remove debug=True for production)
+# Launch the app (remove debug=True for production deployments)
+# Set share=True to get a temporary public link for testing (use with caution due to API key input)
 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)
+    app.launch(debug=True) # Add share=True here if needed: app.launch(debug=True, share=True)
+    # app.launch() # Use for deployment (e.g., on Hugging Face Spaces - remember security implications)