luminarycloud 0.19.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

luminarycloud/pipelines/core.py

@@ -88,48 +88,47 @@ class PipelineParameter(ABC):
 
 class PipelineInput:
     """
-    A named input for an Operator instance (i.e. a Task). Explicitly connected to a PipelineOutput.
+    A named input for a Stage. Explicitly connected to a PipelineOutput.
     """
 
-    def __init__(self, upstream_output: "PipelineOutput", owner: "Operator", name: str):
+    def __init__(self, upstream_output: "PipelineOutput", owner: "Stage", name: str):
         self.upstream_output = upstream_output
         self.owner = owner
         self.name = name
 
-    def _to_dict(self, id_for_task: dict) -> dict:
-        if self.upstream_output.owner not in id_for_task:
+    def _to_dict(self, id_for_stage: dict) -> dict:
+        if self.upstream_output.owner not in id_for_stage:
             raise ValueError(
-                f"Task {self.owner} depends on a task, {self.upstream_output.owner}, that isn't in the Pipeline. Did you forget to add it?"
+                f"Stage {self.owner} depends on a stage, {self.upstream_output.owner}, that isn't in the Pipeline. Did you forget to add it?"
             )
-        upstream_task_id = id_for_task[self.upstream_output.owner]
+        upstream_stage_id = id_for_stage[self.upstream_output.owner]
         upstream_output_name = self.upstream_output.name
-        return {self.name: f"{upstream_task_id}.{upstream_output_name}"}
+        return {self.name: f"{upstream_stage_id}.{upstream_output_name}"}
 
 
 class PipelineOutput(ABC):
     """
-    A named output for an Operator instance (i.e. a Task). Can be used to spawn any number of
-    connected PipelineInputs.
+    A named output for a Stage. Can be used to spawn any number of connected PipelineInputs.
     """
 
-    def __init__(self, owner: "Operator", name: str):
+    def __init__(self, owner: "Stage", name: str):
         self.owner = owner
         self.name = name
         self.downstream_inputs: list[PipelineInput] = []
 
-    def _spawn_input(self, owner: "Operator", name: str) -> PipelineInput:
+    def _spawn_input(self, owner: "Stage", name: str) -> PipelineInput:
         input = PipelineInput(self, owner, name)
         self.downstream_inputs.append(input)
         return input
 
 
-class OperatorInputs:
+class StageInputs:
     """
-    A collection of all PipelineInputs for an Operator instance (i.e. a Task).
+    A collection of all PipelineInputs for a Stage.
     """
 
     def __init__(
-        self, owner: "Operator", **input_descriptors: tuple[Type[PipelineOutput], PipelineOutput]
+        self, owner: "Stage", **input_descriptors: tuple[Type[PipelineOutput], PipelineOutput]
     ):
         """
         input_descriptors is a dict of input name -> (required_upstream_output_type, upstream_output)
@@ -144,26 +143,26 @@ class OperatorInputs:
                 )
             self.inputs.add(upstream_output._spawn_input(owner, name))
 
-    def _to_dict(self, id_for_task: dict) -> dict[str, str]:
+    def _to_dict(self, id_for_stage: dict) -> dict[str, str]:
         d: dict[str, str] = {}
         for input in self.inputs:
-            d |= input._to_dict(id_for_task)
+            d |= input._to_dict(id_for_stage)
         return d
 
 
-T = TypeVar("T", bound="OperatorOutputs")
+T = TypeVar("T", bound="StageOutputs")
 
 
-class OperatorOutputs(ABC):
+class StageOutputs(ABC):
     """
