Upload folder using huggingface_hub

src/eval_card_registry/api/deps.py

@@ -0,0 +1,11 @@
+from fastapi import Depends, HTTPException
+
+from eval_card_registry.config import settings
+
+
+def check_writable():
+    if settings.read_only:
+        raise HTTPException(status_code=405, detail="Write operations disabled in read-only mode")
+
+
+writable = [Depends(check_writable)]

src/eval_card_registry/api/routes_aliases.py

@@ -3,19 +3,13 @@ from typing import Optional
 
 from fastapi import APIRouter, Depends, HTTPException
 
+from eval_card_registry.api.deps import writable as _writable
 from eval_card_registry.api.schemas import AliasPatch, AliasStatus, EntityType
-from eval_card_registry.config import settings
 from eval_card_registry.store.hf_store import get_store, RegistryStore
 from eval_card_registry.store import queries
 
 
-def _check_writable():
-    if settings.read_only:
-        raise HTTPException(status_code=405, detail="Write operations disabled in read-only mode")
-
-
 router = APIRouter()
-_writable = [Depends(_check_writable)]
 
 
 @router.get("/aliases")

src/eval_card_registry/api/routes_entities.py

@@ -3,6 +3,7 @@ from typing import Optional
 
 from fastapi import APIRouter, Depends, HTTPException
 
+from eval_card_registry.api.deps import writable as _writable
 from eval_card_registry.api.schemas import (
     BenchmarkCreate, BenchmarkPatch,
     HarnessCreate, HarnessPatch,
@@ -10,17 +11,10 @@ from eval_card_registry.api.schemas import (
     ModelCreate, ModelPatch,
     ReviewStatus,
 )
-from eval_card_registry.config import settings
 from eval_card_registry.store.hf_store import get_store, RegistryStore
 from eval_card_registry.store import queries
 
-
-def _check_writable():
-    if settings.read_only:
-        raise HTTPException(status_code=405, detail="Write operations disabled in read-only mode")
-
 router = APIRouter()
-_writable = [Depends(_check_writable)]
 
 
 def _get_or_404(store, table, entity_id):

src/eval_card_registry/api/routes_health.py

@@ -5,16 +5,20 @@ from eval_card_registry.store.hf_store import get_store, RegistryStore
 router = APIRouter()
 
 
+def _safe_count(store: RegistryStore, table: str) -> int:
+    return len(store.table(table)) if store.has_table(table) else 0
+
+
 @router.get("/health")
 def health(store: RegistryStore = Depends(get_store)):
     return {
         "status": "ok",
         "store": "loaded" if store.loaded else "not_loaded",
         "entities": {
-            "models": len(store.table("canonical_models")) if store.has_table("canonical_models") else 0,
-            "benchmarks": len(store.table("canonical_benchmarks")) if store.has_table("canonical_benchmarks") else 0,
-            "metrics": len(store.table("canonical_metrics")) if store.has_table("canonical_metrics") else 0,
-            "harnesses": len(store.table("eval_harnesses")) if store.has_table("eval_harnesses") else 0,
+            "models": _safe_count(store, "canonical_models"),
+            "benchmarks": _safe_count(store, "canonical_benchmarks"),
+            "metrics": _safe_count(store, "canonical_metrics"),
+            "harnesses": _safe_count(store, "eval_harnesses"),
         },
     }
 
@@ -42,6 +46,6 @@ def stats(store: RegistryStore = Depends(get_store)):
         "metrics": _counts("canonical_metrics"),
         "harnesses": _counts("eval_harnesses"),
         "aliases": aliases_stats,
-        "resolution_log": {"total": len(store.table("resolution_log")) if store.has_table("resolution_log") else 0},
-        "sync_runs": {"total": len(store.table("sync_runs")) if store.has_table("sync_runs") else 0},
+        "resolution_log": {"total": _safe_count(store, "resolution_log")},
+        "sync_runs": {"total": _safe_count(store, "sync_runs")},
     }

src/eval_card_registry/api/routes_orgs.py

