Configuration Reference¶

from backend.config import settings

# Access configuration values
app_name = settings.APP_NAME
database_path = settings.DATABASE_PATH
cors_origins = settings.BACKEND_CORS_ORIGINS

# Access model configuration
model_path = settings.classifier_model_path
predictor_settings = settings.classifier_settings

class AppSettings(BaseSettings):
    # Core settings
    APP_NAME: str = "CulicidaeLab API"
    API_V1_STR: str = "/api"
    DATABASE_PATH: str = ".lancedb"
    SAVE_PREDICTED_IMAGES: str | bool = False
    BACKEND_CORS_ORIGINS: list[str] = ["http://localhost:8765"]

    # Dynamic properties
    @property
    def classifier_settings(self):
        """Returns culicidaelab library settings"""

    @property
    def classifier_model_path(self) -> str:
        """Returns path to classifier model weights"""

from backend.config import get_predictor_settings

# Get model settings
settings = get_predictor_settings()

# Access model parameters
confidence_threshold = settings.get_confidence_threshold()
model_weights_path = settings.get_model_weights_path("segmenter")

# Database connection settings
DATABASE_CONFIG = {
    "path": settings.DATABASE_PATH,
    "timeout": 30,
    "max_connections": 10,
    "vector_dimension": 512,
    "index_type": "IVF_FLAT",
    "metric_type": "L2"
}

species_schema = {
    "id": "string",
    "name": "string",
    "scientific_name": "string",
    "vector": "vector(512)",
    "metadata": "json",
    "created_at": "timestamp"
}

observations_schema = {
    "id": "string",
    "species_id": "string",
    "location": "geometry",
    "confidence": "float",
    "image_path": "string",
    "metadata": "json",
    "created_at": "timestamp"
}

# FastAPI application configuration
app = FastAPI(
    title=settings.APP_NAME,
    description="CulicidaeLab API for mosquito species identification",
    version="1.0.0",
    openapi_url=f"{settings.API_V1_STR}/openapi.json",
    docs_url=f"{settings.API_V1_STR}/docs",
    redoc_url=f"{settings.API_V1_STR}/redoc"
)

# CORS middleware settings
app.add_middleware(
    CORSMiddleware,
    allow_origins=settings.BACKEND_CORS_ORIGINS,
    allow_credentials=True,
    allow_methods=["GET", "POST", "PUT", "DELETE"],
    allow_headers=["*"],
)

# Static file serving
app.mount("/static", StaticFiles(directory="backend/static"), name="static")

# Rate limiting configuration
RATE_LIMITS = {
    "default": "100/minute",
    "prediction": "10/minute",
    "upload": "5/minute",
    "auth": "20/minute"
}

# Allowed file types and sizes
UPLOAD_CONFIG = {
    "allowed_extensions": [".jpg", ".jpeg", ".png", ".tiff"],
    "max_file_size": 50 * 1024 * 1024,  # 50MB
    "scan_for_malware": True,
    "validate_image_format": True
}

# Validate configuration on startup
def validate_config():
    """Validate application configuration"""
    errors = []

    # Check required environment variables
    required_vars = ["CULICIDAELAB_DATABASE_PATH", "CULICIDAELAB_SECRET_KEY"]
    for var in required_vars:
        if not os.getenv(var):
            errors.append(f"Missing required environment variable: {var}")

    # Check file paths
    if not os.path.exists(settings.DATABASE_PATH):
        errors.append(f"Database path does not exist: {settings.DATABASE_PATH}")

    # Check model files
    try:
        model_path = settings.classifier_model_path
        if not os.path.exists(model_path):
            errors.append(f"Model file not found: {model_path}")
    except Exception as e:
        errors.append(f"Model configuration error: {e}")

    if errors:
        raise ValueError(f"Configuration validation failed: {'; '.join(errors)}")