Prepare for HF deployment: clean structure, HF optimizations, remove demo files

.gitignore

@@ -1,10 +1,4 @@
-# Virtual Environment
-.venv/
-venv/
-env/
-ENV/
-
-# Python cache
+# Python
 __pycache__/
 *.py[cod]
 *$py.class
@@ -27,8 +21,14 @@ wheels/
 *.egg
 MANIFEST
 
-# Old files directory
-old_files/
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
 
 # IDE
 .vscode/
@@ -50,36 +50,35 @@ Thumbs.db
 *.log
 logs/
 
-# Environment variables
-.env
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
+# Cache
+cache/
+*.cache
+.hf_cache/
 
-# Temporary files
-*.tmp
-*.temp
+# Results and temporary files
+results/
 temp/
 tmp/
+*.tmp
 
-# Model files (if any)
-*.pth
-*.pt
-*.onnx
-*.bin
+# Test files
+test_*.py
+*_test.py
+test_image.jpg
+
+# Documentation (keep only main README)
+README_RU.md
+demo.html
+
+# Environment files (will be set in HF)
+.env
+.env.local
+.env.production
 
-# Jupyter Notebook
-.ipynb_checkpoints
+# Docker
+.dockerignore
 
-# Coverage reports
-htmlcov/
-.tox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-.hypothesis/
-.pytest_cache/
+# HF specific
+.hf_cache/
+transformers_cache/
+datasets_cache/

Dockerfile

@@ -1,15 +1,16 @@
 # Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
 # you will also find guides on how best to write your Dockerfile
 
-FROM python:3.9
+FROM python:3.9-slim
 
-# Install only server-side dependencies for OpenCV (no GUI)
+# Install system dependencies
 RUN apt-get update && apt-get install -y --no-install-recommends \
     libjpeg62-turbo-dev \
     libpng16-16 \
     libtiff6 \
     libopenblas-dev \
     gfortran \