@@ -0,0 +1,71 @@
+import json
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from eval_card_registry.api.deps import writable as _writable
+from eval_card_registry.api.schemas import OrgCreate, OrgPatch, ReviewStatus
+from eval_card_registry.store.hf_store import get_store, RegistryStore
+from eval_card_registry.store import queries
+
+router = APIRouter()
+
+
+def _get_or_404(store, entity_id):
+    entity = queries.get_entity(store, "canonical_orgs", entity_id)
+    if entity is None:
+        raise HTTPException(status_code=404, detail=f"canonical_orgs '{entity_id}' not found")
+    return entity
+
+
+_JSON_FIELDS = {"tags", "metadata"}
+
+
+def _encode(data: dict) -> dict:
+    out = {}
+    for k, v in data.items():
+        if k in _JSON_FIELDS and isinstance(v, (list, dict)):
+            out[k] = json.dumps(v)
+        else:
+            out[k] = v
+    return out
+
+
+def _decode(entity: dict) -> dict:
+    out = {}
+    for k, v in entity.items():
+        if k in _JSON_FIELDS and isinstance(v, str):
+            try:
+                out[k] = json.loads(v)
+            except (json.JSONDecodeError, TypeError):
+                out[k] = v
+        else:
+            out[k] = v
+    return out
+
+
+@router.get("/orgs")
+def list_orgs(
+    search: Optional[str] = None,
+    review_status: Optional[ReviewStatus] = None,
+    store: RegistryStore = Depends(get_store),
+):
+    return [_decode(e) for e in queries.list_entities(store, "canonical_orgs", search=search, review_status=review_status)]
+
+
+@router.get("/orgs/{org_id}")
+def get_org(org_id: str, store: RegistryStore = Depends(get_store)):
+    return _decode(_get_or_404(store, org_id))
+
+
+@router.post("/orgs", status_code=201, dependencies=_writable)
+def create_org(body: OrgCreate, store: RegistryStore = Depends(get_store)):
+    return _decode(queries.upsert_entity(store, "canonical_orgs", _encode(body.model_dump())))
+
+
+@router.patch("/orgs/{org_id}", dependencies=_writable)
+def patch_org(org_id: str, body: OrgPatch, store: RegistryStore = Depends(get_store)):
+    _get_or_404(store, org_id)
+    data = {k: v for k, v in body.model_dump().items() if v is not None}
+    data["id"] = org_id
+    return _decode(queries.upsert_entity(store, "canonical_orgs", _encode(data)))

src/eval_card_registry/cli.py

@@ -14,6 +14,7 @@ import yaml
 
 from eval_card_registry.store.hf_store import get_store
 from eval_card_registry.store import queries
+from eval_card_registry.store.queries import _is_na
 
 app = typer.Typer(help="eval-card-registry CLI")
 