-    A collection of all PipelineOutputs for an Operator instance (i.e. a Task). Must be subclassed,
-    and the subclass must also be a dataclass whose fields are all PipelineOutput subclasses. Then
-    that subclass should be instantiated with `_instantiate_for`. Sounds a little complicated,
-    perhaps, but it's not bad. See the existing subclasses in `./operators.py` for examples.
+    A collection of all PipelineOutputs for a Stage. Must be subclassed, and the subclass must also
+    be a dataclass whose fields are all PipelineOutput subclasses. Then that subclass should be
+    instantiated with `_instantiate_for`. Sounds a little complicated, perhaps, but it's not bad.
+    See the existing subclasses in `./stages.py` for examples.
     """
 
     @classmethod
-    def _instantiate_for(cls: type[T], owner: "Operator") -> T:
+    def _instantiate_for(cls: type[T], owner: "Stage") -> T:
         # create an instance with all fields instantiated with the given owner, and named by the
         # field name.
         # Also validate here that we are a dataclass, and all our fields are PipelineOutput types.
@@ -188,41 +187,41 @@ class OperatorOutputs(ABC):
         return inputs
 
 
-class OperatorRegistry:
+class StageRegistry:
     def __init__(self):
-        self.operators = {}
+        self.stages = {}
 
-    def register(self, operator_class: Type["Operator"]) -> None:
-        self.operators[operator_class.__name__] = operator_class
+    def register(self, stage_class: Type["Stage"]) -> None:
+        self.stages[stage_class.__name__] = stage_class
 
-    def get(self, operator_name: str) -> Type["Operator"]:
-        if operator_name not in self.operators:
-            raise ValueError(f"Unknown operator: {operator_name}")
-        return self.operators[operator_name]
+    def get(self, stage_type_name: str) -> Type["Stage"]:
+        if stage_type_name not in self.stages:
+            raise ValueError(f"Unknown stage type: {stage_type_name}")
+        return self.stages[stage_type_name]
 
 
-TOutputs = TypeVar("TOutputs", bound=OperatorOutputs)
+TOutputs = TypeVar("TOutputs", bound=StageOutputs)
 
 
-class Operator(Generic[TOutputs], ABC):
+class Stage(Generic[TOutputs], ABC):
     def __init__(
         self,
-        task_name: str | None,
+        stage_name: str | None,
         params: dict,
-        inputs: OperatorInputs,
+        inputs: StageInputs,
         outputs: TOutputs,
     ):
-        self._operator_name = self.__class__.__name__
-        self._task_name = task_name if task_name is not None else self._operator_name
+        self._stage_type_name = self.__class__.__name__
+        self._name = stage_name if stage_name is not None else self._stage_type_name
         self._params = params
         self._inputs = inputs
         self.outputs = outputs
-        ensure_yamlizable(self._params_dict()[0], "Operator parameters")
+        ensure_yamlizable(self._params_dict()[0], "Stage parameters")
 
     def is_source(self) -> bool:
         return len(self._inputs.inputs) == 0
 
-    def inputs_dict(self) -> dict[str, tuple["Operator", str]]:
+    def inputs_dict(self) -> dict[str, tuple["Stage", str]]:
         inputs = {}
         for pipeline_input in self._inputs.inputs:
             inputs[pipeline_input.name] = (
@@ -231,16 +230,16 @@ class Operator(Generic[TOutputs], ABC):
             )
         return inputs
 
-    def downstream_tasks(self) -> list["Operator"]:
+    def downstream_stages(self) -> list["Stage"]:
         return [input.owner for input in self.outputs.downstream_inputs()]
 
-    def _to_dict(self, id_for_task: dict) -> tuple[dict, set[PipelineParameter]]:
+    def _to_dict(self, id_for_stage: dict) -> tuple[dict, set[PipelineParameter]]:
         params, pipeline_params_set = self._params_dict()
         d = {
-            "name": self._task_name,
-            "operator": self._operator_name,
+            "name": self._name,
+            "operator": self._stage_type_name,  # TODO: change key to "stage_type" when we're ready to bump the yaml schema version
             "params": params,
-            "inputs": self._inputs._to_dict(id_for_task),
+            "inputs": self._inputs._to_dict(id_for_stage),
         }
         return d, pipeline_params_set
 
@@ -250,70 +249,77 @@ class Operator(Generic[TOutputs], ABC):
         for name, value in self._params.items():
             if hasattr(value, "_to_pipeline_dict"):
                 d[name], downstream_params = value._to_pipeline_dict()
+                for param in downstream_params:
+                    if not isinstance(param, PipelineParameter):
+                        raise ValueError(
+                            f"Expected `_to_pipeline_dict()` to only return PipelineParameters, but got a {type(param)}: {param}"
+                        )
                 pipeline_params.update(downstream_params)
             else:
                 d[name] = value
+        # Strip None values. We treat absence of a param value in the YAML the same as a present null value.
+        d = {k: v for k, v in d.items() if v is not None}
         return d, pipeline_params
 
     def __str__(self) -> str:
-        return f'{self._operator_name}(name="{self._task_name}")'
+        return f'{self._stage_type_name}(name="{self._name}")'
 
-    _registry = OperatorRegistry()
+    _registry = StageRegistry()
 
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
-        Operator._registry.register(cls)
+        Stage._registry.register(cls)
 
     @classmethod
-    def _get_subclass(cls, operator_name: str) -> Type["Operator"]:
-        return cls._registry.get(operator_name)
+    def _get_subclass(cls, stage_type_name: str) -> Type["Stage"]:
+        return cls._registry.get(stage_type_name)
 
     @classmethod
     def _parse_params(cls, params: dict) -> dict:
-        # Operators with params that are just primitives or PipelineParams have no parsing to do.
-        # Operators with more complicated params should override this method.
+        # Stages with params that are just primitives or PipelineParams have no parsing to do.
+        # Stages with more complicated params should override this method.
         return params
 
 
 class Pipeline:
-    def __init__(self, tasks: list[Operator]):
-        self.tasks = tasks
-        self._task_ids = self._assign_ids_to_tasks()
+    def __init__(self, stages: list[Stage]):
+        self.stages = stages
+        self._stage_ids = self._assign_ids_to_stages()
 
     def to_yaml(self) -> str:
         return yaml.safe_dump(self._to_dict())
 
     def pipeline_params(self) -> set[PipelineParameter]:
-        return self._tasks_dict_and_params()[1]
+        return self._stages_dict_and_params()[1]
 
-    def _get_task_id(self, task: Operator) -> str:
-        return self._task_ids[task]
+    def _get_stage_id(self, stage: Stage) -> str:
+        return self._stage_ids[stage]
 
-    def _tasks_dict_and_params(self) -> tuple[dict, set[PipelineParameter]]:
-        id_for_task = self._task_ids
-        tasks = {}
+    def _stages_dict_and_params(self) -> tuple[dict, set[PipelineParameter]]:
+        id_for_stage = self._stage_ids
+        stages = {}
         params = set()
-        for task in id_for_task.keys():
-            task_dict, referenced_params = task._to_dict(id_for_task)
-            tasks[id_for_task[task]] = task_dict
+        for stage in id_for_stage.keys():
+            stage_dict, referenced_params = stage._to_dict(id_for_stage)
+            stages[id_for_stage[stage]] = stage_dict
             params.update(referenced_params)
-        return tasks, params
+        return stages, params
 
     def _to_dict(self) -> dict:
-        tasks, params = self._tasks_dict_and_params()
+        stages, params = self._stages_dict_and_params()
 
         d = {
             "lc_pipeline": {
                 "schema_version": 1,
                 "params": self._pipeline_params_dict(params),
-                "tasks": tasks,
+                "tasks": stages,  # TODO: change key to "stages" when we're ready to bump the yaml schema version
             }
         }
         ensure_yamlizable(d, "Pipeline")
         return d
 
-    def _assign_ids_to_tasks(self) -> dict[Operator, str]:
-        return {task: f"t{i + 1}-{task._operator_name}" for i, task in enumerate(self.tasks)}
+    def _assign_ids_to_stages(self) -> dict[Stage, str]:
+        return {stage: f"s{i + 1}-{stage._stage_type_name}" for i, stage in enumerate(self.stages)}
 
     def _pipeline_params_dict(self, params: set[PipelineParameter]) -> dict:
         d: dict[str, dict] = {}
@@ -334,7 +340,9 @@ class Pipeline:
         d = d["lc_pipeline"]
         if "schema_version" not in d:
             raise ValueError("Invalid pipeline YAML: missing 'schema_version' key")
-        if "tasks" not in d:
+        if (
+            "tasks" not in d
+        ):  # TODO: change key to "stages" when we're ready to bump the yaml schema version
             raise ValueError("Invalid pipeline YAML: missing 'tasks' key")
 
         if d["schema_version"] != 1:
@@ -347,18 +355,23 @@ class Pipeline:
                 param_name
             )
 
-        # ...and use them as replacements for any references in the tasks' parameters
-        for task_dict in d["tasks"].values():
-            task_dict["params"] = _recursive_replace_pipeline_params(
-                task_dict["params"], parsed_params
+        # ...and use them as replacements for any references in the stages' parameters
+        for stage_dict in d[
+            "tasks"
+        ].values():  # TODO: change key to "stages" when we're ready to bump the yaml schema version
+            stage_dict["params"] = _recursive_replace_pipeline_params(
+                stage_dict["params"], parsed_params
             )
 
-        # then, finish parsing the tasks
-        parsed_tasks = {}
-        for task_id in d["tasks"]:
-            _parse_task(d, task_id, parsed_tasks)
+        # then, finish parsing the stages
+        parsed_stages = {}
+        for stage_id in d["tasks"]:
+            _parse_stage(d, stage_id, parsed_stages)
 
-        return cls(list(parsed_tasks.values()))
+        pipe = cls(list(parsed_stages.values()))
+        # Preserve the stage IDs from the YAML definition by overwriting the auto-assigned ones
+        pipe._stage_ids = {stage: stage_id for stage_id, stage in parsed_stages.items()}
+        return pipe
 
 
 def _recursive_replace_pipeline_params(d: Any, parsed_params: dict) -> Any:
@@ -368,7 +381,7 @@ def _recursive_replace_pipeline_params(d: Any, parsed_params: dict) -> Any:
             pp_name = d["$pipeline_param"]
             if pp_name not in parsed_params:
                 raise ValueError(
-                    f'Pipeline parameter "{pp_name}" referenced in a pipeline task, but not found in pipeline\'s declared parameters'
+                    f'Pipeline parameter "{pp_name}" referenced in a pipeline stage, but not found in pipeline\'s declared parameters'
                 )
             return parsed_params[pp_name]
         else:
@@ -382,28 +395,32 @@ def _recursive_replace_pipeline_params(d: Any, parsed_params: dict) -> Any:
         return d
 
 
-def _parse_task(pipeline_dict: dict, task_id: str, all_tasks: dict[str, Operator]) -> Operator:
-    all_tasks_dict = pipeline_dict["tasks"]
-    if task_id in all_tasks:
-        return all_tasks[task_id]
-    task_dict = all_tasks_dict[task_id]
-    operator_name = task_dict["operator"]
-    operator_class = Operator._get_subclass(operator_name)
+def _parse_stage(pipeline_dict: dict, stage_id: str, all_stages: dict[str, Stage]) -> Stage:
+    all_stages_dict = pipeline_dict[
+        "tasks"
+    ]  # TODO: change key to "stages" when we're ready to bump the yaml schema version
+    if stage_id in all_stages:
+        return all_stages[stage_id]
+    stage_dict = all_stages_dict[stage_id]
+    stage_type_name = stage_dict[
+        "operator"
+    ]  # TODO: change key to "stage_type" when we're ready to bump the yaml schema version
+    stage_class = Stage._get_subclass(stage_type_name)
 
     parsed_inputs = {}
-    for input_name, input_value in task_dict["inputs"].items():
-        source_task_id, source_output_name = input_value.split(".")
-        source_task = _parse_task(pipeline_dict, source_task_id, all_tasks)
-        source_output = getattr(source_task.outputs, source_output_name)
+    for input_name, input_value in stage_dict["inputs"].items():
+        source_stage_id, source_output_name = input_value.split(".")
+        source_stage = _parse_stage(pipeline_dict, source_stage_id, all_stages)
+        source_output = getattr(source_stage.outputs, source_output_name)
         parsed_inputs[input_name] = source_output
 
-    parsed_params = operator_class._parse_params(task_dict["params"])
+    parsed_params = stage_class._parse_params(stage_dict["params"])
 
-    op_params = {
-        "task_name": task_dict["name"],
+    stage_params = {
+        "stage_name": stage_dict["name"],
         **parsed_params,
         **parsed_inputs,
     }
-    operator = operator_class(**op_params)
-    all_tasks[task_id] = operator
-    return operator
+    stage = stage_class(**stage_params)
+    all_stages[stage_id] = stage
+    return stage

luminarycloud/pipelines/{operators.py → stages.py}

@@ -1,8 +1,8 @@
 # Copyright 2025 Luminary Cloud, Inc. All Rights Reserved.
 from dataclasses import dataclass
 
-from .core import Operator, OperatorInputs, OperatorOutputs, PipelineOutput
-from .parameters import StringPipelineParameter
+from .core import Stage, StageInputs, StageOutputs, PipelineOutput
+from .parameters import StringPipelineParameter, IntPipelineParameter
 from ..meshing import MeshGenerationParams
 
 
@@ -27,11 +27,11 @@ class PipelineOutputSimulation(PipelineOutput):
     pass
 
 
-# Operators
+# Stages
 
 
 @dataclass
-class ReadGeometryOutputs(OperatorOutputs):
+class ReadGeometryOutputs(StageOutputs):
     geometry: PipelineOutputGeometry
     """
     The Geometry identified by the given `geometry_id`, in the state it was in when the Pipeline was
