Add dummy example with CallableModel making callable models

Signed-off-by: Nijat Khanbabayev <nijat.khanbabayev@cubistsystematic.com>

Author: NeejWeej

ccflow/tests/evaluators/test_common.py

@@ -29,7 +29,7 @@
     combine_evaluators,
     get_dependency_graph,
 )
-from ccflow.tests.local_helpers import build_nested_graph_chain
+from ccflow.tests.local_helpers import build_meta_sensor_planner, build_nested_graph_chain
 
 from .util import CircularModel, MyDateCallable, MyDateRangeCallable, MyRaisingCallable, NodeModel, ResultModel
 
@@ -220,6 +220,22 @@ def test_logging_options_nested(self):
         self.assertIn("End evaluation of __call__", captured.records[2].getMessage())
         self.assertIn("time elapsed", captured.records[2].getMessage())
 
+    def test_meta_callable_logged_with_evaluator(self):
+        """Meta callables can spin up request-scoped specialists and still inherit evaluator instrumentation."""
+        SensorQuery, MetaSensorPlanner, captured = build_meta_sensor_planner()
+        evaluator = LoggingEvaluator(log_level=logging.INFO, verbose=False)
+        request = SensorQuery(sensor_type="pressure-valve", site="orbital-lab", window=4)
+        meta = MetaSensorPlanner(warm_start=2)
+        with FlowOptionsOverride(options=FlowOptions(evaluator=evaluator)):
+            with self.assertLogs(level=logging.INFO) as captured_logs:
+                result = meta(request)
+        self.assertEqual(result.value, "planner:orbital-lab:pressure-valve:6")
+        start_messages = [record.getMessage() for record in captured_logs.records if "Start evaluation" in record.getMessage()]
+        self.assertEqual(len(start_messages), 2)
+        self.assertTrue(any("MetaSensorPlanner" in msg for msg in start_messages))
+        specialist_name = captured["callable_cls"].__name__
+        self.assertTrue(any(specialist_name in msg for msg in start_messages))
+
 
 class SubContext(DateContext):
     pass

ccflow/tests/local_helpers.py

@@ -1,10 +1,54 @@
 """Shared helpers for constructing local-scope contexts/models in tests."""
 
-from typing import ClassVar, Tuple, Type
+from typing import ClassVar, Dict, Tuple, Type
 
 from ccflow import CallableModel, ContextBase, Flow, GenericResult, GraphDepList, NullContext
 
 
+def build_meta_sensor_planner():
+    """Return a (SensorQuery, MetaSensorPlanner, captured) tuple for meta-callable tests."""
+
+    captured: Dict[str, Type] = {}
+
+    class SensorQuery(ContextBase):
+        sensor_type: str
+        site: str
+        window: int
+
+    class MetaSensorPlanner(CallableModel):
+        warm_start: int = 2
+
+        @Flow.call
+        def __call__(self, context: SensorQuery) -> GenericResult:
+            # Define request-scoped specialist wiring with a bespoke context/model pair.
+            class SpecialistContext(ContextBase):
+                sensor_type: str
+                window: int
+                pipeline: str
+
+            class SpecialistCallable(CallableModel):
+                pipeline: str
+
+                @Flow.call
+                def __call__(self, context: SpecialistContext) -> GenericResult:
+                    payload = f"{self.pipeline}:{context.sensor_type}:{context.window}"
+                    return GenericResult(value=payload)
+
+            captured["context_cls"] = SpecialistContext
+            captured["callable_cls"] = SpecialistCallable
+
+            window = context.window + self.warm_start
+            local_context = SpecialistContext(
+                sensor_type=context.sensor_type,
+                window=window,
+                pipeline=f"{context.site}-calibration",
+            )
+            specialist = SpecialistCallable(pipeline=f"planner:{context.site}")
+            return specialist(local_context)
+
+    return SensorQuery, MetaSensorPlanner, captured
+
+
 def build_local_callable(name: str = "LocalCallable") -> Type[CallableModel]:
     class _LocalCallable(CallableModel):
         @Flow.call

ccflow/tests/test_callable.py

@@ -23,7 +23,7 @@
     WrapperModel,
 )
 from ccflow.local_persistence import LOCAL_ARTIFACTS_MODULE_NAME
-from ccflow.tests.local_helpers import build_local_callable, build_local_context
+from ccflow.tests.local_helpers import build_local_callable, build_local_context, build_meta_sensor_planner
 
 
 def _find_registered_name(module, cls):
@@ -659,6 +659,21 @@ def __call__(self, context: LocalContext) -> GenericResult:
             else:
                 self.assertEqual(result.value, ctx_instance.value * (label + 1))
 
+    def test_meta_callable_builds_dynamic_specialist(self):
+        SensorQuery, MetaSensorPlanner, captured = build_meta_sensor_planner()
+        request = SensorQuery(sensor_type="wind-turbine", site="ridge-line", window=5)
+        meta = MetaSensorPlanner(warm_start=3)
+        result = meta(request)
+        self.assertEqual(result.value, "planner:ridge-line:wind-turbine:8")
+
+        locals_module = sys.modules[LOCAL_ARTIFACTS_MODULE_NAME]
+        SpecialistContext = captured["context_cls"]
+        SpecialistCallable = captured["callable_cls"]
+        self.assertEqual(SpecialistContext.__module__, LOCAL_ARTIFACTS_MODULE_NAME)
+        self.assertEqual(SpecialistCallable.__module__, LOCAL_ARTIFACTS_MODULE_NAME)
+        self.assertIs(getattr(locals_module, SpecialistContext.__qualname__), SpecialistContext)
+        self.assertIs(getattr(locals_module, SpecialistCallable.__qualname__), SpecialistCallable)
+
 
 class TestWrapperModel(TestCase):
     def test_wrapper(self):