interloper-api 0.60.0__tar.gz → 0.62.0__tar.gz

{interloper_api-0.60.0 → interloper_api-0.62.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: interloper-api
-Version: 0.60.0
+Version: 0.62.0
 Summary: Interloper FastAPI routes
 Author: Guillaume Onfroy
 Author-email: Guillaume Onfroy <guillaume@digitlcloud.com>

{interloper_api-0.60.0 → interloper_api-0.62.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "interloper-api"
-version = "0.60.0"
+version = "0.62.0"
 description = "Interloper FastAPI routes"
 readme = "README.md"
 requires-python = ">=3.10"

{interloper_api-0.60.0 → interloper_api-0.62.0}/pyproject.toml.orig

@@ -3,7 +3,7 @@
 # ###############
 [project]
 name = "interloper-api"
-version = "0.60.0"
+version = "0.62.0"
 description = "Interloper FastAPI routes"
 readme = "README.md"
 authors = [{ name = "Guillaume Onfroy", email = "guillaume@digitlcloud.com" }]

{interloper_api-0.60.0 → interloper_api-0.62.0}/src/interloper_api/routes/admin.py

@@ -19,7 +19,7 @@ from uuid import UUID
 from fastapi import APIRouter, Depends, HTTPException, Request
 from interloper_db import Organisation, Profile, Store
 from interloper_db.store.quotas import METRIC_SUCCESSFUL_RUNS, QUOTAS
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, RootModel, field_validator
 
 from interloper_api.dependencies import get_admin_config, get_quota_defaults, get_store, require_super_admin
 from interloper_api.email import send_invite_email
@@ -228,13 +228,11 @@ class AdminDataConfig(BaseModel):
     catalog: dict[str, list[str]]
 
 
-class AdminQuotaLimits(BaseModel):
-    """One set of quota limits; null means unlimited (or unset, for overrides)."""
-
-    max_sources: int | None = None
-    max_assets_per_source: int | None = None
-    max_successful_runs_per_month: int | None = None
-    max_backfill_days: int | None = None
+#: One set of quota limits, keyed by quota key; null means unlimited (or
+#: unset, for overrides). Derived from the ``QUOTAS`` registry rather than
+#: declared field-by-field, so registering a quota surfaces it here — and in
+#: the frontend, which already indexes these by key — with no code change.
+AdminQuotaLimits = dict[str, int | None]
 
 
 class AdminOrgQuotaStatus(BaseModel):
@@ -272,13 +270,30 @@ class AdminQuotasResponse(BaseModel):
     organisations: list[AdminOrgQuotaStatus]
 
 
-class AdminQuotaUpdateRequest(BaseModel):
-    """Per-org quota overrides. Omitted fields keep their value; null clears one."""
+class AdminQuotaUpdateRequest(RootModel[AdminQuotaLimits]):
+    """Per-org quota overrides. Omitted keys keep their value; null clears one.
+
+    Keys are checked against the registry here so an unknown quota is a 422
+    at the boundary rather than a ``KeyError`` out of the store.
+    """
+
+    @field_validator("root")
+    @classmethod
+    def _known_keys_and_non_negative(cls, value: AdminQuotaLimits) -> AdminQuotaLimits:
+        """Validate the payload against the quota registry.
+
+        Returns:
+            The payload unchanged.
 
-    max_sources: int | None = Field(default=None, ge=0)
-    max_assets_per_source: int | None = Field(default=None, ge=0)
-    max_successful_runs_per_month: int | None = Field(default=None, ge=0)
-    max_backfill_days: int | None = Field(default=None, ge=0)
+        Raises:
+            ValueError: If a key names no registered quota, or a limit is
+                negative.
+        """
+        if unknown := sorted(set(value) - set(QUOTAS.keys())):
+            raise ValueError(f"Unknown quota(s): {', '.join(unknown)}. Known: {', '.join(sorted(QUOTAS.keys()))}")
+        if negative := sorted(key for key, limit in value.items() if limit is not None and limit < 0):
+            raise ValueError(f"Quota limits must be >= 0: {', '.join(negative)}")
+        return value
 
 
 class AdminActivityEntry(BaseModel):
@@ -476,32 +491,40 @@ def build_config_snapshot(settings: Any, features: dict[str, bool], catalog: Any
 
 
 def _quota_limits(limits: Any) -> AdminQuotaLimits:
-    """Map limits from a ``{key: limit}`` dict (store) or attributes (settings)."""
+    """Map limits from a ``{key: limit}`` dict (store) or attributes (settings).
+
+    Returns:
+        Every registered quota's limit, ``None`` where unset.
+    """
     if isinstance(limits, dict):
-        return AdminQuotaLimits(**{key: limits.get(key) for key in AdminQuotaLimits.model_fields})
-    return AdminQuotaLimits(**{key: getattr(limits, key, None) for key in AdminQuotaLimits.model_fields})
+        return {key: limits.get(key) for key in QUOTAS.keys()}
+    return {key: getattr(limits, key, None) for key in QUOTAS.keys()}
 
 
 def _effective_limits(overrides: AdminQuotaLimits, defaults: AdminQuotaLimits) -> AdminQuotaLimits:
-    """Per-org overrides win field-by-field over the global defaults."""
-    return AdminQuotaLimits(
-        **{
-            key: override if (override := getattr(overrides, key)) is not None else getattr(defaults, key)
-            for key in AdminQuotaLimits.model_fields
-        }
-    )
+    """Per-org overrides win key-by-key over the global defaults.
+
+    Returns:
+        The effective limit of every registered quota.
+    """
+    return {
+        key: override if (override := overrides.get(key)) is not None else defaults.get(key)
+        for key in QUOTAS.keys()
+    }
 
 
 def _quota_fields(defaults: AdminQuotaLimits) -> list[AdminQuotaField]:
-    """Field descriptors for admin quota surfaces, in the wire model's order.
+    """Field descriptors for admin quota surfaces, in registry order.
 
-    Labels come from the registry definitions, so the frontend renders new
-    quotas without a matching code change.
+    Keys, labels and defaults all come from the registry, so registering a
+    quota is the whole change: no wire model, no frontend edit. ``Registry``
+    sorts its keys, so the admin surfaces list quotas alphabetically rather
+    than in the order they happen to be registered.
+
+    Returns:
+        One descriptor per registered quota.
     """
-    return [
-        AdminQuotaField(key=key, label=QUOTAS[key].label, default=getattr(defaults, key))
-        for key in AdminQuotaLimits.model_fields
-    ]
+    return [AdminQuotaField(key=key, label=QUOTAS[key].label, default=defaults.get(key)) for key in QUOTAS.keys()]
 
 
 def _require_org(store: Store, org_id: UUID) -> Organisation:
@@ -657,9 +680,9 @@ def update_org_quota(
     user: Profile = Depends(require_super_admin),
     store: Store = Depends(get_store),
 ) -> AdminQuotaLimits:
-    """Set an organisation's quota overrides; omitted fields keep their value, null clears one."""
+    """Set an organisation's quota overrides; omitted keys keep their value, null clears one."""
     _require_org(store, org_id)
-    overrides = store.set_quota(org_id, body.model_dump(exclude_unset=True))
+    overrides = store.set_quota(org_id, body.root)
     return _quota_limits(overrides)
 
 

{interloper_api-0.60.0 → interloper_api-0.62.0}/src/interloper_api/routes/backfills.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import datetime as dt
 from uuid import UUID
 
 from fastapi import APIRouter, Depends, HTTPException
@@ -27,8 +26,8 @@ class BackfillCreateRequest(BaseModel):
     """Request body for queuing a backfill."""
 
     component_id: UUID
-    start_date: dt.date
-    end_date: dt.date
+    start_key: str
+    end_key: str
     concurrency: int = 1
     fail_fast: bool = False
 
@@ -40,8 +39,8 @@ class BackfillResponse(BaseModel):
     org_id: UUID
     component_id: UUID | None
     status: str
-    start_date: dt.date
-    end_date: dt.date
+    start_key: str
+    end_key: str
     concurrency: int
     fail_fast: bool
     partitions: int
@@ -64,8 +63,8 @@ def _backfill_to_response(backfill: Backfill) -> BackfillResponse:
         org_id=backfill.org_id,
         component_id=backfill.component_id,
         status=backfill.status,
-        start_date=backfill.start_date,
-        end_date=backfill.end_date,
+        start_key=backfill.start_key,
+        end_key=backfill.end_key,
         concurrency=backfill.concurrency,
         fail_fast=backfill.fail_fast,
         partitions=backfill.partitions,
@@ -96,18 +95,21 @@ def create_backfill(
     user: Profile = Depends(get_current_user),
     store: Store = Depends(get_store),
 ) -> BackfillResponse:
-    """Queue a backfill for a job over a date range."""
+    """Queue a backfill for a job over a partition-key range."""
     job = load_authorized(
         lambda i: store.get_component(i, kind="job"), body.component_id, user, store, label="Job", minimum="editor"
     )
-    backfill = store.create_backfill(
-        job.org_id,
-        component_id=body.component_id,
-        start_date=body.start_date,
-        end_date=body.end_date,
-        concurrency=body.concurrency,
-        fail_fast=body.fail_fast,
-    )
+    try:
+        backfill = store.create_backfill(
+            job.org_id,
+            component_id=body.component_id,
+            start_key=body.start_key,
+            end_key=body.end_key,
+            concurrency=body.concurrency,
+            fail_fast=body.fail_fast,
+        )
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
     return _backfill_to_response(backfill)
 
 

{interloper_api-0.60.0 → interloper_api-0.62.0}/src/interloper_api/routes/runs.py

@@ -37,7 +37,7 @@ class RunResponse(BaseModel):
     org_id: UUID
     component_id: UUID | None
     backfill_id: UUID | None
-    partition_date: dt.date | None
+    partition_key: str | None
     status: str
     retry_of: UUID | None = None
     attempt: int = 1
@@ -51,7 +51,7 @@ class RunCreateRequest(BaseModel):
     """Request body for queuing a run targeting a runnable component."""
 
     component_id: UUID
-    partition_date: dt.date | None = None
+    partition_key: str | None = None
 
 
 class RetryRequest(BaseModel):
@@ -105,7 +105,7 @@ def _run_to_response(run: Run) -> RunResponse:
         org_id=run.org_id,
         component_id=run.component_id,
         backfill_id=run.backfill_id,
-        partition_date=run.partition_date,
+        partition_key=run.partition_key,
         status=run.status,
         retry_of=run.retry_of,
         attempt=run.attempt,
@@ -172,6 +172,8 @@ def list_runs(
     component_id: UUID | None = None,
     backfill_id: UUID | None = None,
     status: str | None = None,
+    after: dt.datetime | None = None,
+    before: dt.datetime | None = None,
     limit: int = 50,
     offset: int = 0,
     user: Profile = Depends(require_viewer),
@@ -180,16 +182,25 @@ def list_runs(
 ) -> list[RunResponse]:
     """List runs with optional filters.
 
+    ``after``/``before`` bound the runs to those whose execution overlaps that
+    window — a run occupies ``started_at`` → ``completed_at`` (open-ended while
+    running), so runs that never started match no window. This is what a
+    timeline view over a time range asks for.
+
     The total number of matching runs (ignoring ``limit``/``offset``) is
     returned in the ``X-Total-Count`` response header so clients can paginate.
     """
-    total = store.count_runs(org_id, component_id=component_id, backfill_id=backfill_id, status=status)
+    total = store.count_runs(
+        org_id, component_id=component_id, backfill_id=backfill_id, status=status, after=after, before=before
+    )
     response.headers["X-Total-Count"] = str(total)
     runs = store.list_runs(
         org_id,
         component_id=component_id,
         backfill_id=backfill_id,
         status=status,
+        after=after,
+        before=before,
         limit=limit,
         offset=offset,
     )
@@ -206,7 +217,10 @@ def create_run(
     target = load_authorized(store.get_component, body.component_id, user, store, label="Component", minimum="editor")
     if not KINDS[target.kind].runnable:
         raise HTTPException(status_code=400, detail=f"Components of kind '{target.kind}' cannot be run")
-    run = store.create_run(target.org_id, component_id=body.component_id, partition_date=body.partition_date)
+    try:
+        run = store.create_run(target.org_id, component_id=body.component_id, partition_key=body.partition_key)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
     return _run_to_response(run)