@@ -39,10 +39,12 @@ class ReadGeometryOutputs(OperatorOutputs):
     """
 
 
-class ReadGeometry(Operator[ReadGeometryOutputs]):
+class ReadGeometry(Stage[ReadGeometryOutputs]):
     """
     Reads a Geometry into the Pipeline.
 
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
     Parameters
     ----------
     geometry_id : str | StringPipelineParameter
@@ -52,35 +54,80 @@ class ReadGeometry(Operator[ReadGeometryOutputs]):
     -------
     geometry : PipelineOutputGeometry
         The latest GeometryVersion of the Geometry as of the moment the Pipeline was invoked.
-
-    .. warning:: This feature is experimental and may change or be removed in the future.
     """
 
     def __init__(
         self,
         *,
-        task_name: str | None = None,
+        stage_name: str | None = None,
         geometry_id: str | StringPipelineParameter,
     ):
         super().__init__(
-            task_name,
+            stage_name,
             {"geometry_id": geometry_id},
-            OperatorInputs(self),
+            StageInputs(self),
             ReadGeometryOutputs._instantiate_for(self),
         )
 
 
 @dataclass
-class ModifyGeometryOutputs(OperatorOutputs):
+class ReadMeshOutputs(StageOutputs):
+    mesh: PipelineOutputMesh
+    """
+    The Mesh read from the given `mesh_id`.
+    """
+
+
+class ReadMesh(Stage[ReadMeshOutputs]):
+    """
+    Reads a Mesh into the Pipeline.
+
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
+    Parameters
+    ----------
+    mesh_id : str | StringPipelineParameter
+        The ID of the Mesh to retrieve.
+    wait_timeout_seconds : int | IntPipelineParameter | None
+        The number of seconds to wait for the Mesh to be ready. If None, defaults to 1800 seconds
+        (30 minutes).
+
+    Outputs
+    -------
+    mesh : PipelineOutputMesh
+        The Mesh with the given `mesh_id`.
+    """
+
+    def __init__(
+        self,
+        *,
+        stage_name: str | None = None,
+        mesh_id: str | StringPipelineParameter,
+        wait_timeout_seconds: int | IntPipelineParameter | None = None,
+    ):
+        if wait_timeout_seconds is None:
+            wait_timeout_seconds = 30 * 60
+        super().__init__(
+            stage_name,
+            {"mesh_id": mesh_id, "wait_timeout_seconds": wait_timeout_seconds},
+            StageInputs(self),
+            ReadMeshOutputs._instantiate_for(self),
+        )
+
+
+@dataclass
+class ModifyGeometryOutputs(StageOutputs):
     geometry: PipelineOutputGeometry
     """The modified Geometry, represented as a new GeometryVersion."""
 
 
 # TODO: figure out what `mods` actually is. What does the non-pipeline geo mod interface look like?
-class ModifyGeometry(Operator[ModifyGeometryOutputs]):
+class ModifyGeometry(Stage[ModifyGeometryOutputs]):
     """
     Modifies a Geometry.
 
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
     Parameters
     ----------
     mods : dict