@@ -124,8 +125,7 @@ def seed(
             for idx in seed_aliases.index:
                 row = seed_aliases.loc[idx]
                 sc = row.get("source_config")
-                # pandas NA → None so comparison matches how aliases were added.
-                if sc is None or (isinstance(sc, float) and sc != sc) or (hasattr(sc, "__class__") and sc.__class__.__name__ == "NAType"):
+                if _is_na(sc):
                     sc = None
                 key = (row["raw_value"], row["entity_type"], row["canonical_id"], sc)
                 if key in yaml_alias_keys:

src/eval_card_registry/main.py

@@ -3,7 +3,7 @@ from contextlib import asynccontextmanager
 from fastapi import FastAPI
 
 from eval_card_registry.config import settings
-from eval_card_registry.store.hf_store import get_store, _QUERY_TABLE_NAMES
+from eval_card_registry.store.hf_store import get_store, QUERY_TABLE_NAMES
 from eval_card_registry.services.resolution_service import ResolutionService
 from eval_card_registry.services.log_writer import ResolveLogWriter
 from eval_card_registry.api.routes_resolve import router as resolve_router
@@ -16,7 +16,7 @@ from eval_card_registry.api.routes_health import router as health_router
 async def lifespan(app: FastAPI):
     store = get_store()
     if settings.read_only:
-        store.load(tables=_QUERY_TABLE_NAMES)
+        store.load(tables=QUERY_TABLE_NAMES)
     else:
         store.load()
 

src/eval_card_registry/services/resolution_service.py

@@ -55,6 +55,32 @@ def _build_alias_store(registry_store: RegistryStore) -> AliasStore:
     return AliasStore(aliases_df, read_only=True)
 
 
+def _no_match_result() -> dict:
+    return {
+        "canonical_id": None,
+        "strategy": "no_match",
+        "confidence": 0.0,
+        "created_new": False,
+        "review_status": None,
+    }
+
+
+def _match_result(
+    canonical_id: str,
+    strategy: str,
+    confidence: float,
+    review_status: Optional[str],
+    created_new: bool = False,
+) -> dict:
+    return {
+        "canonical_id": canonical_id,
+        "strategy": strategy,
+        "confidence": confidence,
+        "created_new": created_new,
+        "review_status": review_status,
+    }
+
+
 class ResolutionService:
     def __init__(self, registry_store: RegistryStore) -> None:
         self.store = registry_store
@@ -89,13 +115,7 @@ class ResolutionService:
         - canonical_id, strategy, confidence, created_new, review_status
         """
         if not raw_value or not raw_value.strip():
-            return {
-                "canonical_id": None,
-                "strategy": "no_match",
-                "confidence": 0.0,
-                "created_new": False,
-                "review_status": None,
-            }
+            return _no_match_result()
 
         # Fast path: return cached result for duplicate (raw_value, entity_type, source_config)
         cache_key = (raw_value, entity_type, source_config)
@@ -108,21 +128,14 @@ class ResolutionService:
             result: ResolutionResult = resolver.resolve(raw_value, entity_type, source_config)
             if result.canonical_id is not None:
                 entity = queries.get_entity(self.store, _ENTITY_TABLE[entity_type], result.canonical_id)
-                result_dict = {
-                    "canonical_id": result.canonical_id,
-                    "strategy": result.strategy,
-                    "confidence": result.confidence,
-                    "created_new": False,
-                    "review_status": entity.get("review_status") if entity else None,
-                }
+                result_dict = _match_result(
+                    result.canonical_id,
+                    result.strategy,
+                    result.confidence,
+                    entity.get("review_status") if entity else None,
+                )
             else:
-                result_dict = {
-                    "canonical_id": None,
-                    "strategy": "no_match",
-                    "confidence": 0.0,
-                    "created_new": False,
-                    "review_status": None,
-                }
+                result_dict = _no_match_result()
             self._resolve_cache[cache_key] = result_dict
             return result_dict
 
@@ -131,13 +144,12 @@ class ResolutionService:
             existing = queries.get_alias(self.store, raw_value, entity_type, source_config)
             if existing:
                 entity = queries.get_entity(self.store, _ENTITY_TABLE[entity_type], existing["canonical_id"])
-                result_dict = {
-                    "canonical_id": existing["canonical_id"],
-                    "strategy": existing["strategy"],
-                    "confidence": existing["confidence"],
-                    "created_new": False,
-                    "review_status": entity.get("review_status") if entity else None,
-                }
+                result_dict = _match_result(
+                    existing["canonical_id"],
+                    existing["strategy"],
+                    existing["confidence"],
+                    entity.get("review_status") if entity else None,
+                )
                 self._resolve_cache[cache_key] = result_dict
                 return result_dict
 
@@ -218,13 +230,13 @@ class ResolutionService:
             self.invalidate_resolver()
 
         entity = queries.get_entity(self.store, _ENTITY_TABLE[entity_type], canonical_id)
-        result_dict = {
-            "canonical_id": canonical_id,
-            "strategy": strategy_used,
-            "confidence": result.confidence,
-            "created_new": created_new,
-            "review_status": entity.get("review_status") if entity else "draft",
-        }
+        result_dict = _match_result(
+            canonical_id,
+            strategy_used,
+            result.confidence,
+            entity.get("review_status") if entity else "draft",
+            created_new=created_new,
+        )
         self._resolve_cache[cache_key] = result_dict
         return result_dict
 

src/eval_card_registry/store/hf_store.py

@@ -27,7 +27,7 @@ def _fixtures_path() -> Path:
     return Path(os.environ.get("FIXTURES_PATH", settings.fixtures_path))
 
 
-_TABLE_NAMES = [
+TABLE_NAMES = [
     "canonical_models",
     "canonical_benchmarks",
     "canonical_metrics",
@@ -39,7 +39,7 @@ _TABLE_NAMES = [
 ]
 
 # Tables needed for query-only (read-only) mode
-_QUERY_TABLE_NAMES = [
+QUERY_TABLE_NAMES = [
     "canonical_models",
     "canonical_benchmarks",
     "canonical_metrics",
@@ -65,7 +65,7 @@ class RegistryStore:
         Args:
             tables: Specific table names to load. If None, loads all tables.
         """
-        names = tables or _TABLE_NAMES
+        names = tables or TABLE_NAMES
         if _local_mode():
             self._load_from_fixtures(_fixtures_path(), names)
         else:

src/eval_card_registry/store/queries.py

@@ -40,10 +40,9 @@ def _row_to_dict(row: pd.Series) -> dict:
 
 def _records(df: pd.DataFrame) -> list[dict]:
     """Convert a DataFrame to list-of-dicts, coercing NA/NaN to None for JSON."""
-    return [
-        {k: (None if _is_na(v) else v) for k, v in rec.items()}
-        for rec in df.to_dict(orient="records")
-    ]
+    if df.empty:
+        return []
+    return df.astype(object).mask(df.isna(), None).to_dict(orient="records")
 
 
 # ------------------------------------------------------------------