Refactor skin_analysis endpoint to use RapidAPI for skin analysis

app.py

@@ -5,6 +5,9 @@ import os
 import tempfile
 import json
 import requests
+from io import BytesIO
+from dotenv import load_dotenv
+load_dotenv()
 
 # Import deepface with error handling
 try:
@@ -174,126 +177,79 @@ async def analyze_image(file: UploadFile = File(...)):
                 pass
 
 
-# @app.post("/skin-analysis")
-# async def skin_analysis(file: UploadFile = File(...)):
-#     """
-#     Upload an image and get comprehensive skin analysis results.
+@app.post("/skin-analysis")
+async def skin_analysis(file: UploadFile = File(...)):
+    """
+    Upload an image and get comprehensive skin analysis results.
     
-#     Args:
-#         file: Image file to analyze (supports common image formats)
+    Args:
+        file: Image file to analyze (supports common image formats)
     
-#     Returns:
-#         JSON response with detailed skin analysis information
-#     """
-#     # Validate file type
-#     if not file.content_type or not file.content_type.startswith('image/'):
-#         raise HTTPException(status_code=400, detail="File must be an image")
+    Returns:
+        JSON response with detailed skin analysis information
+    """
+    # Validate file type
+    if not file.content_type or not file.content_type.startswith('image/'):
+        raise HTTPException(status_code=400, detail="File must be an image")
     
-#     # Get API key from environment variable
-#     api_key = os.getenv("AILABAPI_API_KEY", "")
+    # Get API key from environment variable
+    api_key = os.getenv("RAPIDAPI_KEY", "")
+    if not api_key:
+        raise HTTPException(
+            status_code=500,
+            detail="RAPIDAPI_KEY environment variable is not set"
+        )
     
-#     # Create a temporary file to save the uploaded image
-#     tmp_file_path = None
-#     try:
-#         # Read file contents
-#         contents = await file.read()
+    try:
+        # Read file contents
+        contents = await file.read()
         
-#         # Create temporary file and write contents
-#         with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.filename)[1]) as tmp_file:
-#             tmp_file.write(contents)
-#             tmp_file_path = tmp_file.name
+        # Prepare request to RapidAPI
+        url = "https://skin-analysis-api.p.rapidapi.com/predict"
+        querystring = {"lang": "en"}
         
-#         # Prepare request to ailabapi
-#         url = "https://www.ailabapi.com/api/portrait/analysis/skin-analysis"
+        # Use BytesIO to create a file-like object from the contents
+        file_obj = BytesIO(contents)
         
-#         # Open the temporary file for the request
-#         with open(tmp_file_path, 'rb') as image_file:
-#             files = {"image": (file.filename or "image.jpg", image_file, file.content_type)}
-#             headers = {"ailabapi-api-key": api_key}
-            
-#             # Make request to ailabapi
-#             response = requests.post(url, files=files, headers=headers)
-            
-#             if response.status_code != 200:
-#                 raise HTTPException(
-#                     status_code=response.status_code,
-#                     detail=f"External API error: {response.text}"
-#                 )
-            
-#             data = response.json()
+        # Try "file" as field name first (common for RapidAPI endpoints)
+        files = {"file": (file.filename or "image.jpg", file_obj, file.content_type)}
+        headers = {
+            "x-rapidapi-key": api_key,
+            "x-rapidapi-host": "skin-analysis-api.p.rapidapi.com"
+        }
         
-#         # Mapping dictionaries
-#         yes_no_mapping = {0: "No", 1: "Yes"}
-#         eyelids_mapping = {
-#             0: "Single eyelids",
-#             1: "Parallel Double Eyelids",
-#             2: "Scalloped Double Eyelids"
-#         }
-#         skin_type_mapping = {
-#             0: "Oily skin",
-#             1: "Dry skin",
-#             2: "Neutral skin",
-#             3: "Combination skin"
-#         }
+        # Make request to RapidAPI
+        # Note: When using files parameter, requests automatically sets Content-Type to multipart/form-data
+        response = requests.post(url, files=files, headers=headers, params=querystring)
         
-#         # Fields that use Yes/No mapping
-#         yes_no_fields = [
-#             "pores_left_cheek", "nasolabial_fold", "eye_pouch", "forehead_wrinkle",
-#             "skin_spot", "acne", "pores_forehead", "pores_jaw", "eye_finelines",
-#             "dark_circle", "crows_feet", "pores_right_cheek", "blackhead",
-#             "glabella_wrinkle", "mole"
-#         ]
+        # If "file" doesn't work, try "image" as fallback
+        if response.status_code == 400 and "No file found" in response.text:
+            file_obj.seek(0)  # Reset file pointer
+            files = {"image": (file.filename or "image.jpg", file_obj, file.content_type)}
+            response = requests.post(url, files=files, headers=headers, params=querystring)
         
-#         # Transform the result data
-#         if "result" in data:
-#             result = data["result"]
-            
-#             # Transform Yes/No fields
-#             for field in yes_no_fields:
-#                 if field in result and "value" in result[field]:
-#                     result[field]["value_label"] = yes_no_mapping.get(result[field]["value"], "Unknown")
-            
-#             # Transform eyelid fields
-#             if "left_eyelids" in result and "value" in result["left_eyelids"]:
-#                 result["left_eyelids"]["value_label"] = eyelids_mapping.get(result["left_eyelids"]["value"], "Unknown")
-            
-#             if "right_eyelids" in result and "value" in result["right_eyelids"]:
-#                 result["right_eyelids"]["value_label"] = eyelids_mapping.get(result["right_eyelids"]["value"], "Unknown")
-            
-#             # Transform skin_type
-#             if "skin_type" in result:
-#                 if "skin_type" in result["skin_type"]:
-#                     result["skin_type"]["skin_type_label"] = skin_type_mapping.get(result["skin_type"]["skin_type"], "Unknown")
-#                 if "details" in result["skin_type"]:
-#                     for detail in result["skin_type"]["details"]:
-#                         if "value" in detail:
-#                             detail["value_label"] = skin_type_mapping.get(detail["value"], "Unknown")
+        if response.status_code != 200:
+            raise HTTPException(
+                status_code=response.status_code,
+                detail=f"External API error: {response.text}"
+            )
         
-#         return JSONResponse(content=data)
+        data = response.json()
+        return JSONResponse(content=data)
         
-#     except requests.exceptions.RequestException as e:
-#         raise HTTPException(
-#             status_code=500,
-#             detail=f"Error calling external API: {str(e)}"
-#         )
-#     except Exception as e:
-#         raise HTTPException(
-#             status_code=500,
-#             detail=f"Error processing image: {str(e)}"
-#         )
-#     finally:
-#         # Clean up temporary file
-#         if tmp_file_path and os.path.exists(tmp_file_path):
-#             try:
-#                 import time
-#                 time.sleep(0.1)
-#                 os.unlink(tmp_file_path)
-#             except (PermissionError, OSError):
-#                 pass
+    except requests.exceptions.RequestException as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error calling external API: {str(e)}"
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error processing image: {str(e)}"
+        )
 
 
 @app.get("/health")
 async def health_check():
     """Health check endpoint"""
-    return {"status": "healthy"}
-
+    return {"status": "healthy"}