| """Admin dataset management endpoints (auth-protected, under /admin). |
| |
| Covers list/view/purge, image→dataset lookup, embed-all, and match-all. The dataset *load* job |
| endpoints live in api/jobs.py (background job + polling for the dashboard's load form). |
| """ |
| from __future__ import annotations |
|
|
| from datetime import date |
|
|
| from fastapi import APIRouter, Depends, HTTPException, status |
| from sqlalchemy import select |
| from sqlalchemy.orm import Session |
|
|
| from ..db import get_db |
| from ..models import Dataset, Picture, User |
| from ..models.base import SubjectType |
| from ..schemas.dataset import ( |
| DatasetDetailOut, |
| DatasetOut, |
| EmbedAllResult, |
| ImageDatasetOut, |
| MatchDatasetResult, |
| PurgeResult, |
| ) |
| from ..security import require_admin |
| from ..services import datasets as ds |
|
|
| router = APIRouter(prefix="/admin", tags=["admin-datasets"]) |
|
|
|
|
| def _get_dataset(db: Session, dataset_id: int) -> Dataset: |
| dataset = db.get(Dataset, dataset_id) |
| if not dataset: |
| raise HTTPException(status.HTTP_404_NOT_FOUND, "Dataset not found") |
| return dataset |
|
|
|
|
| @router.get("/datasets", response_model=list[DatasetOut]) |
| def list_datasets( |
| _: User = Depends(require_admin), |
| db: Session = Depends(get_db), |
| ) -> list[DatasetOut]: |
| datasets = db.execute(select(Dataset).order_by(Dataset.creation_time.desc())).scalars().all() |
| out: list[DatasetOut] = [] |
| for d in datasets: |
| item = DatasetOut.model_validate(d) |
| item.case_count = ds.case_count(db, d) |
| out.append(item) |
| return out |
|
|
|
|
| @router.get("/datasets/{dataset_id}", response_model=DatasetDetailOut) |
| def get_dataset( |
| dataset_id: int, |
| _: User = Depends(require_admin), |
| db: Session = Depends(get_db), |
| ) -> DatasetDetailOut: |
| dataset = _get_dataset(db, dataset_id) |
| stats = ds.dataset_stats(db, dataset) |
| base = DatasetOut.model_validate(dataset) |
| base.case_count = stats["case_count"] |
| return DatasetDetailOut(**base.model_dump(), stats=stats) |
|
|
|
|
| @router.get("/test-match") |
| def test_match( |
| kind: str, |
| dog_id: int, |
| top_k: int = 10, |
| apply_breed_gate: bool = False, |
| _: User = Depends(require_admin), |
| db: Session = Depends(get_db), |
| ) -> dict: |
| """Score one dog against ALL dogs in the opposite category by embedding similarity (testing).""" |
| if kind not in ("known", "unknown"): |
| raise HTTPException(status.HTTP_400_BAD_REQUEST, "kind must be 'known' or 'unknown'") |
| subject_type = SubjectType.known if kind == "known" else SubjectType.unknown |
| query = ds.dog_profile(db, subject_type, dog_id) |
| if query is None: |
| raise HTTPException(status.HTTP_404_NOT_FOUND, "Dog not found") |
|
|
| top_k = max(1, min(top_k, 50)) |
| from ..services.matching import rank_dog_against_opposite |
|
|
| ranked, considered, query_embedded = rank_dog_against_opposite( |
| db, subject_type=subject_type, subject_id=dog_id, top_k=top_k, |
| apply_breed_gate=apply_breed_gate, |
| ) |
| results = [] |
| for cand_type, cid, score in ranked: |
| prof = ds.dog_profile(db, cand_type, cid) |
| if prof: |
| results.append({**prof, "score": score}) |
|
|
| from ..ml import get_embedder |
|
|
| e = get_embedder() |
| return { |
| "query": query, |
| "results": results, |
| "model": f"{e.name}/{e.version}", |
| "candidate_count": considered, |
| "query_embedded": query_embedded, |
| } |
|
|
|
|
| @router.get("/dog/{kind}/{dog_id}") |
| def dog_detail( |
| kind: str, |
| dog_id: int, |
| _: User = Depends(require_admin), |
| db: Session = Depends(get_db), |
| ) -> dict: |
| """A dog's profile plus ALL of its photos (full images) — for the profile viewer.""" |
| if kind not in ("known", "unknown"): |
| raise HTTPException(status.HTTP_400_BAD_REQUEST, "kind must be 'known' or 'unknown'") |
| subject_type = SubjectType.known if kind == "known" else SubjectType.unknown |
| profile = ds.dog_profile(db, subject_type, dog_id) |
| if profile is None: |
| raise HTTPException(status.HTTP_404_NOT_FOUND, "Dog not found") |
| from .helpers import pictures_for |
|
|
| photos = [p.model_dump() for p in pictures_for(db, subject_type, dog_id)] |
| return {"profile": profile, "photos": photos} |
|
|
|
|
| @router.get("/breeds") |
| def list_breeds( |
| _: User = Depends(require_admin), |
| db: Session = Depends(get_db), |
| ) -> dict: |
| """Predicted breed labels (HF softmax, active model) available to filter by.""" |
| return {"model": ds.active_breed_model_in_db(db), "breeds": ds.list_breeds(db)} |
|
|
|
|
| @router.get("/dogs") |
| def list_all_dogs( |
| kind: str = "all", |
| limit: int = 30, |
| offset: int = 0, |
| breed: str | None = None, |
| breed_k: int = 10, |
| sort: str = "newest", |
| zip: str | None = None, |
| added_from: date | None = None, |
| added_to: date | None = None, |
| _: User = Depends(require_admin), |
| db: Session = Depends(get_db), |
| ) -> dict: |
| """Browse every dog profile, filterable by predicted breed / ZIP / added-date and sortable. |
| |
| ``breed_k`` = 1 matches the top predicted breed; 5–10 matches within the top-K. ``sort`` is |
| ``newest`` (default) or ``oldest``. ``zip`` matches a dog's ZIP by prefix; ``added_from`` / |
| ``added_to`` bound the added date (inclusive). |
| """ |
| kind = kind if kind in ("all", "known", "unknown") else "all" |
| limit = max(1, min(limit, 100)) |
| offset = max(0, offset) |
| breed_k = max(1, min(breed_k, 50)) |
| sort = sort if sort in ("newest", "oldest") else "newest" |
| return ds.list_all_dogs( |
| db, kind, limit, offset, breed=breed or None, breed_k=breed_k, |
| sort=sort, zip_prefix=(zip or None), added_from=added_from, added_to=added_to, |
| ) |
|
|
|
|
| @router.get("/datasets/{dataset_id}/dogs") |
| def list_dataset_dogs( |
| dataset_id: int, |
| limit: int = 25, |
| offset: int = 0, |
| _: User = Depends(require_admin), |
| db: Session = Depends(get_db), |
| ) -> dict: |
| dataset = _get_dataset(db, dataset_id) |
| limit = max(1, min(limit, 100)) |
| return ds.list_dogs(db, dataset, limit, offset) |
|
|
|
|
| @router.delete("/datasets/{dataset_id}", response_model=PurgeResult) |
| def delete_dataset( |
| dataset_id: int, |
| _: User = Depends(require_admin), |
| db: Session = Depends(get_db), |
| ) -> PurgeResult: |
| dataset = _get_dataset(db, dataset_id) |
| deleted = ds.purge_dataset(db, dataset) |
| return PurgeResult(dataset_id=dataset_id, deleted=deleted) |
|
|
|
|
| @router.get("/image/{image_id}/dataset", response_model=ImageDatasetOut) |
| def image_dataset( |
| image_id: int, |
| _: User = Depends(require_admin), |
| db: Session = Depends(get_db), |
| ) -> ImageDatasetOut: |
| pic = db.get(Picture, image_id) |
| if not pic: |
| raise HTTPException(status.HTTP_404_NOT_FOUND, "Image not found") |
| from ..models import KnownDog, UnknownDog |
|
|
| if pic.subject_type == SubjectType.known: |
| dog = db.get(KnownDog, pic.subject_id) |
| else: |
| dog = db.get(UnknownDog, pic.subject_id) |
| dataset_id = getattr(dog, "dataset_id", None) if dog else None |
| dataset_name = None |
| if dataset_id: |
| d = db.get(Dataset, dataset_id) |
| dataset_name = d.name if d else None |
| return ImageDatasetOut( |
| image_id=image_id, |
| subject_type=pic.subject_type.value, |
| subject_id=pic.subject_id, |
| dataset_id=dataset_id, |
| dataset_name=dataset_name, |
| ) |
|
|
|
|
| @router.post("/datasets/{dataset_id}/embed-all", response_model=EmbedAllResult) |
| def embed_all( |
| dataset_id: int, |
| _: User = Depends(require_admin), |
| db: Session = Depends(get_db), |
| ) -> EmbedAllResult: |
| dataset = _get_dataset(db, dataset_id) |
| result = ds.embed_all(db, dataset) |
| return EmbedAllResult(dataset_id=dataset_id, **result) |
|
|
|
|
| @router.post("/datasets/{dataset_id}/match", response_model=MatchDatasetResult) |
| def match_dataset( |
| dataset_id: int, |
| candidate_dataset_id: int | None = None, |
| _: User = Depends(require_admin), |
| db: Session = Depends(get_db), |
| ) -> MatchDatasetResult: |
| dataset = _get_dataset(db, dataset_id) |
| result = ds.match_dataset(db, dataset, candidate_dataset_id=candidate_dataset_id) |
| return MatchDatasetResult( |
| dataset_id=dataset_id, |
| cases_processed=result["cases_processed"], |
| matches_created=result["matches_created"], |
| candidate_dataset_id=result["candidate_dataset_id"], |
| ) |
|
|
