Upload 4 files

.dockerignore

@@ -0,0 +1,19 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info
+dist
+build
+.git
+.gitignore
+.env
+.venv
+venv/
+*.md
+!README.md
+main.py
+

Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY app.py .
+
+# Expose port (Hugging Face Spaces uses port 7860 by default)
+EXPOSE 7860
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+
+# Run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+

app.py

@@ -0,0 +1,299 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import os
+import tempfile
+import json
+import requests
+
+# Import deepface with error handling
+try:
+    from deepface import DeepFace
+    import cv2
+    import numpy as np
+    DEEPFACE_AVAILABLE = True
+except ImportError as e:
+    DEEPFACE_AVAILABLE = False
+    print(f"Warning: DeepFace not available. Please install dependencies: {e}")
+
+
+def convert_to_serializable(obj):
+    """Convert numpy types and other non-serializable types to native Python types"""
+    if DEEPFACE_AVAILABLE:
+        if isinstance(obj, np.integer):
+            return int(obj)
+        elif isinstance(obj, np.floating):
+            return float(obj)
+        elif isinstance(obj, np.ndarray):
+            return obj.tolist()
+    
+    # Handle dict and list recursively
+    if isinstance(obj, dict):
+        return {key: convert_to_serializable(value) for key, value in obj.items()}
+    elif isinstance(obj, list):
+        return [convert_to_serializable(item) for item in obj]
+    
+    # Try to convert to float if it's a number-like object
+    try:
+        if hasattr(obj, 'item'):  # numpy scalar
+            return obj.item()
+    except (AttributeError, ValueError):
+        pass
+    
+    return obj
+
+
+app = FastAPI(title="Age, Emotion, and Gender Detection API", version="1.0.0")
+
+# Add CORS middleware to allow requests from React app
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, replace with specific origins
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Age, Emotion, and Gender Detection API",
+        "endpoints": {
+            "/analyze": "POST - Upload an image to detect age, emotion, and gender",
+            "/skin-analysis": "POST - Upload an image for comprehensive skin analysis"
+        }
+    }
+
+
+@app.post("/analyze")
+async def analyze_image(file: UploadFile = File(...)):
+    """
+    Upload an image and get age, emotion, and gender detection results.
+    
+    Args:
+        file: Image file to analyze (supports common image formats)
+    
+    Returns:
+        JSON response with age, gender, and emotion information
+    """
+    # Check if DeepFace is available
+    if not DEEPFACE_AVAILABLE:
+        raise HTTPException(
+            status_code=503,
+            detail="DeepFace module not available. Please install dependencies: pip install -r requirements.txt"
+        )
+    
+    # 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")
+    
+    # Create a temporary file to save the uploaded image
+    tmp_file_path = None
+    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
+        
+        # Analyze the image
+        try:
+            results = DeepFace.analyze(
+                img_path=tmp_file_path,
+                actions=['age', 'gender', 'emotion'],
+                enforce_detection=False  # Continue even if face detection fails
+            )
+            
+            # Handle both single result and list of results
+            if isinstance(results, list):
+                result = results[0]
+            else:
+                result = results
+            
+            # Extract age (convert to native Python int)
+            age = int(result.get("age", 0))
+            
+            # Extract gender and convert numpy types
+            gender_dict = result.get("gender", {})
+            gender_dict = convert_to_serializable(gender_dict)
+            if gender_dict:
+                dominant_gender = max(gender_dict, key=gender_dict.get)
+                gender_confidence = float(gender_dict[dominant_gender])
+            else:
+                dominant_gender = "Unknown"
+                gender_confidence = 0.0
+            
+            # Extract emotion and convert numpy types
+            emotion_dict = result.get("emotion", {})
+            emotion_dict = convert_to_serializable(emotion_dict)
+            if emotion_dict:
+                dominant_emotion = max(emotion_dict, key=emotion_dict.get)
+                emotion_confidence = float(emotion_dict[dominant_emotion])
+            else:
+                dominant_emotion = "Unknown"
+                emotion_confidence = 0.0
+            
+            # Prepare response with all values converted to native Python types
+            response = {
+                "success": True,
+                "age": age,
+                "gender": {
+                    "prediction": dominant_gender,
+                    "confidence": round(gender_confidence, 2),
+                    "all_predictions": gender_dict
+                },
+                "emotion": {
+                    "prediction": dominant_emotion,
+                    "confidence": round(emotion_confidence, 2),
+                    "all_predictions": emotion_dict
+                }
+            }
+            
+            return JSONResponse(content=response)
+            
+        except Exception as e:
+            raise HTTPException(
+                status_code=500,
+                detail=f"Error analyzing image: {str(e)}"
+            )
+    
+    finally:
+        # Clean up temporary file (close it first on Windows)
+        if tmp_file_path and os.path.exists(tmp_file_path):
+            try:
+                # On Windows, we need to ensure the file is closed before deletion
+                import time
+                time.sleep(0.1)  # Small delay to ensure file is released
+                os.unlink(tmp_file_path)
+            except (PermissionError, OSError) as e:
+                # If deletion fails, try to delete on next attempt or ignore
+                # The OS will clean up temp files eventually
+                pass
+
+
+@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)
+    
+    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", "")
+    
+    # Create a temporary file to save the uploaded image
+    tmp_file_path = None
+    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 ailabapi
+        url = "https://www.ailabapi.com/api/portrait/analysis/skin-analysis"
+        
+        # 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()
+        
+        # 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"
+        }
+        
+        # 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"
+        ]
+        
+        # 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")
+        
+        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
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy"}
+

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn[standard]
+python-multipart
+deepface
+opencv-python
+numpy
+tensorflow-cpu
+Pillow
+requests