quantlix 0.1.0__py3-none-any.whl

api/__init__.py

@@ -0,0 +1 @@
+"""Quantlix API."""

api/auth.py

@@ -0,0 +1,81 @@
+"""API key and password authentication."""
+import hashlib
+from typing import Annotated
+
+import bcrypt
+from fastapi import Depends, HTTPException, status
+from fastapi.security import APIKeyHeader
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from api.db import get_db
+from api.models import APIKey, User
+
+
+api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
+
+
+def hash_password(password: str) -> str:
+    """Hash password with bcrypt."""
+    return bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
+
+
+def verify_password(plain: str, hashed: str) -> bool:
+    """Verify password against hash."""
+    return bcrypt.checkpw(plain.encode(), hashed.encode())
+
+
+def hash_api_key(key: str) -> str:
+    """Hash API key for storage (never store plain)."""
+    return hashlib.sha256(key.encode()).hexdigest()
+
+
+async def get_user_from_api_key(
+    api_key: Annotated[str | None, Depends(api_key_header)],
+    db: Annotated[AsyncSession, Depends(get_db)],
+) -> User:
+    """Resolve API key to user. Raises 401 if invalid or missing."""
+    if not api_key or not api_key.strip():
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Missing API key. Provide X-API-Key header.",
+        )
+    key_hash = hash_api_key(api_key.strip())
+    result = await db.execute(
+        select(APIKey).where(APIKey.key_hash == key_hash)
+    )
+    api_key_row = result.scalar_one_or_none()
+    if not api_key_row:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid API key.",
+        )
+    result = await db.execute(select(User).where(User.id == api_key_row.user_id))
+    user = result.scalar_one()
+    return user
+
+
+async def get_current_api_key(
+    api_key: Annotated[str | None, Depends(api_key_header)],
+    db: Annotated[AsyncSession, Depends(get_db)],
+) -> APIKey:
+    """Resolve API key header to APIKey row. Raises 401 if invalid. For rotate/revoke flows."""
+    if not api_key or not api_key.strip():
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Missing API key. Provide X-API-Key header.",
+        )
+    key_hash = hash_api_key(api_key.strip())
+    result = await db.execute(select(APIKey).where(APIKey.key_hash == key_hash))
+    api_key_row = result.scalar_one_or_none()
+    if not api_key_row:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid API key.",
+        )
+    return api_key_row
+
+
+# Type aliases for route dependencies
+CurrentUser = Annotated[User, Depends(get_user_from_api_key)]
+CurrentAPIKey = Annotated[APIKey, Depends(get_current_api_key)]

api/config.py

@@ -0,0 +1,61 @@
+"""Application configuration."""
+from pydantic import ConfigDict
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    model_config = ConfigDict(
+        extra="ignore",
+        env_file=".env",
+        env_file_encoding="utf-8",
+    )
+
+    postgres_host: str = "localhost"
+    postgres_port: int = 5432
+    postgres_user: str = "cloud"
+    postgres_password: str = "cloud_secret"
+    postgres_db: str = "cloud"
+    redis_url: str = "redis://localhost:6379/0"
+    minio_endpoint: str = "localhost:9000"
+    minio_access_key: str = "minioadmin"
+    minio_secret_key: str = "minioadmin"
+    minio_bucket: str = "models"
+    jwt_secret: str = "dev-secret-change-me"
+
+    # Email (Sweego). Set to False to disable all email until domain is verified.
+    # Use SWEEGO_API_KEY for HTTP API (recommended in K8s; avoids SMTP port blocking).
+    # Otherwise use SMTP with smtp_user/smtp_password.
+    email_enabled: bool = True
+    sweego_api_key: str = ""  # When set, use Sweego HTTP API instead of SMTP
+    sweego_auth_type: str = "api_token"  # "api_token" (Api-Token), "api_key" (Api-Key), or "bearer" (Authorization: Bearer)
+    smtp_host: str = "smtp.sweego.io"
+    smtp_port: int = 587
+    smtp_user: str = ""
+    smtp_password: str = ""
+    smtp_from_email: str = "support@quantlix.ai"
+    smtp_from_name: str = "Quantlix"
+    app_base_url: str = "https://api.quantlix.ai"  # For verification links
+    portal_base_url: str = "https://app.quantlix.ai"  # For Stripe redirects
+    dev_return_verification_link: bool = False  # If True, include verification link in signup response (for local testing)
+
+    # Usage limits (0 = unlimited)
+    usage_limit_tokens_per_month: int = 0
+    usage_limit_compute_seconds_per_month: float = 0.0
+
+    # CORS (comma-separated extra origins, e.g. for Vercel: https://quantlix.vercel.app)
+    cors_origins: str = ""
+
+    # Stripe
+    stripe_secret_key: str = ""
+    stripe_webhook_secret: str = ""
+    stripe_price_id_starter: str = ""  # Price ID for Starter €9/mo
+    stripe_price_id_pro: str = ""  # Price ID for Pro plan (e.g. price_xxx)
+
+    @property
+    def database_url(self) -> str:
+        return (
+            f"postgresql+asyncpg://{self.postgres_user}:{self.postgres_password}"
+            f"@{self.postgres_host}:{self.postgres_port}/{self.postgres_db}"
+        )
+
+settings = Settings()

api/db.py

@@ -0,0 +1,38 @@
+"""Database setup and session management."""
+from collections.abc import AsyncGenerator
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase
+
+from api.config import settings
+
+
+class Base(DeclarativeBase):
+    """SQLAlchemy declarative base."""
+
+
+engine = create_async_engine(
+    settings.database_url,
+    echo=False,
+)
+
+async_session_maker = async_sessionmaker(
+    engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+    autocommit=False,
+    autoflush=False,
+)
+
+
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    """Dependency for async DB session."""
+    async with async_session_maker() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+        finally:
+            await session.close()