Fix provider TTL overrides and CEL preview cache

Author: jeremi

spp_cel_domain/EXTERNAL_METRICS_SPEC_V2.md

@@ -34,7 +34,7 @@ Modules
 
 - `openspp_metrics` (new core)
   - Owns feature store, provider registry, push/pull APIs, invalidation, admin dashboards.
-  - Exposes Odoo models: `openspp.metric.registry`, `openspp.function.registry`, `openspp.feature.store`.
+  - Exposes Odoo models: `openspp.indicator.registry`, `openspp.function.registry`, `openspp.feature.store`.
 - `cel_domain` (existing)
   - Soft‑depends at runtime; uses the registries to evaluate metrics in CEL expressions.
 - Reuse elsewhere
@@ -126,7 +126,7 @@ Preview vs Evaluate
 
 6.1 Registration (soft dependency)
 
-- Providers register metrics in `post_init_hook` only if `openspp.metric.registry` exists.
+- Providers register metrics in `post_init_hook` only if `openspp.indicator.registry` exists.
 - Example
 
 ```
@@ -135,10 +135,10 @@ from odoo import api, SUPERUSER_ID
 
 def post_init_hook(cr, registry):
     env = api.Environment(cr, SUPERUSER_ID, {})
-    if 'openspp.metric.registry' not in env:
+    if 'openspp.indicator.registry' not in env:
         return
     from .providers.attendance import AttendanceProvider
-    env['openspp.metric.registry'].register(
+    env['openspp.indicator.registry'].register(
         name='education.attendance_pct',
         handler=AttendanceProvider(),
         return_type='number',
@@ -431,12 +431,12 @@ This repository now ships Phase 1 fully and key Phase 2 items:
 
 - New addon `openspp_metrics`
 
-  - Feature store model/table: `openspp.feature.value`.
+  - Feature store model/table: `openspp.indicator.value`.
     - Columns now include: `metric`, `provider`, `subject_model`, `subject_id`, `period_key`, `value_json`,
       `value_type`, `params_hash`, `coverage`, `as_of`, `fetched_at`, `expires_at`, `source`, `error_code`,
       `error_message`, `updated_at`, `company_id`.
     - Unique key: `(metric, provider, subject_model, subject_id, period_key, params_hash, company_id)`.
-  - Registry: `openspp.metric.registry` (Python‑backed) + `register_static()` for deterministic startup.
+  - Registry: `openspp.indicator.registry` (Python‑backed) + `register_static()` for deterministic startup.
   - Service: `openspp.metrics.evaluate()` with cache_only/refresh/fallback, ID mapping chain, and stats
     (requested/hits/misses/fresh/coverage).
   - HTTP: `POST /api/metrics/push`, `POST /api/metrics/invalidate` (X‑Api‑Key or admin session).

spp_cel_domain/METRICS_SQL_OPTIMIZATION_SPEC_V2.md

@@ -162,7 +162,7 @@ Queue details (existing API)
 
 ### 5) Provider/params resolution
 
-- Provider label comes from `openspp.metric.registry.get(metric)['provider']` if present; fallback to
+- Provider label comes from `openspp.indicator.registry.get(metric)['provider']` if present; fallback to
   `metric`.
 - `params_hash` should be `""` for CEL V2 unless the CEL translator passes explicit params; keep code ready to
   accept it.
@@ -211,7 +211,7 @@ File: `cel_domain/models/cel_executor.py`
 
 2. Add helper `_metric_registry_info(metric) -> (provider, return_type)`
 
-   - Query `openspp.metric.registry.get(metric)`; default provider to metric name.
+   - Query `openspp.indicator.registry.get(metric)`; default provider to metric name.
 
 3. Add helper
    `_metric_cache_status_sql(model, base_domain, metric, period_key, provider, params_hash) -> dict`

spp_cel_domain/models/cel_executor.py

@@ -236,10 +236,23 @@ def _exec_exists(self, p: ExistsThrough) -> list[int]:
             dom = self._and_domains(dom, mem_dom)
         if child_subplan is not None:
             child_domain, requires_exec_child = self._plan_to_domain(p.child_model, child_subplan)
+            try:
+                self._logger.info(
+                    "[CEL EXISTS] child_subplan model=%s plan=%s requires_exec=%s",
+                    getattr(child_subplan, "model", None),
+                    getattr(child_subplan, "domain", None),
+                    requires_exec_child,
+                )
+            except Exception:
+                pass
             if requires_exec_child:
                 child_ids = self._execute_plan(p.child_model, child_subplan)
             else:
                 child_domain = self._ensure_domain_list(child_domain)
+                try:
+                    self._logger.info("[CEL EXISTS] applying child domain=%s on model=%s", child_domain, p.child_model)
+                except Exception:
+                    pass
                 child_ids = self.env[p.child_model].search(child_domain).ids
             child_ids = [int(i) for i in child_ids if i]
             if not child_ids:
@@ -302,8 +315,28 @@ def _exec_count(self, p: CountThrough) -> list[int]:  # noqa: C901
                 child_ids = self._execute_plan(p.child_model, child_subplan)
             else:
                 child_domain = self._ensure_domain_list(child_domain)
+                try:
+                    self._logger.info("[CEL EXISTS] applying child domain=%s on model=%s", child_domain, p.child_model)
+                except Exception:
+                    pass
                 child_ids = self.env[p.child_model].search(child_domain).ids
             child_ids = [int(i) for i in child_ids if i]
+            try:
+                sample_labels = []
+                if child_ids:
+                    records = self.env[p.child_model].browse(child_ids[:5])
+                    sample_labels = [
+                        getattr(rec, "name", None) or getattr(rec, "display_name", None) for rec in records
+                    ]
+                self._logger.info(
+                    "[CEL EXISTS] child filter results child_model=%s domain=%s ids=%s sample=%s",
+                    p.child_model,
+                    child_domain,
+                    child_ids[:10],
+                    sample_labels,
+                )
+            except Exception:
+                pass
             if not child_ids:
                 # No matching children; counts are zero for all candidate parents
                 if not candidate_parents and parent_model_name:
@@ -386,7 +419,7 @@ def _exec_metric(self, model: str, p: MetricCompare, metrics_info: list[dict[str
         # Resolve flags
         ICP = self.env["ir.config_parameter"].sudo()
         enable_sql = bool(int(ICP.get_param("cel.enable_sql_metrics", "1")))
-        preview_cache_only = bool(int(ICP.get_param("cel.preview_cache_only", "1")))
+        preview_cache_only = bool(int(ICP.get_param("cel.preview_cache_only", "0")))
         async_threshold = int(ICP.get_param("cel.async_threshold", "50000") or 50000)
         allow_any_provider = self._allow_any_provider_fallback()
         # Provider resolution
@@ -483,12 +516,17 @@ def _exec_metric(self, model: str, p: MetricCompare, metrics_info: list[dict[str
         if total_requested:
             stats_total["requested"] = total_requested
             stats_total["coverage"] = len(aggregated_values) / float(base_count or 1)
+        incomplete_cache = eval_mode == "cache_only" and total_requested and len(aggregated_values) < total_requested
         if eval_mode == "cache_only":
             path_flag = "cache_only"
         else:
             path_flag = "python" if status.get("status") != "fresh" else "cache"
+        stats_total.update({"path": path_flag})
+        if incomplete_cache:
+            if metrics_info is not None:
+                metrics_info.append(stats_total)
+            return []
         if metrics_info is not None:
-            stats_total.update({"path": path_flag})
             metrics_info.append(stats_total)
         res = []
         for sid, val in aggregated_values.items():
@@ -498,7 +536,7 @@ def _exec_metric(self, model: str, p: MetricCompare, metrics_info: list[dict[str
         return res
 
     def _metric_registry_info(self, metric: str) -> tuple[str, str]:
-        info = self.env["openspp.metric.registry"].get(metric) or {}
+        info = self.env["openspp.indicator.registry"].get(metric) or {}
         provider = info.get("provider") or metric
         return_type = info.get("return_type") or "json"
         return provider, return_type

spp_cel_domain/models/cel_translator.py

@@ -648,6 +648,37 @@ def _smart_op_domain(self, field: str, op: str, right: Any, model_name: str) ->
                             break
                 resolved_ids: list[int] = []
                 if comodel and isinstance(right, str):
+                    if "value" in self.env[comodel]._fields:
+                        direct = (
+                            self.env[comodel]
+                            .with_context(active_test=False)
+                            .search([("value", "=", right.capitalize())], limit=None)
+                        )
+                        if not direct and right.lower() in {"male", "female"}:
+                            code_defaults = {"male": "M", "female": "F"}
+                            direct = (
+                                self.env[comodel]
+                                .with_context(active_test=False)
+                                .sudo()
+                                .create(
+                                    {
+                                        "value": right.capitalize(),
+                                        "code": code_defaults[right.lower()],
+                                    }
+                                )
+                            )
+                        if direct:
+                            resolved_ids = direct.ids
+                            if op in ("=", "=="):
+                                if len(resolved_ids) == 1:
+                                    return [(field, "=", resolved_ids[0])]
+                                return [(field, "in", resolved_ids)]
+                            if op == "in":
+                                return [(field, "in", resolved_ids)]
+                            if op == "ilike":
+                                base_domain = [(field, "in", resolved_ids)]
+                                return expression.OR([base_domain, [(f"{field}.{label_field}", "ilike", right)]])
+
                     name_clauses: list[list[Any]] = []
                     for attr in ("value", "name", "code"):
                         if attr in self.env[comodel]._fields:
@@ -658,6 +689,17 @@ def _smart_op_domain(self, field: str, op: str, right: Any, model_name: str) ->
                     else:
                         lookup_domain = [("name", "ilike", right)]
                     matches = self.env[comodel].with_context(active_test=False).search(lookup_domain, limit=None)
+                    try:
+                        _logger.info(
+                            "[CEL TRANSLATOR] smart-op lookup model=%s field=%s op=%s value=%s matches=%s",
+                            model_name,
+                            field,
+                            op,
+                            right,
+                            [(m.id, getattr(m, "value", None), getattr(m, "name", None)) for m in matches],
+                        )
+                    except Exception:
+                        pass
                     if matches:
                         target = right.casefold()
                         exact = matches.filtered(
@@ -666,7 +708,7 @@ def _smart_op_domain(self, field: str, op: str, right: Any, model_name: str) ->
                                 for attr in ("value", "name", "code")
                             )
                         )
-                        resolved_ids = exact.ids or []
+                        resolved_ids = exact.ids if exact else []
                 if resolved_ids:
                     if op in ("=", "=="):
                         if len(resolved_ids) == 1:

spp_cel_domain/tests/test_aggregators.py

@@ -18,7 +18,7 @@ def setUp(self):
         M.create({"group": self.g1.id, "individual": self.m2.id, "is_ended": False})
         M.create({"group": self.g2.id, "individual": self.m3.id, "is_ended": False})
         # Push metric values for September
-        FV = self.env["openspp.feature.value"]
+        FV = self.env["openspp.indicator.value"]
         # G1 avg = (90 + 100) / 2 = 95, coverage=1.0
         FV.sudo().upsert_values(
             [

spp_cel_domain/tests/test_cycles.py

@@ -43,7 +43,7 @@ def _ids(self, expr):
 
     def test_last_first_previous_next(self):
         # Push values for each cycle to exercise cycle helpers with metrics
-        FV = self.env["openspp.feature.value"]
+        FV = self.env["openspp.indicator.value"]
         FV.sudo().upsert_values(
             [
                 {

spp_cel_domain/tests/test_metrics_integration.py

@@ -23,7 +23,7 @@ def test_push_and_filter_by_metric(self):
                 # p3 missing
             ],
         }
-        self.env["openspp.feature.value"].sudo().upsert_values(
+        self.env["openspp.indicator.value"].sudo().upsert_values(
             [
                 {
                     "metric": payload["metric"],
@@ -59,7 +59,7 @@ def compute_batch(self, env, ctx, subject_ids):
                 counts = {r["group"][0]: r["group_count"] for r in rows if r.get("group")}
                 return {int(sid): int(counts.get(sid, 0)) for sid in subject_ids}
 
-        self.env["openspp.metric.registry"].register(
+        self.env["openspp.indicator.registry"].register(
             name="test_household.size",
             handler=_TestHouseholdSizeProvider(),
             return_type="number",
@@ -78,7 +78,7 @@ def compute_batch(self, env, ctx, subject_ids):
         Membership.create({"group": group.id, "individual": ind2.id, "is_ended": False})
 
         # Seed the value (cache path) to make the test robust across environments
-        self.env["openspp.feature.value"].sudo().upsert_values(
+        self.env["openspp.indicator.value"].sudo().upsert_values(
             [
                 {
                     "metric": "test_household.size",

spp_cel_domain/tests/test_metrics_namespaced.py

@@ -11,7 +11,7 @@ def setUp(self):
 
     def test_namespaced_metric_compare_individuals(self):
         # Seed cached values without provider (provider-agnostic push)
-        FV = self.env["openspp.feature.value"]
+        FV = self.env["openspp.indicator.value"]
         FV.sudo().upsert_values(
             [
                 {
@@ -51,7 +51,7 @@ def test_namespaced_metric_aggregator_groups(self):
         M = self.env["g2p.group.membership"]
         M.create({"group": G.id, "individual": c1.id, "is_ended": False})
         M.create({"group": G.id, "individual": c2.id, "is_ended": False})
-        FV = self.env["openspp.feature.value"]
+        FV = self.env["openspp.indicator.value"]
         # Values 90 and 100 → avg 95
         FV.sudo().upsert_values(
             [

spp_cel_domain/tests/test_metrics_sql_fastpath.py

@@ -32,7 +32,7 @@ def __init__(self, test_case):
             def compute_batch(self, env, ctx, subject_ids):
                 return {sid: self._test.seed_values.get(sid) for sid in subject_ids if sid in self._test.seed_values}
 
-        self.env["openspp.metric.registry"].register(
+        self.env["openspp.indicator.registry"].register(
             self.metric,
             _FakeProvider(self),
             return_type="number",
@@ -63,7 +63,7 @@ def _seed_cache(self, rows):
             }
             for sid, val in rows
         ]
-        self.env["openspp.feature.value"].sudo().upsert_values(rows_payload)
+        self.env["openspp.indicator.value"].sudo().upsert_values(rows_payload)
         self.seed_values = {sid: val for sid, val in rows}
 
     def test_sql_fast_path_numeric(self):
@@ -109,7 +109,7 @@ def test_evaluate_large_cohort_enqueues_refresh(self):
         plan, _ = Translator.translate("res.partner", expr, cfg)
         calls = {}
         # Patch enqueue_refresh to capture calls without relying on queue_job runtime
-        OpensppMetricsService = import_module("odoo.addons.spp_indicators.models.service").OpensppMetricsService
+        OpensppIndicatorService = import_module("odoo.addons.spp_indicators.models.service").OpensppIndicatorService
 
         def _fake_enqueue(self_, metric, subject_model, subject_ids, period_key, *, chunk_size=2000):
             calls["metric"] = metric
@@ -118,7 +118,7 @@ def _fake_enqueue(self_, metric, subject_model, subject_ids, period_key, *, chun
             calls["count"] = len(subject_ids)
             return 1
 
-        with patch.object(OpensppMetricsService, "enqueue_refresh", _fake_enqueue):
+        with patch.object(OpensppIndicatorService, "enqueue_refresh", _fake_enqueue):
             metrics_info = []
             _ = (
                 self.env["cel.executor"]
@@ -195,7 +195,7 @@ def test_preflight_status_transitions(self):
         assert status_fresh["status"] == "fresh"
 
         # incomplete: remove one row
-        self.env["openspp.feature.value"].sudo().search(
+        self.env["openspp.indicator.value"].sudo().search(
             [
                 ("metric", "=", self.metric),
                 ("subject_id", "=", self.p_ko.id),
@@ -228,7 +228,7 @@ def test_small_cohort_sync_refresh(self):
         self._seed_cache([(self.p_ok.id, 82), (self.p_ko.id, 84)])
         cfg = {"root_model": "res.partner", "base_domain": [("email", "ilike", "fastpath@test.local")]}
         expr = f'metric("{self.metric}", me, "{self.period}") >= 80'
-        FV = self.env["openspp.feature.value"].sudo()
+        FV = self.env["openspp.indicator.value"].sudo()
         assert (
             FV.search_count(
                 [

spp_cel_domain/tests/test_provider_config_overrides.py

@@ -18,7 +18,7 @@ class _MiniHHProvider:
             def compute_batch(self, env, ctx, subject_ids):
                 return {int(s): 1 for s in subject_ids}
 
-        self.env["openspp.metric.registry"].register(
+        self.env["openspp.indicator.registry"].register(
             name="test_household.size",
             handler=_MiniHHProvider(),
             return_type="number",
@@ -43,7 +43,7 @@ def compute_batch(self, env, ctx, subject_ids):
         svc.evaluate("test_household.size", "res.partner", [hh.id], "current", mode="refresh")
 
         # Validate expires_at is close (<< 1 minute), and company_id is set
-        row = self.env["openspp.feature.value"].search(
+        row = self.env["openspp.indicator.value"].search(
             [
                 ("metric", "=", "test_household.size"),
                 ("subject_model", "=", "res.partner"),