@@ -92,62 +139,66 @@ class ModifyGeometry(Operator[ModifyGeometryOutputs]):
     -------
     geometry : PipelineOutputGeometry
         The modified Geometry, represented as a new GeometryVersion.
-
-    .. warning:: This feature is experimental and may change or be removed in the future.
     """
 
     def __init__(
         self,
         *,
-        task_name: str | None = None,
+        stage_name: str | None = None,
         mods: list[dict],
         geometry: PipelineOutputGeometry,
     ):
         raise NotImplementedError("ModifyGeometry is not implemented yet.")
         super().__init__(
-            task_name,
+            stage_name,
             {"mods": mods},
-            OperatorInputs(self, geometry=(PipelineOutputGeometry, geometry)),
+            StageInputs(self, geometry=(PipelineOutputGeometry, geometry)),
             ModifyGeometryOutputs._instantiate_for(self),
         )
 
 
 @dataclass
-class MeshOutputs(OperatorOutputs):
+class MeshOutputs(StageOutputs):
     mesh: PipelineOutputMesh
     """The Mesh generated from the given Geometry."""
 
 
-class Mesh(Operator[MeshOutputs]):
+class Mesh(Stage[MeshOutputs]):
     """
     Generates a Mesh from a Geometry.
 
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
     Parameters
     ----------
