refactor: extract FMU definition builder and simplify get_definition

docs/source/modelon.impact.client.experiment_definition.rst

@@ -44,6 +44,14 @@ modelon.impact.client.experiment\_definition.fmu\_based module
    :undoc-members:
    :show-inheritance:
 
+modelon.impact.client.experiment\_definition.from\_dict module
+--------------------------------------------------------------
+
+.. automodule:: modelon.impact.client.experiment_definition.from_dict
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
 modelon.impact.client.experiment\_definition.model\_based module
 ----------------------------------------------------------------
 

modelon/impact/client/entities/_initialize_from.py

@@ -10,11 +10,11 @@
     from modelon.impact.client.sal.service import Service
 
 
-def _resolve_initialize_from(
+def _resolve_extension_initialize_from(
     workspace_id: str,
     sal: Service,
     modifiers: Dict[str, Any],
-) -> Optional[Union[Case, Experiment, ExternalResult]]:
+) -> Optional[Union[Case, Experiment]]:
     if "initializeFrom" in modifiers:
         from modelon.impact.client.entities.experiment import Experiment
 
@@ -27,8 +27,16 @@ def _resolve_initialize_from(
         case_id = modifiers["initializeFromCase"]["caseId"]
         case_data = sal.experiment.case_get(workspace_id, exp_id, case_id)
         return Case(case_data["id"], workspace_id, exp_id, sal, case_data)
-    elif "initializeFromExternalResult" in modifiers:
+    return None
+
+
+def _resolve_initialize_from(
+    workspace_id: str,
+    sal: Service,
+    modifiers: Dict[str, Any],
+) -> Optional[Union[Case, Experiment, ExternalResult]]:
+    if "initializeFromExternalResult" in modifiers:
         return ExternalResult(
             result_id=modifiers["initializeFromExternalResult"], service=sal
         )
-    return None
+    return _resolve_extension_initialize_from(workspace_id, sal, modifiers)

modelon/impact/client/entities/experiment.py

@@ -6,32 +6,18 @@
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
-from modelon.impact.client.entities._initialize_from import _resolve_initialize_from
 from modelon.impact.client.entities.asserts import assert_variable_in_result
 from modelon.impact.client.entities.case import Case
 from modelon.impact.client.entities.custom_function import (
     CustomFunction,
     _build_custom_function,
 )
-from modelon.impact.client.entities.external_result import ExternalResult
 from modelon.impact.client.entities.interfaces.experiment import ExperimentReference
-from modelon.impact.client.entities.model import (
-    Model,
-    SimpleModelicaExperimentDefinition,
-    to_domain_parameter_value,
-)
-from modelon.impact.client.entities.model_executable import (
-    ModelExecutable,
-    SimpleFMUExperimentDefinition,
-)
 from modelon.impact.client.entities.status import ExperimentStatus
-from modelon.impact.client.experiment_definition.extension import (
-    SimpleExperimentExtension,
+from modelon.impact.client.experiment_definition.from_dict import (
+    ValidExperimentDefinitions,
+    _build_experiment_definition,
 )
-from modelon.impact.client.experiment_definition.model_based import (
-    _build_simple_modelica_experiment_definition,
-)
-from modelon.impact.client.experiment_definition.operators import get_operator_from_dict
 from modelon.impact.client.operations import experiment
 from modelon.impact.client.options import (
     CompilerOptions,
@@ -47,10 +33,6 @@
 logger = logging.getLogger(__name__)
 
 ScalarValue = Union[float, int, str]
-ValidExperimentDefinitions = Union[
-    SimpleModelicaExperimentDefinition,
-    SimpleFMUExperimentDefinition,
-]
 
 
 @enum.unique
@@ -613,35 +595,6 @@ def get_solver_options(self) -> SolverOptions:
         analysis = self._get_info()["experiment"]["base"]["analysis"]
         return SolverOptions(analysis.get("solverOptions", {}), self.custom_function)
 
-    def _get_initialize_from_case(self, experiment_id: str, case_id: str) -> Case:
-        case_data = self._sal.experiment.case_get(
-            self._workspace_id, experiment_id, case_id
-        )
-        return Case(
-            case_data["id"], self._workspace_id, experiment_id, self._sal, case_data
-        )
-
-    def _get_initialize_from_experiment(self, experiment_id: str) -> Experiment:
-        resp = self._sal.workspace.experiment_get(self._workspace_id, experiment_id)
-        return Experiment(self._workspace_id, resp["id"], self._sal, resp)
-
-    def _get_initialize_from(
-        self, modifiers: Dict[str, Any]
-    ) -> Optional[Union[Case, Experiment, ExternalResult]]:
-        return _resolve_initialize_from(self._workspace_id, self._sal, modifiers)
-
-    def _get_extension_initialize_from(
-        self, modifiers: Dict[str, Any]
-    ) -> Optional[Union[Case, Experiment]]:
-        if "initializeFrom" in modifiers:
-            exp_id = modifiers["initializeFrom"]
-            return self._get_initialize_from_experiment(exp_id)
-        elif "initializeFromCase" in modifiers:
-            case_id = modifiers["initializeFromCase"]["caseId"]
-            exp_id = modifiers["initializeFromCase"]["experimentId"]
-            return self._get_initialize_from_case(exp_id, case_id)
-        return None
-
     def get_definition(self) -> ValidExperimentDefinitions:
         """Get an experiment definition that can be used to reproduce this experiment
         result.
@@ -655,67 +608,11 @@ def get_definition(self) -> ValidExperimentDefinitions:
             definition = experiment.get_definition()
 
         """
-        base = self._get_info(cached=False)["experiment"]["base"]
-        analysis = base["analysis"]
-        custom_function = self._get_custom_function(analysis)
-        if self._get_workflow() == _Workflow.CLASS_BASED:
-            model = Model(
-                self.get_model_name(),
-                workspace_id=self._workspace_id,
-                project_id="",
-                service=self._sal,
-            )
-            definition = _build_simple_modelica_experiment_definition(
-                model, base, custom_function, self._workspace_id, self._sal
-            )
-        else:
-            fmu_id = base["model"]["fmu"]["id"]
-            definition = SimpleFMUExperimentDefinition(
-                fmu=ModelExecutable(self._workspace_id, fmu_id, self._sal),
-                custom_function=custom_function,
-                solver_options=self.get_solver_options(),
-                simulation_options=self.get_simulation_options(),
-                simulation_log_level=analysis["simulationLogLevel"],
-                initialize_from=self._get_initialize_from(base["modifiers"]),
-            )  # type: ignore
-            modifiers = {
-                mod["name"]: get_operator_from_dict(mod)
-                for mod in base["modifiers"]["variables"]
-            }
-            definition = definition.with_modifiers(modifiers=modifiers)
-        extensions = self._get_info()["experiment"].get("extensions")
-        if extensions:
-            sim_exts = []
-            for extension in extensions:
-                analysis = extension.get("analysis", {})
-                ext_custom_function_params = {
-                    param["name"]: param["value"]
-                    for param in analysis.get("parameters", [])
-                }
-                sim_ext = SimpleExperimentExtension(
-                    parameter_modifiers=ext_custom_function_params,
-                    solver_options=analysis.get("solverOptions"),
-                    simulation_options=analysis.get("simulationOptions"),
-                    simulation_log_level=analysis.get("simulationLogLevel"),
-                    initialize_from=self._get_extension_initialize_from(
-                        extension["modifiers"]
-                    )
-                    if extension.get("modifiers")
-                    else None,
-                )
-                ext_modifiers = {
-                    mod["name"]: to_domain_parameter_value(mod)
-                    for mod in extension.get("modifiers", {}).get("variables", [])
-                }
-                sim_ext = sim_ext.with_modifiers(modifiers=ext_modifiers)
-                case_data = extension.get("caseData", [])
-                case_labels = [data.get("label") for data in case_data]
-                if case_labels:
-                    case_label = case_labels[0]
-                    sim_ext = sim_ext.with_case_label(case_label)
-                sim_exts.append(sim_ext)
-            definition = definition.with_extensions(sim_exts)
-        return definition
+        info = self._get_info(cached=False)["experiment"]
+        custom_function = self._get_custom_function(info["base"]["analysis"])
+        return _build_experiment_definition(
+            info, custom_function, self._workspace_id, self._sal
+        )
 
     def _get_custom_function(self, analysis: Dict[str, Any]) -> CustomFunction:
         meta = self._sal.custom_function.custom_function_get(

modelon/impact/client/entities/model.py

@@ -13,9 +13,11 @@
 from modelon.impact.client.entities.interfaces.model import ModelInterface
 from modelon.impact.client.entities.model_executable import ModelExecutable
 from modelon.impact.client.entities.project import Project
+from modelon.impact.client.experiment_definition.from_dict import (
+    _build_experiment_definition,
+)
 from modelon.impact.client.experiment_definition.model_based import (
     SimpleModelicaExperimentDefinition,
-    _build_simple_modelica_experiment_definition,
 )
 from modelon.impact.client.experiment_definition.modifiers import Enumeration
 from modelon.impact.client.operations.fmu_import import FMUImportOperation
@@ -266,9 +268,16 @@ def get_experiment_definitions(
             custom_function = _build_custom_function(
                 self._workspace_id, cf_meta, self._sal
             ).with_parameters(**params)
-            definition = _build_simple_modelica_experiment_definition(
-                self, base, custom_function, self._workspace_id, self._sal
+            definition = _build_experiment_definition(
+                item["experiment"],
+                custom_function,
+                self._workspace_id,
+                self._sal,
+                model=self,
             )
+            # Experiment definitions are always defined for a model, the API
+            # never returns an FMU based definition here.
+            assert isinstance(definition, SimpleModelicaExperimentDefinition)
             meta = item["metadata"]
             entries.append(
                 ExperimentDefinitionEntry(

modelon/impact/client/experiment_definition/expansion.py

@@ -113,9 +113,9 @@ def get_parameters_as_dict(self) -> Optional[Dict[str, Any]]:
         return asdict(self)
 
 
-def expansion_from_dict(
-    algorithm: str, parameters: Dict[str, Any]
-) -> ExpansionAlgorithm:
+def expansion_from_dict(expansion_dict: Dict[str, Any]) -> ExpansionAlgorithm:
+    algorithm = expansion_dict.get("algorithm", "")
+    parameters = expansion_dict.get("parameters", {})
     if algorithm == "SOBOL":
         return Sobol(samples=parameters["samples"])
     elif algorithm == "LATINHYPERCUBE":