Upload 3 files

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,160 @@
+
+from fastapi import FastAPI, File, UploadFile, Form, HTTPException
+from fastapi.responses import JSONResponse
+import tempfile
+from dotenv import load_dotenv
+import os
+import google.generativeai as genai # Correct import alias
+import json
+import logging # Added for better debugging
+
+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
+
+# --- 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).")
+
+    tmp_path = None # Initialize tmp_path
+    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_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, 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."
+        )
+
+        # 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.")
+
+
+    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)
+
+    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.")
+
+    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}")
+
+# --- 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)