Update app.py

app.py

@@ -1,160 +1,58 @@
-
-from fastapi import FastAPI, File, UploadFile, Form, HTTPException
+from fastapi import FastAPI, File, UploadFile, Form
 from fastapi.responses import JSONResponse
 import tempfile
 from dotenv import load_dotenv
 import os
-import google.generativeai as genai # Correct import alias
+import google.generativeai as genai
 import json
-import logging # Added for better debugging
+import logging
 
 load_dotenv()
-# Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 app = FastAPI()
 
-# --- Configuration ---
-# Load API Key securely (e.g., from environment variable)
-# Replace with your actual key retrieval method
-API_KEY = os.getenv("GOOGLE_API_KEY") # Use environment variable or replace directly
-
-if not API_KEY:
-    logger.error("GEMINI_API_KEY environment variable not set.")
-    # You might want to raise an exception or exit here in a real application
-    # For now, we'll let it proceed but it will fail later if the placeholder key is invalid
-
-# Configure the Gemini client globally
-try:
-    genai.configure(api_key=API_KEY)
-    logger.info("Google Gemini client configured successfully.")
-except Exception as e:
-    logger.error(f"Failed to configure Google Gemini client: {e}")
-    # Handle configuration error appropriately
-
-# Initialize the Generative Model globally
-# Use a model that supports image input, like gemini-1.5-flash-latest or gemini-pro-vision
-# gemini-1.5-flash is generally recommended now
-try:
-    model = genai.GenerativeModel("gemini-2.0-flash") # Using the recommended flash model
-    logger.info(f"Google Gemini model '{model.model_name}' initialized.")
-except Exception as e:
-    logger.error(f"Failed to initialize Google Gemini model: {e}")
-    # Handle model initialization error appropriately
+API_KEY = os.getenv("GOOGLE_API_KEY")
+genai.configure(api_key=API_KEY)
+model = genai.GenerativeModel("gemini-2.0-flash")
 
-# --- FastAPI Endpoint ---
 @app.post("/rate-outfit/")
 async def rate_outfit(image: UploadFile = File(...), category: str = Form(...)):
-    logger.info(f"Received request to rate outfit. Category: {category}, Image: {image.filename}, Content-Type: {image.content_type}")
-
     if image.content_type not in ["image/jpeg", "image/png", "image/jpg"]:
-        logger.warning(f"Invalid image content type: {image.content_type}")
-        raise HTTPException(status_code=400, detail="Please upload a valid image file (jpeg, png, jpg).")
+        return JSONResponse(content={"message": "Please review the image before uploading"})
 
-    tmp_path = None # Initialize tmp_path
+    tmp_path = None
     try:
-        # Save image to temp file safely
-        # Using a context manager ensures the file is closed properly
         with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(image.filename)[1]) as tmp:
-            content = await image.read()
-            tmp.write(content)
+            tmp.write(await image.read())
             tmp_path = tmp.name
-        logger.info(f"Image saved temporarily to: {tmp_path}")
 
-        # Upload image to Gemini using the recommended function
-        logger.info("Uploading image to Gemini...")
-        # The new API uses genai.upload_file directly
         uploaded_file = genai.upload_file(path=tmp_path, display_name=image.filename)
-        logger.info(f"Image uploaded successfully: {uploaded_file.name}")
-
 
-        # Define the prompt clearly
         prompt = (
             f"You are an AI fashion assistant. Based on the category '{category}', analyze the provided image. "
-            "Extract the following information and provide the response ONLY as a valid JSON object, without any surrounding text, markdown formatting (like ```json), or explanations. "
-            "The JSON object should follow this exact schema: "
-            '{"Tag": "A short, catchy caption phrase based on the image, including a relevant emoji.", '
-            '"Feedback": "Concise advice (1-2 sentences) on how the look could be improved or styled differently."}'
-            " --- IMPORTANT SAFETY CHECK: If the image contains nudity, offensive content, any religious context, political figure, or anything inappropriate for a fashion context, respond ONLY with the following JSON: "
-            '{"error": "Please upload an appropriate image"} --- '
-            "Focus on being concise and eye-catching."
+            "Extract the following information and provide the response ONLY as a valid JSON object, without explanations. "
+            "Schema: {\"Tag\": \"catchy phrase\", \"Feedback\": \"concise advice\"}. "
+            "If inappropriate, respond ONLY with {\"error\": \"Please upload an appropriate image\"}."
         )
 
