ado-trim 1.6.0__tar.gz

ado_trim-1.6.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: ado-trim
+Version: 1.6.0
+Summary: TRIM (Transfer Refined Iterative Modeling) builds an accurate predictive model from a small dataset by iteratively sampling a Discovery Space.
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: ado-core
+Requires-Dist: autogluon-tabular[catboost,xgboost]==1.5
+Requires-Dist: numpy
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: scikit-learn
+
+# ADO TRIM Operator
+
+`ado-trim` is an operator plugin for the
+[Accelerated Discovery Orchestrator (ADO)](https://github.com/IBM/ado),
+providing the Transfer Refined Iterative Modeling (TRIM) characterization
+operator.
+
+**TRIM** is designed to efficiently build a surrogate model of a complex system.
+It is ideal for scenarios where exploring a parameter space is time-consuming or
+expensive. TRIM intelligently samples just enough points to create a stable and
+accurate predictive model, saving significant time and resources.
+
+## How it Works
+
+The `TRIM` operator works in two main phases:
+
+1. **No-Priors Characterization**: If the system has not been measured before,
+   TRIM starts by sampling a small, representative set of points using a
+   space-filling algorithm to get a baseline understanding of the parameter
+   space.
+
+2. **Iterative Modeling**: This phase begins by using all currently available
+   data to train a single preliminary surrogate model. The feature importance
+   from this model is used to order for all remaining unmeasured points. TRIM
+   then enters a loop where it:
+   - Samples the next point and adds it to the dataset.
+   - Trains a model on the gathered data.
+   - Evaluates the expected improvement of a model trained on a larger dataset
+     by comparing the new model's performance against that of previous models.
+
+This loop continues until the improvement is below a threshold, at which point
+TRIM automatically stops. Finally, it trains one high-quality model on all
+collected data and saves it for your use. It also outputs a file containing the
+measured values and predictions for all points in your space.
+
+## Installation
+
+You can install the `TRIM` operator and its dependencies (including `ado-core`)
+directly from PyPI:
+
+```bash
+pip install ado-trim
+```
+
+## More Information
+
+To learn more about TRIM and explore the full capabilities of ADO, including
+detailed documentation, configuration guides, and additional examples, visit the
+official ADO website:
+
+- **TRIM Quickstart**: <https://ibm.github.io/ado/examples/trim/>
+- **Configuring TRIM**: <https://ibm.github.io/ado/operators/trim/>
+- **ADO Documentation**: <https://ibm.github.io/ado/>

ado_trim-1.6.0/README.md

@@ -0,0 +1,53 @@
+# ADO TRIM Operator
+
+`ado-trim` is an operator plugin for the
+[Accelerated Discovery Orchestrator (ADO)](https://github.com/IBM/ado),
+providing the Transfer Refined Iterative Modeling (TRIM) characterization
+operator.
+
+**TRIM** is designed to efficiently build a surrogate model of a complex system.
+It is ideal for scenarios where exploring a parameter space is time-consuming or
+expensive. TRIM intelligently samples just enough points to create a stable and
+accurate predictive model, saving significant time and resources.
+
+## How it Works
+
+The `TRIM` operator works in two main phases:
+
+1. **No-Priors Characterization**: If the system has not been measured before,
+   TRIM starts by sampling a small, representative set of points using a
+   space-filling algorithm to get a baseline understanding of the parameter
+   space.
+
+2. **Iterative Modeling**: This phase begins by using all currently available
+   data to train a single preliminary surrogate model. The feature importance
+   from this model is used to order for all remaining unmeasured points. TRIM
+   then enters a loop where it:
+   - Samples the next point and adds it to the dataset.
+   - Trains a model on the gathered data.
+   - Evaluates the expected improvement of a model trained on a larger dataset
+     by comparing the new model's performance against that of previous models.
+
+This loop continues until the improvement is below a threshold, at which point
+TRIM automatically stops. Finally, it trains one high-quality model on all
+collected data and saves it for your use. It also outputs a file containing the
+measured values and predictions for all points in your space.
+
+## Installation
+
+You can install the `TRIM` operator and its dependencies (including `ado-core`)
+directly from PyPI:
+
+```bash
+pip install ado-trim
+```
+
+## More Information
+
+To learn more about TRIM and explore the full capabilities of ADO, including
+detailed documentation, configuration guides, and additional examples, visit the
+official ADO website:
+
+- **TRIM Quickstart**: <https://ibm.github.io/ado/examples/trim/>
+- **Configuring TRIM**: <https://ibm.github.io/ado/operators/trim/>
+- **ADO Documentation**: <https://ibm.github.io/ado/>

ado_trim-1.6.0/ado_trim.egg-info/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: ado-trim
+Version: 1.6.0
+Summary: TRIM (Transfer Refined Iterative Modeling) builds an accurate predictive model from a small dataset by iteratively sampling a Discovery Space.
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: ado-core
+Requires-Dist: autogluon-tabular[catboost,xgboost]==1.5
+Requires-Dist: numpy
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: scikit-learn
+
+# ADO TRIM Operator
+
+`ado-trim` is an operator plugin for the
+[Accelerated Discovery Orchestrator (ADO)](https://github.com/IBM/ado),
+providing the Transfer Refined Iterative Modeling (TRIM) characterization
+operator.
+
+**TRIM** is designed to efficiently build a surrogate model of a complex system.
+It is ideal for scenarios where exploring a parameter space is time-consuming or
+expensive. TRIM intelligently samples just enough points to create a stable and
+accurate predictive model, saving significant time and resources.
+
+## How it Works
+
+The `TRIM` operator works in two main phases:
+
+1. **No-Priors Characterization**: If the system has not been measured before,
+   TRIM starts by sampling a small, representative set of points using a
+   space-filling algorithm to get a baseline understanding of the parameter
+   space.
+
+2. **Iterative Modeling**: This phase begins by using all currently available
+   data to train a single preliminary surrogate model. The feature importance
+   from this model is used to order for all remaining unmeasured points. TRIM
+   then enters a loop where it:
+   - Samples the next point and adds it to the dataset.
+   - Trains a model on the gathered data.
+   - Evaluates the expected improvement of a model trained on a larger dataset
+     by comparing the new model's performance against that of previous models.
+
+This loop continues until the improvement is below a threshold, at which point
+TRIM automatically stops. Finally, it trains one high-quality model on all
+collected data and saves it for your use. It also outputs a file containing the
+measured values and predictions for all points in your space.
+
+## Installation
+
+You can install the `TRIM` operator and its dependencies (including `ado-core`)
+directly from PyPI:
+
+```bash
+pip install ado-trim
+```
+
+## More Information
+
+To learn more about TRIM and explore the full capabilities of ADO, including
+detailed documentation, configuration guides, and additional examples, visit the
+official ADO website:
+
+- **TRIM Quickstart**: <https://ibm.github.io/ado/examples/trim/>
+- **Configuring TRIM**: <https://ibm.github.io/ado/operators/trim/>
+- **ADO Documentation**: <https://ibm.github.io/ado/>

ado_trim-1.6.0/ado_trim.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+README.md
+pyproject.toml
+ado_trim.egg-info/PKG-INFO
+ado_trim.egg-info/SOURCES.txt
+ado_trim.egg-info/dependency_links.txt
+ado_trim.egg-info/entry_points.txt
+ado_trim.egg-info/requires.txt
+ado_trim.egg-info/top_level.txt
+trim/__init__.py
+trim/no_priors_pydantic.py
+trim/no_priors_sampler.py
+trim/operator.py
+trim/trim_pydantic.py
+trim/trim_sampler.py
+trim/test/test_data_documentation.py
+trim/test/test_high_dimensional_sampling.py
+trim/test/test_rowsring.py
+trim/test/test_sampling.py
+trim/utils/__init__.py
+trim/utils/exceptions.py
+trim/utils/high_dimensional_sampling.py
+trim/utils/logging_utils.py
+trim/utils/miscellaneous.py
+trim/utils/one_dimensional_sampling.py
+trim/utils/order.py
+trim/utils/rowsring.py
+trim/utils/space_df_connector.py
+trim/utils/split_common_and_diff.py
+trim/utils/stopping_criterion.py

ado_trim-1.6.0/ado_trim.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ado_trim-1.6.0/ado_trim.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[ado.operators]
+trim = trim.operator

ado_trim-1.6.0/ado_trim.egg-info/requires.txt

@@ -0,0 +1,5 @@
+ado-core
+autogluon-tabular[catboost,xgboost]==1.5
+numpy
+pandas>=2.2.0
+scikit-learn

ado_trim-1.6.0/ado_trim.egg-info/top_level.txt

@@ -0,0 +1 @@
+trim

ado_trim-1.6.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "ado-trim"
+description = "TRIM (Transfer Refined Iterative Modeling) builds an accurate predictive model from a small dataset by iteratively sampling a Discovery Space."
+readme = "README.md"
+requires-python = ">=3.10,<3.14"
+dependencies = [
+  "ado-core",
+  "autogluon-tabular[catboost,xgboost]==1.5",
+  "numpy",
+  "pandas>=2.2.0",
+  "scikit-learn",
+]
+dynamic = ["version"]
+
+[project.entry-points."ado.operators"]
+trim = "trim.operator"
+
+[build-system]
+requires = ["setuptools", "setuptools_scm"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["trim"]
+
+[tool.setuptools_scm]
+root = "../../../"
+
+[tool.uv.sources]
+ado-core = { workspace = true }

ado_trim-1.6.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ado_trim-1.6.0/trim/__init__.py

@@ -0,0 +1,2 @@
+# Copyright IBM Corporation 2025, 2026
+# SPDX-License-Identifier: MIT

ado_trim-1.6.0/trim/no_priors_pydantic.py

@@ -0,0 +1,72 @@
+# Copyright IBM Corporation 2025, 2026
+# SPDX-License-Identifier: MIT
+
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, BeforeValidator, Field
+
+
+class NoPriorsParameters(BaseModel):
+    """
+    Parameters for sampling high-dimensional spaces without prior model structure.
+
+    The `sampling_strategy` must be one of the Literals supported.
+    Source of truth for supported strategies is the comment block right here:
+
+        strategy (str): sampling subroutine:
+        - 'random': selects random points from the beginning
+        - 'one_shift': refer to one_shift_then_random_points_high_dimensional_sampling
+        - 'recursive_aggregation': refer to recursive_aggregation_high_dimensional_sampling
+        - 'clhs': refer to concatenated_latin_hypercube_sampling
+        - 'sobol': sobol sampling
+    """
+
+    targetOutput: Annotated[
+        str,
+        Field(
+            description="The measured property you will treat as a target variable.",
+        ),
+    ]
+
+    samples: Annotated[
+        int,
+        Field(
+            ge=1,
+            description="Number of unique points to sample (must be >= 1).",
+        ),
+    ] = 20
+
+    batchSize: Annotated[
+        int,
+        Field(
+            ge=1,
+            description=(
+                "Batch size parameter used by certain samplers (e.g., randomWalk) via continuous batching; "
+                "by default set equal to iterationSize in those contexts. Must be >= 1."
+            ),
+        ),
+    ] = 1
+
+    sampling_strategy: Annotated[
+        Literal["random", "one_shift", "recursive_aggregation", "clhs", "sobol"],
+        BeforeValidator(lambda s: s.lower()),
+        Field(
+            description=(
+                "Sampling subroutine. Supported values:\n"
+                " - 'random': selects random points from the beginning\n"
+                " - 'one_shift': see one_shift_then_random_points_high_dimensional_sampling\n"
+                " - 'recursive_aggregation': see recursive_aggregation_high_dimensional_sampling\n"
+                " - 'clhs': dimension-wise random without replacement until each dim cycles\n"
+                " - 'sobol': sobol sampling via scipy\n"
+                "Aliases: 'random_shifts' → 'recursive_aggregation'.\n"
+                "Validation is case-insensitive; value is normalized to lowercase."
+            ),
+        ),
+    ] = "clhs"
+
+
+if __name__ == "__main__":
+    params = NoPriorsParameters.model_validate(NoPriorsParameters(targetOutput="test"))
+    print(
+        f"type of model_validate output on no-priors-characterization default is {type(params)}, printing the full object gives {params}"
+    )

ado_trim-1.6.0/trim/no_priors_sampler.py

@@ -0,0 +1,132 @@
+# Copyright IBM Corporation 2025, 2026
+# SPDX-License-Identifier: MIT
+
+import asyncio
+import logging
+import typing
+
+from pydantic import BaseModel
+
+from orchestrator.core.discoveryspace.samplers import BaseSampler
+from orchestrator.core.discoveryspace.space import DiscoverySpace, Entity
+from orchestrator.modules.operators.discovery_space_manager import DiscoverySpaceManager
+from trim.no_priors_pydantic import NoPriorsParameters
+from trim.utils.order import order_df_for_sampling_with_no_priors
+from trim.utils.space_df_connector import (
+    get_list_of_entities_from_df_and_space,
+    get_source_and_target,
+)
+
+logger_no_priors = logging.getLogger(__name__)
+
+
+# NOTE: to repeat the operation on the same space I can delete the operation if the output of this operation
+# are not used by another operation
+class NoPriorsSampleSelector(BaseSampler):
+    @classmethod
+    def samplerCompatibleWithDiscoverySpaceRemote(
+        cls, remoteDiscoverySpace: DiscoverySpaceManager  # type: ignore[name-defined]
+    ) -> bool:
+        return True
+
+    async def remoteEntityIterator(
+        self, remoteDiscoverySpace: DiscoverySpaceManager, batchsize: int = 1
+    ) -> typing.AsyncGenerator[list[Entity], None]:
+        """
+        Generate entities for no-priors characterization sampling.
+
+        Orders the target space using a high-dimensional sampling strategy (e.g., CLHS, Sobol)
+        without relying on prior model knowledge or feature importance.
+
+        Args:
+            remoteDiscoverySpace: Manager for the discovery space state
+            batchsize: Number of entities to yield per iteration
+
+        Yields:
+            List of Entity objects to be measured, in the determined order
+        """
+
+        async def iterator_closure(
+            stateHandle: DiscoverySpaceManager,  # type: ignore[name-defined]
+        ) -> typing.Callable[[], typing.AsyncGenerator[list[Entity], None]]:
+
+            logger_no_priors.info("Characterization with no-priors starts.\n")
+            logger_no_priors.info(f"PARAMETERS ARE:\n{self.params}\n\n")
+
+            discoverySpace = await stateHandle.discoverySpace.remote()
+            source_df, target_df = get_source_and_target(
+                discoverySpace, self.params.targetOutput
+            )
+            logger_no_priors.info(f"Target dataframe has length {len(target_df)}")
+            target_df = order_df_for_sampling_with_no_priors(
+                target_df,
+                [
+                    cp.identifier
+                    for cp in discoverySpace.entitySpace.constitutiveProperties
+                ],
+                self.params.samples - len(source_df),
+                strategy=self.params.sampling_strategy,
+            )
+            list_of_entities_for_no_prior_characterization = (
+                get_list_of_entities_from_df_and_space(
+                    df=target_df, space=discoverySpace
+                )
+            )
+
+            logger_no_priors.info(
+                "\n\nCharacterization with no-priors finished. Starting Iterative Modeling.\n"
+            )
+
+            async def iterator() -> typing.AsyncGenerator[list[Entity], None]:  # type: ignore[name-defined]
+                logger_no_priors.info(
+                    "\n\nIteration over sorted entities for no priors characterization starts.\n"
+                )
+                await asyncio.sleep(0.1)
+                for i in range(
+                    0, len(list_of_entities_for_no_prior_characterization), batchsize
+                ):
+                    entities = list_of_entities_for_no_prior_characterization[
+                        i : i + batchsize
+                    ]
+                    if len(entities) == 0:
+                        logger_no_priors.info(
+                            "\n\nCharacterization with no-priors finished.\n"
+                        )
+                        break
+                    else:
+                        yield entities
+                logger_no_priors.info("\n\nCharacterization with no-priors finished.\n")
+
+            return iterator
+
+        retval = await iterator_closure(remoteDiscoverySpace)
+
+        return retval()
+
+    def entityIterator(
+        self, discoverySpace: DiscoverySpace, batchsize: int = 1
+    ) -> typing.Generator[list[Entity], None, None]:
+        """Returns an remoteEntityIterator that returns entities in order"""
+
+        def iterator_closure(
+            space: DiscoverySpace,
+        ) -> typing.Callable[[], typing.Generator[list[Entity], None, None]]:
+
+            # list_of_entities = list(...)  # type: ignore[name-defined]
+            # numberEntities = len(list_of_entities)
+
+            def iterator() -> typing.Generator[list[Entity], None, None]:  # type: ignore[name-defined]
+                raise NotImplementedError
+                # ...for i in range(0, numberEntities, batchsize):
+
+            return iterator
+
+        retval = iterator_closure(discoverySpace)
+        return retval()
+
+    @classmethod
+    def parameters_model(cls) -> type[BaseModel] | None:
+        return NoPriorsParameters
+
+    def __init__(self, parameters: NoPriorsParameters) -> None:
+        self.params = parameters

ado_trim-1.6.0/trim/operator.py

@@ -0,0 +1,189 @@
+# Copyright IBM Corporation 2025, 2026
+# SPDX-License-Identifier: MIT
+
+
+import logging
+
+from orchestrator.core.discoveryspace.space import DiscoverySpace
+from orchestrator.core.operation.config import FunctionOperationInfo
+from orchestrator.core.operation.operation import OperationOutput
+from orchestrator.modules.operators.collections import characterize_operation
+from trim.trim_pydantic import (
+    TrimParameters,
+)  # Importing this way works when the package is installed
+from trim.utils.logging_utils import (
+    log_and_save_characterization,
+    log_unable_to_proceed_with_iterative_modeling_and_raise_error,
+)
+from trim.utils.space_df_connector import get_source_and_target
+
+logger_trim = logging.getLogger(__name__)
+
+
+@characterize_operation(
+    name="trim",
+    configuration_model=TrimParameters,
+    configuration_model_default=TrimParameters.defaultOperationParameters(),
+    description="""
+                Trim is used to characterise a Discovery space.
+                In its first implementation it starts from a space,
+                Retrieves all measured entities from the entity source and samples the others following a certain order.
+                If the number of measured entity is too small, Trim instantiates a no-priors characterization operation.
+                """,
+)
+def trim(
+    discoverySpace: DiscoverySpace = None,  # type: ignore[name-defined]
+    operationInfo: FunctionOperationInfo | None = None,
+    **kwargs: object,
+) -> OperationOutput:
+    """
+    Execute the TRIM (Transfer Refined Iterative Modeling) operation on a discovery space.
+
+    TRIM characterizes a discovery space by first ensuring sufficient measured entities exist,
+    then performing iterative modeling to sample additional entities in an informed order.
+    If insufficient data exists, it runs a no-priors characterization first.
+
+    Args:
+        discoverySpace: The discovery space to characterize
+        operationInfo: Optional operation metadata
+        **kwargs: Additional parameters validated against TrimParameters model
+
+    Returns:
+        OperationOutput containing the operation resources and metadata
+    """
+    # Lazy import to avoid circular import issues during plugin loading
+    from orchestrator.modules.operators.randomwalk import (
+        CustomSamplerConfiguration,
+        RandomWalkParameters,
+        SamplerModuleConf,
+        random_walk,
+    )
+
+    params = TrimParameters.model_validate(kwargs)
+    logger_trim.info(
+        "Transfer Refined Iterative Modeling starts."
+        f"Target variable = {params.targetOutput}"
+    )
+    logger_trim.info(f"Parameters are {params}")
+
+    nopriors_module = SamplerModuleConf(
+        moduleClass="NoPriorsSampleSelector", moduleName="trim.no_priors_sampler"
+    )
+
+    # Checks if the source space has been already characterized appropriately
+    source_df, target_df = get_source_and_target(
+        discoverySpace, params.targetOutput, log_string="First query"
+    )
+    initial_source_space_size = len(source_df)
+
+    op_output_characterization_no_prior = OperationOutput.model_validate(
+        {
+            "metadata": {
+                "skipping operation": f"Prior source space characterization: {len(source_df)} sample. Minimal sample size: {params.samplingBudget.minPoints }"
+            }
+        }
+    )
+
+    if logger_trim.isEnabledFor(logging.DEBUG):
+        log_and_save_characterization(source_df, target_df)
+
+    if len(source_df) < params.samplingBudget.minPoints:
+        logger_trim.warning(
+            f"Only {len(source_df)} points in the source space.\n"
+            "Starting with no-prior characterization operation, "
+            f"it will sample {params.samplingBudget.minPoints - len(source_df)} points.\n"
+            f"Note: Trim sampler has been called with a minimum budget of {params.samplingBudget.minPoints} points."
+        )
+
+        no_priors_params = params.noPriorParameters
+        no_priors_sampler_config = CustomSamplerConfiguration(
+            module=nopriors_module, parameters=no_priors_params
+        )
+
+        no_priors_rwparams = RandomWalkParameters(
+            samplerConfig=no_priors_sampler_config,
+            # here you set up the rw params
+            batchSize=no_priors_params.batchSize,
+            numberEntities=no_priors_params.samples,
+            singleMeasurement=True,
+        )
+
+        op_output_characterization_no_prior = random_walk(
+            discoverySpace=discoverySpace,
+            operationInfo=FunctionOperationInfo.model_validate(
+                {
+                    "metadata": {
+                        "completed operation": "Characterization with no priors",
+                        "summary of collected data": f"No-priors characterization produced {len(source_df)} samples with the required property {params.targetOutput}. Minimal sample size: {params.samplingBudget.minPoints }",
+                    },
+                    "actuatorConfigurationIdentifiers": operationInfo.actuatorConfigurationIdentifiers,
+                }
+            ),
+            **no_priors_rwparams.model_dump(),
+        )
+
+        source_df, target_df = get_source_and_target(
+            discoverySpace, params.targetOutput
+        )
+
+        if logger_trim.isEnabledFor(logging.DEBUG):
+            logger_trim.debug(
+                "Saving updated source space after no-priors characterization"
+            )
+            log_and_save_characterization(source_df, target_df)
+
+        if len(source_df) < params.samplingBudget.minPoints:
+            log_unable_to_proceed_with_iterative_modeling_and_raise_error(
+                discoverySpace,
+                target_output=params.targetOutput,
+                additional_info=f"This was detected during the no-priors characterization phase: {params.samplingBudget.minPoints - len(source_df)} out of {params.samplingBudget.minPoints}.",
+            )
+
+    # TRIM Iterative Modeling
+    trim_module = SamplerModuleConf(
+        moduleClass="TrimSampleSelector",  # this is the name of our custom sampler class -> which I guess is CustomSequentialSampleSelector
+        moduleName="trim.trim_sampler",  ### If CustomSequentialSampleSelector is imported as "from trim.trim_sampler import TrimSampleSelector" then this is correct
+    )
+    trim_sampler_config = CustomSamplerConfiguration(
+        module=trim_module, parameters=params
+    )
+    numberEntities_iterative_modeling = (
+        len(source_df) - initial_source_space_size
+        if op_output_characterization_no_prior.operation
+        else params.samplingBudget.maxPoints
+    )
+    trim_rwparams = RandomWalkParameters(
+        samplerConfig=trim_sampler_config,
+        batchSize=1,
+        numberEntities=numberEntities_iterative_modeling,
+        singleMeasurement=True,
+    )
+
+    op_output_iterative_modeling = random_walk(
+        discoverySpace=discoverySpace,
+        operationInfo=FunctionOperationInfo.model_validate(
+            {
+                "metadata": {"completed operation": "Iterative Modeling Operation"},
+                "actuatorConfigurationIdentifiers": operationInfo.actuatorConfigurationIdentifiers,
+            }
+        ),
+        **trim_rwparams.model_dump(),
+    )
+
+    logger_trim.info(
+        f"op_output_iterative_modeling.operation = {op_output_iterative_modeling.operation} "
+    )
+
+    if op_output_characterization_no_prior.operation:
+        return OperationOutput(
+            other=[],
+            resources=[
+                op_output_characterization_no_prior.operation,
+                op_output_iterative_modeling.operation,
+            ],
+            metadata={},
+        )
+
+    return OperationOutput(
+        other=[], resources=[op_output_iterative_modeling.operation], metadata={}
+    )