-    target_cv_count : int | None
-        The target number of control volumes to generate. If None, a minimal mesh will be generated.
     geometry : PipelineOutputGeometry
         The Geometry to mesh.
+    mesh_name : str | StringPipelineParameter | None
+        The name to assign to the Mesh. If None, a default name will be used.
+    target_cv_count : int | None
+        The target number of control volumes to generate. If None, a minimal mesh will be generated.
 
     Outputs
     -------
     mesh : PipelineOutputMesh
         The generated Mesh.
-
-    .. warning:: This feature is experimental and may change or be removed in the future.
     """
 
     def __init__(
         self,
         *,
-        task_name: str | None = None,
-        target_cv_count: int | None,
+        stage_name: str | None = None,
         geometry: PipelineOutputGeometry,
+        mesh_name: str | StringPipelineParameter | None = None,
+        target_cv_count: int | IntPipelineParameter | None = None,
     ):
         super().__init__(
-            task_name,
-            {"target_cv_count": target_cv_count},
-            OperatorInputs(self, geometry=(PipelineOutputGeometry, geometry)),
+            stage_name,
+            {
+                "mesh_name": mesh_name,
+                "target_cv_count": target_cv_count,
+            },
+            StageInputs(self, geometry=(PipelineOutputGeometry, geometry)),
             MeshOutputs._instantiate_for(self),
         )
 
@@ -160,40 +211,46 @@ class Mesh(Operator[MeshOutputs]):
 
 
 @dataclass
-class SimulateOutputs(OperatorOutputs):
+class SimulateOutputs(StageOutputs):
     simulation: PipelineOutputSimulation
     """The Simulation."""
 
 
-class Simulate(Operator[SimulateOutputs]):
+class Simulate(Stage[SimulateOutputs]):
     """
     Runs a Simulation.
 