-        # Prepare content for the model (prompt first, then file)
-        # Ensure the uploaded file object is used, not just the path
-        content_parts = [prompt, uploaded_file] # Pass the UploadedFile object
-
-        logger.info("Generating content with Gemini model...")
-        # Generate content
-        response = model.generate_content(content_parts)
-        logger.info("Received response from Gemini.")
-        # logger.debug(f"Raw Gemini response text: {response.text}") # Optional: Log raw response for debugging
-
-        # Clean and parse the response
-        text_response = response.text.strip()
-
-        # Robust cleaning: Remove potential markdown code blocks
-        if text_response.startswith("```json"):
-            text_response = text_response[7:] # Remove ```json\n
-        if text_response.endswith("```"):
-            text_response = text_response[:-3] # Remove ```
-        text_response = text_response.strip() # Strip again after removing markdown
-
-        logger.info(f"Cleaned Gemini response text: {text_response}")
-
-        # Attempt to parse the cleaned JSON
-        try:
-            result = json.loads(text_response)
-            # Validate if the result contains expected keys or the error key
-            if "error" in result:
-                 logger.warning(f"Gemini detected inappropriate image: {result['error']}")
-                 # Return a different status code for client-side handling? (e.g., 400 Bad Request)
-                 # raise HTTPException(status_code=400, detail=result['error'])
-                 # Or just return the error JSON as requested by some flows:
-                 return JSONResponse(content=result, status_code=200) # Or 400 depending on desired API behavior
-            elif "Tag" not in result or "Feedback" not in result:
-                 logger.error(f"Gemini response missing expected keys 'Tag' or 'Feedback'. Got: {result}")
-                 raise HTTPException(status_code=500, detail="AI response format error: Missing expected keys.")
-
-            logger.info(f"Successfully parsed Gemini response: {result}")
-            return JSONResponse(content=result)
-
-        except json.JSONDecodeError as json_err:
-            logger.error(f"Failed to decode JSON response from Gemini: {json_err}")
-            logger.error(f"Invalid JSON string received: {text_response}")
-            raise HTTPException(status_code=500, detail="AI response format error: Invalid JSON.")
-        except Exception as parse_err: # Catch other potential errors during parsing/validation
-            logger.error(f"Error processing Gemini response: {parse_err}")
-            raise HTTPException(status_code=500, detail="Error processing AI response.")
+        response = model.generate_content([prompt, uploaded_file])
+        result = json.loads(response.text.strip().replace('```json', '').replace('```', '').strip())
 
+        if "error" in result:
+            return JSONResponse(content={"message": "Please review the image before uploading"})
 
-    except genai.types.generation_types.BlockedPromptException as block_err:
-        logger.warning(f"Gemini blocked the prompt or response due to safety settings: {block_err}")
-        # Return a generic safety message or the specific error JSON
-        error_response = {"error": "Request blocked due to safety policies. Please ensure the image is appropriate."}
-        # It's often better to return a 400 Bad Request here
-        return JSONResponse(content=error_response, status_code=400)
+        return JSONResponse(content=result)
 
     except Exception as e:
-        logger.error(f"An unexpected error occurred: {e}", exc_info=True) # Log full traceback
-        # Generic error for security reasons, details are logged
-        raise HTTPException(status_code=500, detail="An internal server error occurred.")
+        logger.error(f"Error: {e}")
+        return JSONResponse(content={"message": "Please review the image before uploading"})
 
     finally:
-        # Cleanup temp image file if it was created
         if tmp_path and os.path.exists(tmp_path):
-            try:
-                os.remove(tmp_path)
-                logger.info(f"Temporary file {tmp_path} removed.")
-            except OSError as e:
-                logger.error(f"Error removing temporary file {tmp_path}: {e}")
+            os.remove(tmp_path)
 
-# --- To Run (if this is the main script) ---
 if __name__ == "__main__":
     import uvicorn
-#     # Remember to set the GEMINI_API_KEY environment variable before running
-    # Example (Linux/macOS): export GEMINI_API_KEY='your_actual_api_key'
-#     # Example (Windows CMD): set GEMINI_API_KEY=your_actual_api_key
-#     # Example (Windows PowerShell): $env:GEMINI_API_KEY='your_actual_api_key'
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    uvicorn.run(app, host="0.0.0.0", port=8000)