+    curl \
     && rm -rf /var/lib/apt/lists/*
 
 # The two following lines are requirements for the Dev Mode to be functional
@@ -17,8 +18,36 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 RUN useradd -m -u 1000 user
 WORKDIR /app
 
-COPY --chown=user ./requirements.txt requirements.txt
-RUN pip install --no-cache-dir --upgrade -r requirements.txt
+# Copy requirements first for better caching
+COPY --chown=user requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
 
+# Copy application code
 COPY --chown=user . /app
+
+# Create necessary directories
+RUN mkdir -p /app/logs /app/cache && chown -R user:user /app
+
+# Switch to user
+USER user
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Expose port
+EXPOSE 7860
+
+# Default command (can be overridden)
 CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+
+# Alternative commands for different deployment scenarios:
+# For production with multiple workers:
+# CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "4"]
+# 
+# For development with auto-reload:
+# CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--reload"]
+# 
+# For Hugging Face Spaces (single worker recommended):
+# CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -9,4 +9,79 @@ license: mit
 short_description: Clothing segmentation and background removal
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Loomi Clothing Detection API 🚀
+
+AI-powered clothing analysis and segmentation API, optimized for Hugging Face Spaces.
+
+## ✨ Features
+
+- **🧠 AI-Powered**: Uses Segformer model for clothing detection
+- **🖼️ Image Processing**: Background removal and dominant color detection
+- **⚡ Async**: Non-blocking model loading and request processing
+- **🚦 Rate Limiting**: Per-user request limits and concurrent control
+- **👥 Multi-User**: Supports multiple users with isolation
+- **🔧 HF Optimized**: Built specifically for Hugging Face Spaces
+
+## 🚀 Quick Start
+
+### API Endpoints
+
+- `GET /` - API overview
+- `GET /health` - System health and status
+- `GET /user/stats` - User usage statistics
+- `POST /clothing` - Detect clothing types and coordinates
+- `POST /analyze` - Full analysis with color detection
+- `POST /analyze/download` - Download processed images
+
+### Usage Example
+
+```python
+import requests
+
+# Upload image for clothing detection
+with open('image.jpg', 'rb') as f:
+    response = requests.post(
+        'https://your-hf-space.hf.space/clothing',
+        files={'file': f}
+    )
+    result = response.json()
+    print(result)
+```
+
+## 🏗️ Architecture
+
+- **FastAPI**: Modern, fast web framework
+- **Async Processing**: Non-blocking operations
+- **Rate Limiting**: User-based request control
+- **Model Management**: Efficient ML model loading
+- **Queue System**: Background task processing
+
+## 🔧 Configuration
+
+The API automatically detects Hugging Face Spaces and applies optimizations:
+
+- Single worker process
+- Conservative rate limits (15 req/min, 5 concurrent)
+- Optimized cache sizes
+- HF-specific environment variables
+
+## 📱 Integration
+
+Perfect for:
+- Mobile apps (React Native, Flutter)
+- Web applications
+- E-commerce platforms
+- Fashion analysis tools
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Submit a pull request
+
+---
+
+**Made with ❤️ by the Loomi Team**
+
+*AI-powered clothing analysis, production ready! 🎯*

__init__.py

@@ -0,0 +1,30 @@
+"""
+Loomi Clothing Detection API
+============================
+
+A clean, modular FastAPI application for AI-powered clothing analysis and segmentation.
+
+Features:
+- Async model loading
+- Rate limiting and user management
+- Queue-based processing
+- Token system foundation
+- Clean, maintainable code structure
+
+Modules:
+- main.py: Main FastAPI application
+- config.py: Configuration management
+- rate_limiter.py: Rate limiting and user tracking
+- model_manager.py: Async ML model management
+- request_queue.py: Background task processing
+- user_manager.py: User identification and management
+- clothing_detector.py: Core ML inference
+- process.py: Image processing utilities
+
+Author: Loomi Team
+Version: 2.0.0
+"""
+
+__version__ = "2.0.0"
+__author__ = "Loomi Team"
+__description__ = "AI-powered clothing analysis and segmentation API"

app.py

@@ -1,168 +0,0 @@
-from fastapi import FastAPI, UploadFile, File, Form, HTTPException, Request
-from fastapi.responses import JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-from typing import Optional, List
-from process import get_dominant_color_from_base64
-from clothing_detector import (
-    detect_clothing_types,
-    create_clothing_only_image,
-    get_clothing_detector,
-)
-import logging
-import os
-import base64
-from starlette import status
-
-# Logging setup
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-app = FastAPI(title="FashionAI API", description="Clothing analysis & segmentation API")
-
-# CORS (configure with env ALLOWED_ORIGINS="http://localhost:5173,https://your-site")
-allowed_origins_env = os.getenv("ALLOWED_ORIGINS", "*")
-allow_origins: List[str]
-if allowed_origins_env.strip() == "*":
-    allow_origins = ["*"]
-else:
-    allow_origins = [o.strip() for o in allowed_origins_env.split(",") if o.strip()]
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=allow_origins,
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# API settings
-MAX_UPLOAD_MB = int(os.getenv("MAX_UPLOAD_MB", "10"))
-MAX_UPLOAD_BYTES = MAX_UPLOAD_MB * 1024 * 1024
-ALLOWED_CONTENT_TYPES = {
-    c.strip() for c in os.getenv("ALLOWED_CONTENT_TYPES", "image/jpeg,image/png,image/webp").split(",") if c.strip()
-}
-
-
-@app.exception_handler(Exception)
-async def unhandled_exception_handler(request: Request, exc: Exception):
-    logging.exception("Unhandled server error: %s", exc)
-    return JSONResponse(
-        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-        content={"error": "Internal Server Error"},
-    )
-
-@app.on_event("startup")
-async def maybe_warmup_model():
-    if os.getenv("WARMUP_ON_STARTUP", "true").lower() in {"1", "true", "yes"}:
-        # Warm up model on startup to reduce first request latency
-        get_clothing_detector()
-
-
-@app.get("/")
-async def api_root():
-    return JSONResponse({
-        "name": "FashionAI API",
-        "status": "ok",
-        "docs": "/docs",
-        "endpoints": ["/clothing", "/analyze", "/analyze/base64", "/labels", "/healthz"],
-    })
-
-
-@app.get("/healthz")
-async def health_check():
-    return {"status": "ok"}
-
-@app.post("/clothing")
-async def get_clothing_list(file: UploadFile = File(...)):
-    """Detect all clothing types on image and return coordinates."""
-    logger.info(f"Processing clothing detection for file: {file.filename}")
-    # Validation
-    if file.content_type not in ALLOWED_CONTENT_TYPES:
-        raise HTTPException(status_code=415, detail=f"Unsupported content-type: {file.content_type}")
-    # Read with size guard
-    image_bytes = await file.read()
-    if len(image_bytes) > MAX_UPLOAD_BYTES:
-        raise HTTPException(status_code=413, detail=f"File too large. Max {MAX_UPLOAD_MB}MB")
-    clothing_result = detect_clothing_types(image_bytes)
-    logger.info(f"Clothing detection completed. Found {clothing_result.get('total_detected', 0)} items")
-    return clothing_result
-
-@app.post("/analyze")
-async def analyze_image(
-    file: UploadFile = File(...),
-    selected_clothing: Optional[str] = Form(None)
-):
-    """
-    Full image analysis: clothing detection, clothing-only image, dominant color.
-
-    - selected_clothing: Optional clothing type to focus on
-    - color: Dominant color of clothing
-    - clothing_analysis: Detected clothing types with stats
-    - clothing_only_image: Base64 PNG with transparent background
-    """
-    logger.info(f"Processing full analysis for file: {file.filename}, selected_clothing: {selected_clothing}")
-    if file.content_type not in ALLOWED_CONTENT_TYPES:
-        raise HTTPException(status_code=415, detail=f"Unsupported content-type: {file.content_type}")
-    image_bytes = await file.read()
-    if len(image_bytes) > MAX_UPLOAD_BYTES:
-        raise HTTPException(status_code=413, detail=f"File too large. Max {MAX_UPLOAD_MB}MB")
-
-    # Step 1: Detect clothing types (cached segmentation)
-    logger.info("Detecting clothing types...")
-    clothing_result = detect_clothing_types(image_bytes)
-
-    # Step 2: Create clothing-only image (cached segmentation)
-    logger.info("Creating clothing-only image...")
-    clothing_only_image = create_clothing_only_image(image_bytes, selected_clothing)
-
-    # Step 3: Get dominant color from clothing-only image (no background)
-    logger.info("Getting dominant color from clothing-only image...")
-    color = get_dominant_color_from_base64(clothing_only_image)
-
-    logger.info("Full analysis completed successfully")
-    return JSONResponse(content={
-        "dominant_color": color,
-        "clothing_analysis": clothing_result,
-        "clothing_only_image": clothing_only_image,
-        "selected_clothing": selected_clothing
-    })
-
-
-class Base64AnalyzeRequest(BaseModel):
-    image_base64: str
-    selected_clothing: Optional[str] = None
-
-
-@app.post("/analyze/base64")
-async def analyze_image_base64(payload: Base64AnalyzeRequest):
-    """Analyze base64-encoded image (handy for React Native)."""
-    # Decode image from base64
-    if payload.image_base64.startswith("data:image"):
-        base64_data = payload.image_base64.split(",", 1)[1]
-    else:
-        base64_data = payload.image_base64
-
-    image_bytes = base64.b64decode(base64_data)
-
-    # 1) Clothing detection
-    clothing_result = detect_clothing_types(image_bytes)
-
-    # 2) Clothing-only image
-    clothing_only_image = create_clothing_only_image(image_bytes, payload.selected_clothing)
-
-    # 3) Dominant color from clothing-only image
-    color = get_dominant_color_from_base64(clothing_only_image)
-
-    return JSONResponse(content={
-        "dominant_color": color,
-        "clothing_analysis": clothing_result,
-        "clothing_only_image": clothing_only_image,
-        "selected_clothing": payload.selected_clothing,
-    })
-
-
-@app.get("/labels")
-async def get_labels():
-    detector = get_clothing_detector()
-    return {"labels": list(detector.labels.values())}

config.py

@@ -0,0 +1,243 @@
+import os
+from typing import List, Dict, Any
+from dataclasses import dataclass, field
+
+@dataclass
+class APIConfig:
+    """Configuration class for the Loomi Clothing Detection API."""
+    
+    # API Settings
+    title: str = "Loomi Clothing Detection API"
+    description: str = "AI-powered clothing analysis and segmentation API with rate limiting and user management"
+    version: str = "2.0.0"
+    
+    # Server Settings
+    host: str = "0.0.0.0"
+    port: int = 7860
+    workers: int = 1
+    reload: bool = False
+    
+    # File Upload Settings
+    max_upload_mb: int = 10
+    max_upload_bytes: int = field(init=False)
+    allowed_content_types: set = field(default_factory=lambda: {"image/jpeg", "image/png", "image/webp"})
+    
+    # Rate Limiting
+    rate_limit_requests: int = 10  # requests per minute
+    rate_limit_window: int = 60  # seconds
+    max_concurrent_requests: int = 5  # per user
+    
+    # Model Settings
+    model_warmup_on_startup: bool = True
+    model_cache_size: int = 10
+    
+    # Queue Settings
+    num_workers: int = 2
+    queue_max_size: int = 100
+    
+    # CORS Settings
+    allowed_origins: List[str] = field(default_factory=lambda: ["*"])
+    
+    # Security Settings
+    enable_auth: bool = False
+    jwt_secret: str = "your-secret-key-change-in-production"
+    jwt_algorithm: str = "HS256"
+    jwt_expire_minutes: int = 60
+    
+    # Token System Settings (Future)
+    enable_token_system: bool = False
+    free_tier_requests_per_day: int = 100
+    premium_tier_requests_per_day: int = 1000
+    
+    # Logging Settings
+    log_level: str = "INFO"
+    log_format: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    
+    # Monitoring Settings
+    enable_metrics: bool = False
+    metrics_port: int = 8000
+    
+    # Cache Settings
+    enable_redis: bool = False
+    redis_host: str = "localhost"
+    redis_port: int = 6379
+    redis_db: int = 0
+    redis_password: str = ""
+    
+    # Hugging Face Spaces Settings
+    is_huggingface_space: bool = False
+    space_id: str = ""
+    hf_space: bool = False
+    hf_cache_dir: str = "/tmp/hf_cache"
+    
+    def __post_init__(self):
+        """Post-initialization to set computed fields and load from environment."""
+        # Load from environment variables
+        self.host = os.getenv("HOST", self.host)
+        self.port = int(os.getenv("PORT", str(self.port)))
+        self.workers = int(os.getenv("WORKERS", str(self.workers)))
+        self.reload = os.getenv("RELOAD", str(self.reload)).lower() == "true"
+        
+        self.max_upload_mb = int(os.getenv("MAX_UPLOAD_MB", str(self.max_upload_mb)))
+        self.max_upload_bytes = self.max_upload_mb * 1024 * 1024
+        
+        # Handle allowed content types
+        content_types_env = os.getenv("ALLOWED_CONTENT_TYPES")
+        if content_types_env:
+            self.allowed_content_types = {c.strip() for c in content_types_env.split(",") if c.strip()}
+        
+        self.rate_limit_requests = int(os.getenv("RATE_LIMIT_REQUESTS", str(self.rate_limit_requests)))
+        self.rate_limit_window = int(os.getenv("RATE_LIMIT_WINDOW", str(self.rate_limit_window)))
+        self.max_concurrent_requests = int(os.getenv("MAX_CONCURRENT_REQUESTS", str(self.max_concurrent_requests)))
+        
+        self.model_warmup_on_startup = os.getenv("MODEL_WARMUP_ON_STARTUP", str(self.model_warmup_on_startup)).lower() == "true"
+        self.model_cache_size = int(os.getenv("MODEL_CACHE_SIZE", str(self.model_cache_size)))
+        
+        self.num_workers = int(os.getenv("NUM_WORKERS", str(self.num_workers)))
+        self.queue_max_size = int(os.getenv("QUEUE_MAX_SIZE", str(self.queue_max_size)))
+        
+        # Handle allowed origins
+        origins_env = os.getenv("ALLOWED_ORIGINS")
+        if origins_env and origins_env != "*":
+            self.allowed_origins = [o.strip() for o in origins_env.split(",") if o.strip()]
+        
+        self.enable_auth = os.getenv("ENABLE_AUTH", str(self.enable_auth)).lower() == "true"
+        self.jwt_secret = os.getenv("JWT_SECRET", self.jwt_secret)
+        self.jwt_algorithm = os.getenv("JWT_ALGORITHM", self.jwt_algorithm)
+        self.jwt_expire_minutes = int(os.getenv("JWT_EXPIRE_MINUTES", str(self.jwt_expire_minutes)))
+        
+        self.enable_token_system = os.getenv("ENABLE_TOKEN_SYSTEM", str(self.enable_token_system)).lower() == "true"
+        self.free_tier_requests_per_day = int(os.getenv("FREE_TIER_REQUESTS_PER_DAY", str(self.free_tier_requests_per_day)))
+        self.premium_tier_requests_per_day = int(os.getenv("PREMIUM_TIER_REQUESTS_PER_DAY", str(self.premium_tier_requests_per_day)))
+        
+        self.log_level = os.getenv("LOG_LEVEL", self.log_level)
+        self.log_format = os.getenv("LOG_FORMAT", self.log_format)
+        
+        self.enable_metrics = os.getenv("ENABLE_METRICS", str(self.enable_metrics)).lower() == "true"
+        self.metrics_port = int(os.getenv("METRICS_PORT", str(self.metrics_port)))
+        
+        self.enable_redis = os.getenv("ENABLE_REDIS", str(self.enable_redis)).lower() == "true"
+        self.redis_host = os.getenv("REDIS_HOST", self.redis_host)
+        self.redis_port = int(os.getenv("REDIS_PORT", str(self.redis_port)))
+        self.redis_db = int(os.getenv("REDIS_DB", str(self.redis_db)))
+        self.redis_password = os.getenv("REDIS_PASSWORD", self.redis_password)
+        
+        # Hugging Face detection and settings
+        self.space_id = os.getenv("SPACE_ID", "")
+        self.hf_space = os.getenv("HF_SPACE", str(self.hf_space)).lower() == "true"
+        self.hf_cache_dir = os.getenv("HF_CACHE_DIR", self.hf_cache_dir)
+        
+        # Determine if this is a Hugging Face Space
+        self.is_huggingface_space = bool(self.space_id.strip()) or self.hf_space
+        
+        # Apply HF-specific optimizations
+        if self.is_huggingface_space:
+            self._apply_hf_optimizations()
+    
+    def _apply_hf_optimizations(self):
+        """Apply Hugging Face Spaces specific optimizations."""
+        # Set HF environment variables
+        os.environ["HF_HOME"] = self.hf_cache_dir
+        os.environ["TRANSFORMERS_CACHE"] = f"{self.hf_cache_dir}/transformers"
+        os.environ["HF_DATASETS_CACHE"] = f"{self.hf_cache_dir}/datasets"
+        
+        # Optimize for HF Spaces
+        if self.workers > 1:
+            self.workers = 1  # HF Spaces work better with single worker
+        
+        # Conservative rate limiting for HF
+        if self.rate_limit_requests > 15:
+            self.rate_limit_requests = 15
+        
+        if self.max_concurrent_requests > 5:
+            self.max_concurrent_requests = 5
+        
+        # Smaller cache sizes for HF
+        if self.model_cache_size > 5:
+            self.model_cache_size = 5
+        
+        if self.queue_max_size > 25:
+            self.queue_max_size = 25
+    
+    def get_rate_limit_info(self) -> Dict[str, Any]:
+        """Get rate limit information for API responses."""
+        return {
+            "requests_per_minute": self.rate_limit_requests,
+            "window_seconds": self.rate_limit_window,
+            "concurrent_limit": self.max_concurrent_requests,
+            "file_size_limit_mb": self.max_upload_mb
+        }
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """Get model information for API responses."""
+        return {
+            "warmup_on_startup": self.model_warmup_on_startup,
+            "cache_size": self.model_cache_size,
+            "workers": self.num_workers
+        }
+    
+    def get_security_info(self) -> Dict[str, Any]:
+        """Get security information for API responses."""
+        return {
+            "authentication_enabled": self.enable_auth,
+            "cors_enabled": True,
+            "rate_limiting_enabled": True,
+            "file_validation_enabled": True
+        }
+    
+    def get_hf_info(self) -> Dict[str, Any]:
+        """Get Hugging Face specific information."""
+        return {
+            "is_hf_space": self.is_huggingface_space,
+            "space_id": self.space_id,
+            "cache_dir": self.hf_cache_dir,
+            "optimizations_applied": self.is_huggingface_space
+        }
+    
+    def validate(self) -> List[str]:
+        """Validate configuration and return list of warnings/errors."""
+        warnings = []
+        
+        if self.rate_limit_requests < 1:
+            warnings.append("RATE_LIMIT_REQUESTS should be at least 1")
+        
+        if self.max_concurrent_requests < 1:
+            warnings.append("MAX_CONCURRENT_REQUESTS should be at least 1")
+        
+        if self.max_upload_mb < 1:
+            warnings.append("MAX_UPLOAD_MB should be at least 1")
+        
+        if self.workers < 1:
+            warnings.append("WORKERS should be at least 1")
+        
+        if self.is_huggingface_space and self.workers > 1:
+            warnings.append("Multiple workers not recommended in Hugging Face Spaces")
+        
+        if self.is_huggingface_space and self.rate_limit_requests > 20:
+            warnings.append("High rate limits may cause issues in Hugging Face Spaces")
+        
+        return warnings
+
+# Global configuration instance
+config = APIConfig()
+
+# Validate configuration on import
+if __name__ == "__main__":
+    warnings = config.validate()
+    if warnings:
+        print("Configuration warnings:")
+        for warning in warnings:
+            print(f"  - {warning}")
+    else:
+        print("Configuration is valid!")
+    
+    print(f"\nCurrent configuration:")
+    print(f"  - Rate limit: {config.rate_limit_requests} requests per {config.rate_limit_window} seconds")
+    print(f"  - Concurrent limit: {config.max_concurrent_requests} requests")
+    print(f"  - File size limit: {config.max_upload_mb}MB")
+    print(f"  - Workers: {config.workers}")
+    print(f"  - Background workers: {config.num_workers}")
+    print(f"  - Hugging Face Space: {config.is_huggingface_space}")
+    if config.is_huggingface_space:
+        print(f"  - Space ID: {config.space_id}")
+        print(f"  - Cache dir: {config.hf_cache_dir}")

env.example

@@ -0,0 +1,59 @@
+# Loomi Clothing Detection API Configuration - HF Optimized
+# Copy this to .env and modify as needed
+
+# API Settings
+HOST=0.0.0.0
+PORT=7860
+WORKERS=1
+RELOAD=false
+
+# File Upload Settings
+MAX_UPLOAD_MB=15
+ALLOWED_CONTENT_TYPES=image/jpeg,image/png,image/webp
+
+# Rate Limiting (HF-optimized)
+RATE_LIMIT_REQUESTS=15
+RATE_LIMIT_WINDOW=60
+MAX_CONCURRENT_REQUESTS=5
+
+# Model Settings (HF-optimized)
+MODEL_WARMUP_ON_STARTUP=true
+MODEL_CACHE_SIZE=5
+
+# Queue Settings (HF-optimized)
+NUM_WORKERS=1
+QUEUE_MAX_SIZE=25
+
+# CORS Settings
+ALLOWED_ORIGINS=*
+
+# Security Settings
+ENABLE_AUTH=false
+JWT_SECRET=your-secret-key-change-in-production
+JWT_ALGORITHM=HS256
+JWT_EXPIRE_MINUTES=60
+
+# Token System Settings (Future)
+ENABLE_TOKEN_SYSTEM=false
+FREE_TIER_REQUESTS_PER_DAY=100
+PREMIUM_TIER_REQUESTS_PER_DAY=1000
+
+# Logging Settings
+LOG_LEVEL=INFO
+LOG_FORMAT=%(asctime)s - %(name)s - %(levelname)s - %(message)s
+
+# Monitoring Settings
+ENABLE_METRICS=false
+METRICS_PORT=8000
+
+# Cache Settings
+ENABLE_REDIS=false
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_DB=0
+REDIS_PASSWORD=
+
+# Hugging Face Spaces Settings
+SPACE_ID=your-username/your-space-name
+HF_SPACE=true
+HF_CACHE_DIR=/tmp/hf_cache

model_manager.py

@@ -0,0 +1,75 @@
+"""
+Async model management for the Loomi Clothing Detection API.
+"""
+import asyncio
+import logging
+from config import config
+
+logger = logging.getLogger(__name__)
+
+class AsyncModelManager:
+    """Manages asynchronous loading of the ML model."""
+    
+    def __init__(self):
+        self.model_loaded = False
+        self.model_loading = False
+        self.loading_task = None
+        self._lock = asyncio.Lock()
+    
+    async def ensure_model_loaded(self):
+        """Ensure model is loaded, load it asynchronously if needed."""
+        if self.model_loaded:
+            return
+        
+        async with self._lock:
+            if self.model_loaded:
+                return
+            
+            if self.model_loading:
+                # Wait for existing loading task
+                if self.loading_task:
+                    await self.loading_task
+                return
+            
+            # Start loading task
+            self.model_loading = True
+            self.loading_task = asyncio.create_task(self._load_model())
+            await self.loading_task
+    
+    async def _load_model(self):
+        """Load model in background thread."""
+        try:
+            logger.info("Starting model loading in background...")
+            
+            # Run model loading in thread pool to avoid blocking
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(None, self._load_model_sync)
+            
+            self.model_loaded = True
+            logger.info("Model loaded successfully!")
+            
+        except Exception as e:
+            logger.error(f"Failed to load model: {e}")
+            self.model_loading = False
+        finally:
+            self.model_loading = False
+    
+    def _load_model_sync(self):
+        """Synchronous model loading (runs in thread pool)."""
+        try:
+            from clothing_detector import get_clothing_detector
+            detector = get_clothing_detector()
+            logger.info("Model loaded in background thread")
+        except Exception as e:
+            logger.error(f"Error loading model: {e}")
+            raise
+    
+    def get_status(self) -> dict:
+        """Get current model status for health checks."""
+        return {
+            "model_loaded": self.model_loaded,
+            "model_loading": self.model_loading
+        }
+
+# Global model manager instance
+model_manager = AsyncModelManager()

rate_limiter.py

@@ -0,0 +1,78 @@
+"""
+Rate limiting and user management for the Loomi Clothing Detection API.
+"""
+import asyncio
+import time
+from typing import Dict, List
+from collections import defaultdict
+from dataclasses import dataclass
+from config import config
+
+@dataclass
+class UserRequest:
+    """Represents a user request for tracking."""
+    timestamp: float
+    endpoint: str
+    file_size: int
+
+class RateLimiter:
+    """Manages rate limiting and concurrent request tracking per user."""
+    
+    def __init__(self):
+        self.user_requests: Dict[str, List[UserRequest]] = defaultdict(list)
+        self.user_concurrent: Dict[str, int] = defaultdict(int)
+        self.lock = asyncio.Lock()
+    
+    async def check_rate_limit(self, user_id: str, endpoint: str) -> bool:
+        """Check if user has exceeded rate limit."""
+        async with self.lock:
+            now = time.time()
+            user_reqs = self.user_requests[user_id]
+            
+            # Remove old requests outside the window
+            user_reqs = [req for req in user_reqs if now - req.timestamp < config.rate_limit_window]
+            self.user_requests[user_id] = user_reqs
+            
+            # Check rate limit
+            return len(user_reqs) < config.rate_limit_requests
+    
+    async def check_concurrent_limit(self, user_id: str) -> bool:
+        """Check if user has exceeded concurrent request limit."""
+        async with self.lock:
+            return self.user_concurrent[user_id] < config.max_concurrent_requests
+    
+    async def add_request(self, user_id: str, endpoint: str, file_size: int):
+        """Add a new request to user's history."""
+        async with self.lock:
+            now = time.time()
+            self.user_requests[user_id].append(UserRequest(now, endpoint, file_size))
+            self.user_concurrent[user_id] += 1
+    
+    async def remove_request(self, user_id: str):
+        """Remove a completed request from concurrent count."""
+        async with self.lock:
+            if self.user_concurrent[user_id] > 0:
+                self.user_concurrent[user_id] -= 1
+    
+    def get_user_stats(self, user_id: str) -> Dict:
+        """Get user statistics for API responses."""
+        now = time.time()
+        user_reqs = self.user_requests[user_id]
+        concurrent = self.user_concurrent[user_id]
+        
+        # Calculate usage in current window
+        window_start = now - config.rate_limit_window
+        requests_in_window = len([req for req in user_reqs if req.timestamp >= window_start])
+        
+        return {
+            "user_id": user_id,
+            "requests_in_window": requests_in_window,
+            "requests_limit": config.rate_limit_requests,
+            "concurrent_requests": concurrent,
+            "concurrent_limit": config.max_concurrent_requests,
+            "window_remaining": config.rate_limit_window - (now - window_start),
+            "total_requests_today": len([req for req in user_reqs if req.timestamp >= now - 86400])
+        }
+
+# Global rate limiter instance
+rate_limiter = RateLimiter()

request_queue.py

@@ -0,0 +1,71 @@
+"""
+Request queue management for the Loomi Clothing Detection API.
+"""
+import asyncio
+import logging
+from typing import Any, Callable
+from config import config
+
+logger = logging.getLogger(__name__)
+
+class RequestQueue:
+    """Manages background processing of heavy API requests."""
+    
+    def __init__(self):
+        self.queue = asyncio.Queue()
+        self.processing = False
+        self.workers = []
+    
+    async def start_workers(self, num_workers: int = None):
+        """Start background workers."""
+        if num_workers is None:
+            num_workers = config.num_workers
+            
+        for i in range(num_workers):
+            worker = asyncio.create_task(self._worker(f"worker-{i}"))
+            self.workers.append(worker)
+        logger.info(f"Started {num_workers} background workers")
+    
+    async def _worker(self, name: str):
+        """Background worker for processing requests."""
+        logger.info(f"Worker {name} started")
+        while True:
+            try:
+                task = await self.queue.get()
+                if task is None:  # Shutdown signal
+                    break
+                
+                user_id, endpoint, process_func, args, future = task
+                try:
+                    # Process the request
+                    result = await process_func(*args)
+                    future.set_result(result)
+                except Exception as e:
+                    future.set_exception(e)
+                finally:
+                    self.queue.task_done()
+                    
+            except Exception as e:
+                logger.error(f"Worker {name} error: {e}")
+    
+    async def submit_task(self, user_id: str, endpoint: str, process_func: Callable, *args) -> Any:
+        """Submit a task to the queue."""
+        future = asyncio.Future()
+        await self.queue.put((user_id, endpoint, process_func, args, future))
+        return await future
+    
+    async def shutdown(self):
+        """Shutdown workers."""
+        for _ in self.workers:
+            await self.queue.put(None)
+        await asyncio.gather(*self.workers, return_exceptions=True)
+    
+    def get_status(self) -> dict:
+        """Get current queue status for health checks."""
+        return {
+            "queue_size": self.queue.qsize(),
+            "active_workers": len(self.workers)
+        }
+
+# Global request queue instance
+request_queue = RequestQueue()

requirements.txt

@@ -1,12 +1,28 @@
+# Core FastAPI dependencies
 fastapi
 uvicorn[standard]
-pillow
 python-multipart
-numpy
-scikit-learn
+
+# Image processing
+pillow
 opencv-python-headless
+rembg
+
+# Machine Learning
 transformers
 torch
 torchvision
-rembg
-onnxruntime
+onnxruntime
+
+# Data processing
+numpy
+scikit-learn
+
+# Configuration and utilities
+python-dotenv
+
+# Optional dependencies (uncomment if needed)
+# redis          # For Redis caching
+# celery        # For task queue
+# prometheus-client  # For metrics
+# structlog     # For structured logging

start.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""
+Startup script for Loomi Clothing Detection API
+Supports different deployment scenarios and configurations
+"""
+
+import os
+import sys
+import argparse
+import uvicorn
+from config import config
+
+def main():
+    parser = argparse.ArgumentParser(description="Start Loomi Clothing Detection API")
+    parser.add_argument("--host", default=config.host, help="Host to bind to")
+    parser.add_argument("--port", type=int, default=config.port, help="Port to bind to")
+    parser.add_argument("--workers", type=int, default=config.workers, help="Number of worker processes")
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload for development")
+    parser.add_argument("--config", help="Path to .env file")
+    parser.add_argument("--huggingface", action="store_true", help="Optimize for Hugging Face Spaces")
+    
+    args = parser.parse_args()
+    
+    # Load environment variables if specified
+    if args.config:
+        from dotenv import load_dotenv
+        load_dotenv(args.config)
+        # Reload config after loading .env
+        from importlib import reload
+        import config
+        reload(config)
+        config = config.config
+    
+    # Hugging Face Spaces optimization
+    if args.huggingface:
+        print("🚀 Optimizing for Hugging Face Spaces...")
+        os.environ["WORKERS"] = "1"
+        os.environ["NUM_WORKERS"] = "1"
+        os.environ["MODEL_WARMUP_ON_STARTUP"] = "true"
+        args.workers = 1
+        args.reload = False
+    
+    # Validate configuration
+    warnings = config.validate()
+    if warnings:
+        print("⚠️  Configuration warnings:")
+        for warning in warnings:
+            print(f"   - {warning}")
+        print()
+    
+    # Print startup information
+    print("🎯 Loomi Clothing Detection API")
+    print(f"   Version: {config.version}")
+    print(f"   Host: {args.host}:{args.port}")
+    print(f"   Workers: {args.workers}")
+    print(f"   Background workers: {config.num_workers}")
+    print(f"   Rate limit: {config.rate_limit_requests} req/min")
+    print(f"   Concurrent limit: {config.max_concurrent_requests}")
+    print(f"   File size limit: {config.max_upload_mb}MB")
+    print(f"   Hugging Face Space: {config.is_huggingface_space}")
+    print()
+    
+    # Start the server
+    try:
+        uvicorn.run(
+            "main:app",
+            host=args.host,
+            port=args.port,
+            workers=args.workers if not args.reload else 1,
+            reload=args.reload,
+            log_level=config.log_level.lower(),
+            access_log=True,
+            use_colors=True
+        )
+    except KeyboardInterrupt:
+        print("\n👋 Shutting down gracefully...")
+    except Exception as e:
+        print(f"❌ Error starting server: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

user_manager.py

@@ -0,0 +1,25 @@
+"""
+User management and identification for the Loomi Clothing Detection API.
+"""
+import hashlib
+from typing import Optional
+from fastapi import Request, Depends
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+
+# Security
+security = HTTPBearer(auto_error=False)
+
+def get_user_id(request: Request, credentials: Optional[HTTPAuthorizationCredentials] = Depends(security)) -> str:
+    """
+    Extract user ID from request. 
+    In production, validate JWT token.
+    """
+    if credentials:
+        # In production, decode JWT and extract user_id
+        return f"user_{hashlib.md5(credentials.credentials.encode()).hexdigest()[:8]}"
+    
+    # Fallback: use IP address + User-Agent hash
+    client_ip = request.client.host
+    user_agent = request.headers.get("user-agent", "")
+    user_hash = hashlib.md5(f"{client_ip}:{user_agent}".encode()).hexdigest()[:8]
+    return f"anon_{user_hash}"