+    .. warning:: This feature is experimental and may change or be removed in the future.
+
     Parameters
     ----------
-    sim_template_id : str | StringPipelineParameter
-        The ID of the SimulationTemplate to use for the Simulation.
     mesh : PipelineOutputMesh
         The Mesh to use for the Simulation.
+    sim_name : str | StringPipelineParameter | None
+        The name to assign to the Simulation. If None, a default name will be used.
+    sim_template_id : str | StringPipelineParameter
+        The ID of the SimulationTemplate to use for the Simulation.
 
     Outputs
     -------
     simulation : PipelineOutputSimulation
         The Simulation.
-
-    .. warning:: This feature is experimental and may change or be removed in the future.
     """
 
     def __init__(
         self,
         *,
-        task_name: str | None = None,
-        sim_template_id: str | StringPipelineParameter,
+        stage_name: str | None = None,
         mesh: PipelineOutputMesh,
+        sim_name: str | StringPipelineParameter | None = None,
+        sim_template_id: str | StringPipelineParameter,
     ):
         super().__init__(
-            task_name,
-            {"sim_template_id": sim_template_id},
-            OperatorInputs(self, mesh=(PipelineOutputMesh, mesh)),
+            stage_name,
+            {
+                "sim_name": sim_name,
+                "sim_template_id": sim_template_id,
+            },
+            StageInputs(self, mesh=(PipelineOutputMesh, mesh)),
             SimulateOutputs._instantiate_for(self),
         )