improvement(presidio): address review feedback

- Register VIN under all served languages, not just en (Bugbot: VIN missed for
  non-English language routing).
- Bump HEALTHCHECK start-period to 180s — five lg models load at import (Bugbot).
- Drop --no-cache-dir so the pip cache mount actually works (Greptile).
- Pydantic request models for /analyze + /anonymize so missing 'text' returns
  422 not 500; default operator 'type' to 'replace' instead of KeyError->500
  (Greptile).

Author: TheodoreSpeaks

docker/presidio.Dockerfile

@@ -16,7 +16,7 @@ RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
 # don't reinstall the heavy model.
 COPY docker/presidio/requirements.txt ./requirements.txt
 RUN --mount=type=cache,target=/root/.cache/pip \
-    pip install --no-cache-dir -r requirements.txt
+    pip install -r requirements.txt
 
 # Pinned spaCy models (en + es/it/pl/fi, ~2.2GB total). Downloaded with
 # retries/resume — the large wheels truncate on flaky networks if pip fetches
@@ -29,7 +29,7 @@ RUN --mount=type=cache,target=/root/.cache/pip \
         -o "/tmp/${whl}" \
         "https://github.com/explosion/spacy-models/releases/download/${model}/${whl}" || exit 1; \
     done && \
-    pip install --no-cache-dir /tmp/*.whl && \
+    pip install /tmp/*.whl && \
     rm /tmp/*.whl
 
 COPY docker/presidio/server.py ./server.py
@@ -41,7 +41,9 @@ USER presidio
 
 EXPOSE 3000
 
-HEALTHCHECK --interval=30s --timeout=5s --start-period=40s --retries=3 \
+# start-period is generous: five large spaCy models load at import before
+# /health responds. Tune against measured cold-start once built.
+HEALTHCHECK --interval=30s --timeout=5s --start-period=180s --retries=3 \
     CMD curl -fsS http://localhost:3000/health || exit 1
 
 CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "3000"]

docker/presidio/server.py

@@ -7,7 +7,7 @@
 
 from typing import Any
 
-from fastapi import Body, FastAPI
+from fastapi import FastAPI
 from presidio_analyzer import AnalyzerEngine, Pattern, PatternRecognizer, RecognizerResult
 from presidio_analyzer.nlp_engine import NlpEngineProvider
 from presidio_analyzer.predefined_recognizers import (
@@ -35,6 +35,7 @@
 )
 from presidio_anonymizer import AnonymizerEngine
 from presidio_anonymizer.entities import OperatorConfig
+from pydantic import BaseModel
 
 # Languages served. Each needs its spaCy model installed in the image; the
 # es/it/pl/fi predefined recognizers (ES_NIF, IT_FISCAL_CODE, PL_PESEL, ...)
@@ -112,14 +113,18 @@ def validate_result(self, pattern_text: str):
 def build_analyzer() -> AnalyzerEngine:
     nlp_engine = NlpEngineProvider(nlp_configuration=NLP_CONFIGURATION).create_engine()
     analyzer = AnalyzerEngine(nlp_engine=nlp_engine, supported_languages=SUPPORTED_LANGUAGES)
+    # VIN is language-agnostic, so register it under every served language —
+    # a recognizer only fires for the language the caller routes to.
     vin_pattern = Pattern(name="vin", regex=r"\b[A-HJ-NPR-Z0-9]{17}\b", score=0.7)
-    analyzer.registry.add_recognizer(
-        VinRecognizer(
-            supported_entity="VIN",
-            patterns=[vin_pattern],
-            context=["vin", "vehicle", "chassis"],
+    for language in SUPPORTED_LANGUAGES:
+        analyzer.registry.add_recognizer(
+            VinRecognizer(
+                supported_entity="VIN",
+                patterns=[vin_pattern],
+                context=["vin", "vehicle", "chassis"],
+                supported_language=language,
+            )
         )
-    )
     for recognizer_cls in EXTRA_RECOGNIZERS:
         analyzer.registry.add_recognizer(recognizer_cls())
     return analyzer
@@ -131,6 +136,21 @@ def build_analyzer() -> AnalyzerEngine:
 app = FastAPI(title="Sim Presidio", docs_url=None, redoc_url=None)
 
 
+class AnalyzeRequest(BaseModel):
+    text: str
+    language: str = "en"
+    entities: list[str] | None = None
+    score_threshold: float | None = None
+    return_decision_process: bool = False
+
+
+class AnonymizeRequest(BaseModel):
+    text: str
+    analyzer_results: list[dict[str, Any]] = []
+    anonymizers: dict[str, dict[str, Any]] | None = None
+    operators: dict[str, dict[str, Any]] | None = None
+
+
 @app.get("/health")
 def health() -> dict[str, str]:
     return {"status": "ok"}
@@ -142,38 +162,38 @@ def supported_entities(language: str = "en") -> list[str]:
 
 
 @app.post("/analyze")
-def analyze(payload: dict[str, Any] = Body(...)) -> list[dict[str, Any]]:
-    entities = payload.get("entities") or None
+def analyze(req: AnalyzeRequest) -> list[dict[str, Any]]:
     results = analyzer.analyze(
-        text=payload["text"],
-        language=payload.get("language", "en"),
-        entities=entities,
-        score_threshold=payload.get("score_threshold"),
-        return_decision_process=payload.get("return_decision_process", False),
+        text=req.text,
+        language=req.language,
+        entities=req.entities or None,
+        score_threshold=req.score_threshold,
+        return_decision_process=req.return_decision_process,
     )
     return [r.to_dict() for r in results]
 
 
 @app.post("/anonymize")
-def anonymize(payload: dict[str, Any] = Body(...)) -> dict[str, Any]:
+def anonymize(req: AnonymizeRequest) -> dict[str, Any]:
     analyzer_results = [
         RecognizerResult(
             entity_type=r["entity_type"],
             start=r["start"],
             end=r["end"],
             score=r.get("score", 1.0),
         )
-        for r in payload.get("analyzer_results", [])
+        for r in req.analyzer_results
     ]
-    raw_operators = payload.get("anonymizers") or payload.get("operators")
+    raw_operators = req.anonymizers or req.operators
     operators = None
     if raw_operators:
         operators = {}
-        for entity, cfg in raw_operators.items():
-            cfg = dict(cfg)
-            operators[entity] = OperatorConfig(cfg.pop("type"), cfg)
+        for entity, raw_cfg in raw_operators.items():
+            op_cfg = dict(raw_cfg)
+            op_type = op_cfg.pop("type", "replace")
+            operators[entity] = OperatorConfig(op_type, op_cfg)
     result = anonymizer.anonymize(
-        text=payload["text"],
+        text=req.text,
         analyzer_results=analyzer_results,
         operators=operators,
     )