zenml-nightly 0.70.0.dev20241128__py3-none-any.whl → 0.70.0.dev20241130__py3-none-any.whl

zenml/materializers/built_in_materializer.py

@@ -28,7 +28,7 @@ from typing import (
 )
 
 from zenml.artifact_stores.base_artifact_store import BaseArtifactStore
-from zenml.enums import ArtifactType
+from zenml.enums import ArtifactType, VisualizationType
 from zenml.logger import get_logger
 from zenml.materializers.base_materializer import BaseMaterializer
 from zenml.materializers.materializer_registry import materializer_registry
@@ -415,6 +415,23 @@ class BuiltInContainerMaterializer(BaseMaterializer):
                 self.artifact_store.rmtree(entry["path"])
             raise e
 
+    # save dict type objects to JSON file with JSON visualization type
+    def save_visualizations(self, data: Any) -> Dict[str, "VisualizationType"]:
+        """Save visualizations for the given data.
+
+        Args:
+            data: The data to save visualizations for.
+
+        Returns:
+            A dictionary of visualization URIs and their types.
+        """
+        # dict/list type objects are always saved as JSON files
+        # doesn't work for non-serializable types as they
+        # are saved as list of lists in different files
+        if _is_serializable(data):
+            return {self.data_path: VisualizationType.JSON}
+        return {}
+
     def extract_metadata(self, data: Any) -> Dict[str, "MetadataType"]:
         """Extract metadata from the given built-in container object.
 

zenml/materializers/structured_string_materializer.py

@@ -19,22 +19,23 @@ from typing import Dict, Type, Union
 from zenml.enums import ArtifactType, VisualizationType
 from zenml.logger import get_logger
 from zenml.materializers.base_materializer import BaseMaterializer
-from zenml.types import CSVString, HTMLString, MarkdownString
+from zenml.types import CSVString, HTMLString, JSONString, MarkdownString
 
 logger = get_logger(__name__)
 
 
-STRUCTURED_STRINGS = Union[CSVString, HTMLString, MarkdownString]
+STRUCTURED_STRINGS = Union[CSVString, HTMLString, MarkdownString, JSONString]
 
 HTML_FILENAME = "output.html"
 MARKDOWN_FILENAME = "output.md"
 CSV_FILENAME = "output.csv"
+JSON_FILENAME = "output.json"
 
 
 class StructuredStringMaterializer(BaseMaterializer):
     """Materializer for HTML or Markdown strings."""
 
-    ASSOCIATED_TYPES = (CSVString, HTMLString, MarkdownString)
+    ASSOCIATED_TYPES = (CSVString, HTMLString, MarkdownString, JSONString)
     ASSOCIATED_ARTIFACT_TYPE = ArtifactType.DATA_ANALYSIS
 
     def load(self, data_type: Type[STRUCTURED_STRINGS]) -> STRUCTURED_STRINGS:
@@ -94,6 +95,8 @@ class StructuredStringMaterializer(BaseMaterializer):
             filename = HTML_FILENAME
         elif issubclass(data_type, MarkdownString):
             filename = MARKDOWN_FILENAME
+        elif issubclass(data_type, JSONString):
+            filename = JSON_FILENAME
         else:
             raise ValueError(
                 f"Data type {data_type} is not supported by this materializer."
@@ -120,6 +123,8 @@ class StructuredStringMaterializer(BaseMaterializer):
             return VisualizationType.HTML
         elif issubclass(data_type, MarkdownString):
             return VisualizationType.MARKDOWN
+        elif issubclass(data_type, JSONString):
+            return VisualizationType.JSON
         else:
             raise ValueError(
                 f"Data type {data_type} is not supported by this materializer."

zenml/model/model.py

@@ -57,7 +57,9 @@ class Model(BaseModel):
     ethics: The ethical implications of the model.
     tags: Tags associated with the model.
     version: The version name, version number or stage is optional and points model context
-        to a specific version/stage. If skipped new version will be created.
+        to a specific version/stage. If skipped new version will be created. `version`
+        also supports placeholders: standard `{date}` and `{time}` and any custom placeholders
+        that are passed as substitutions in the pipeline or step decorators.
     save_models_to_registry: Whether to save all ModelArtifacts to Model Registry,
         if available in active stack.
     """
@@ -334,12 +336,16 @@ class Model(BaseModel):
             metadata: The metadata to log.
         """
         from zenml.client import Client
+        from zenml.models import RunMetadataResource
 
         response = self._get_or_create_model_version()
         Client().create_run_metadata(
             metadata=metadata,
-            resource_id=response.id,
-            resource_type=MetadataResourceTypes.MODEL_VERSION,
+            resources=[
+                RunMetadataResource(
+                    id=response.id, type=MetadataResourceTypes.MODEL_VERSION
+                )
+            ],
         )
 
     @property
@@ -534,6 +540,8 @@ class Model(BaseModel):
         from zenml.models import ModelRequest
 
         zenml_client = Client()
+        # backup logic, if the Model class is used directly from the code
+        self.name = format_name_template(self.name)
         if self.model_version_id:
             mv = zenml_client.get_model_version(
                 model_version_name_or_number_or_id=self.model_version_id,

zenml/model/utils.py

@@ -52,29 +52,31 @@ def log_model_metadata(
             `model` in decorator.
 
     Raises:
-        ValueError: If no model name/version is provided and the function is not
-            called inside a step with configured `model` in decorator.
+        ValueError: If the function is not called with proper input.
     """
     logger.warning(
         "The `log_model_metadata` function is deprecated and will soon be "
         "removed. Please use `log_metadata` instead."
     )
 
-    if model_name and model_version:
-        from zenml import Model
+    from zenml import log_metadata
 
-        mv = Model(name=model_name, version=model_version)
+    if model_name and model_version:
+        log_metadata(
+            metadata=metadata,
+            model_version=model_version,
+            model_name=model_name,
+        )
+    elif model_name is None and model_version is None:
+        log_metadata(
+            metadata=metadata,
+            infer_model=True,
+        )
     else:
-        try:
-            step_context = get_step_context()
-        except RuntimeError:
-            raise ValueError(
-                "Model name and version must be provided unless the function is "
-                "called inside a step with configured `model` in decorator."
-            )
-        mv = step_context.model
-
-    mv.log_metadata(metadata)
+        raise ValueError(
+            "You can call `log_model_metadata` by either providing both "
+            "`model_name` and `model_version` or keeping both of them None."
+        )
 
 
 def link_artifact_version_to_model_version(
@@ -107,7 +109,7 @@ def link_artifact_to_model(
         model: The model to link to.
 
     Raises:
-        RuntimeError: If called outside of a step.
+        RuntimeError: If called outside a step.
     """
     if not model:
         is_issue = False

zenml/models/__init__.py

@@ -372,6 +372,10 @@ from zenml.models.v2.misc.auth_models import (
     OAuthRedirectResponse,
     OAuthTokenResponse,
 )
+from zenml.models.v2.misc.run_metadata import (
+    RunMetadataEntry,
+    RunMetadataResource,
+)
 from zenml.models.v2.misc.server_models import (
     ServerModel,
     ServerDatabaseType,
@@ -752,4 +756,6 @@ __all__ = [
     "ServiceConnectorInfo",
     "ServiceConnectorResourcesInfo",
     "ResourcesInfo",
+    "RunMetadataEntry",
+    "RunMetadataResource",
 ]

zenml/models/v2/core/artifact_version.py

@@ -576,6 +576,7 @@ class ArtifactVersionFilter(WorkspaceScopedTaggableFilter):
             ModelVersionArtifactSchema,
             ModelVersionSchema,
             PipelineRunSchema,
+            RunMetadataResourceSchema,
             RunMetadataSchema,
             StepRunInputArtifactSchema,
             StepRunOutputArtifactSchema,
@@ -679,10 +680,12 @@ class ArtifactVersionFilter(WorkspaceScopedTaggableFilter):
 
             for key, value in self.run_metadata.items():
                 additional_filter = and_(
-                    RunMetadataSchema.resource_id == ArtifactVersionSchema.id,
-                    RunMetadataSchema.resource_type
+                    RunMetadataResourceSchema.resource_id
+                    == ArtifactVersionSchema.id,
+                    RunMetadataResourceSchema.resource_type
                     == MetadataResourceTypes.ARTIFACT_VERSION,
-                    RunMetadataSchema.key == key,
+                    RunMetadataResourceSchema.run_metadata_id
+                    == RunMetadataSchema.id,
                     self.generate_custom_query_conditions_for_column(
                         value=value,
                         table=RunMetadataSchema,

zenml/models/v2/core/component.py

@@ -81,11 +81,6 @@ class ComponentBase(BaseModel):
         title="The stack component labels.",
     )
 
-    component_spec_path: Optional[str] = Field(
-        default=None,
-        title="The path to the component spec used for mlstacks deployments.",
-    )
-
 
 # ------------------ Request Model ------------------
 
@@ -155,10 +150,6 @@ class ComponentUpdate(BaseUpdate):
         title="The stack component labels.",
         default=None,
     )
-    component_spec_path: Optional[str] = Field(
-        title="The path to the component spec used for mlstacks deployments.",
-        default=None,
-    )
     connector: Optional[UUID] = Field(
         title="The service connector linked to this stack component.",
         default=None,
@@ -201,10 +192,6 @@ class ComponentResponseMetadata(WorkspaceScopedResponseMetadata):
         default=None,
         title="The stack component labels.",
     )
-    component_spec_path: Optional[str] = Field(
-        default=None,
-        title="The path to the component spec used for mlstacks deployments.",
-    )
     connector_resource_id: Optional[str] = Field(
         default=None,
         description="The ID of a specific resource instance to "
@@ -325,15 +312,6 @@ class ComponentResponse(
         """
         return self.get_metadata().labels
 
-    @property
-    def component_spec_path(self) -> Optional[str]:
-        """The `component_spec_path` property.
-
-        Returns:
-            the value of the property.
-        """
-        return self.get_metadata().component_spec_path
-
     @property
     def connector_resource_id(self) -> Optional[str]:
         """The `connector_resource_id` property.

zenml/models/v2/core/model_version.py

@@ -652,6 +652,7 @@ class ModelVersionFilter(WorkspaceScopedTaggableFilter):
 
         from zenml.zen_stores.schemas import (
             ModelVersionSchema,
+            RunMetadataResourceSchema,
             RunMetadataSchema,
             UserSchema,
         )
@@ -672,10 +673,12 @@ class ModelVersionFilter(WorkspaceScopedTaggableFilter):
 
             for key, value in self.run_metadata.items():
                 additional_filter = and_(
-                    RunMetadataSchema.resource_id == ModelVersionSchema.id,
-                    RunMetadataSchema.resource_type
+                    RunMetadataResourceSchema.resource_id
+                    == ModelVersionSchema.id,
+                    RunMetadataResourceSchema.resource_type
                     == MetadataResourceTypes.MODEL_VERSION,
-                    RunMetadataSchema.key == key,
+                    RunMetadataResourceSchema.run_metadata_id
+                    == RunMetadataSchema.id,
                     self.generate_custom_query_conditions_for_column(
                         value=value,
                         table=RunMetadataSchema,

zenml/models/v2/core/pipeline_run.py

@@ -237,6 +237,10 @@ class PipelineRunResponseMetadata(WorkspaceScopedResponseMetadata):
         default=False,
         description="Whether a template can be created from this run.",
     )
+    step_substitutions: Dict[str, Dict[str, str]] = Field(
+        title="Substitutions used in the step runs of this pipeline run.",
+        default_factory=dict,
+    )
 
 
 class PipelineRunResponseResources(WorkspaceScopedResponseResources):
@@ -546,6 +550,15 @@ class PipelineRunResponse(
         """
         return self.get_metadata().is_templatable
 
+    @property
+    def step_substitutions(self) -> Dict[str, Dict[str, str]]:
+        """The `step_substitutions` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_metadata().step_substitutions
+
     @property
     def model_version(self) -> Optional[ModelVersionResponse]:
         """The `model_version` property.
@@ -722,6 +735,7 @@ class PipelineRunFilter(WorkspaceScopedTaggableFilter):
             PipelineDeploymentSchema,
             PipelineRunSchema,
             PipelineSchema,
+            RunMetadataResourceSchema,
             RunMetadataSchema,
             ScheduleSchema,
             StackComponentSchema,
@@ -897,10 +911,12 @@ class PipelineRunFilter(WorkspaceScopedTaggableFilter):
 
             for key, value in self.run_metadata.items():
                 additional_filter = and_(
-                    RunMetadataSchema.resource_id == PipelineRunSchema.id,
-                    RunMetadataSchema.resource_type
+                    RunMetadataResourceSchema.resource_id
+                    == PipelineRunSchema.id,
+                    RunMetadataResourceSchema.resource_type
                     == MetadataResourceTypes.PIPELINE_RUN,
-                    RunMetadataSchema.key == key,
+                    RunMetadataResourceSchema.run_metadata_id
+                    == RunMetadataSchema.id,
                     self.generate_custom_query_conditions_for_column(
                         value=value,
                         table=RunMetadataSchema,

zenml/models/v2/core/run_metadata.py

@@ -13,16 +13,16 @@
 #  permissions and limitations under the License.
 """Models representing run metadata."""
 
-from typing import Dict, Optional
+from typing import Dict, List, Optional
 from uuid import UUID
 
-from pydantic import Field
+from pydantic import Field, model_validator
 
-from zenml.enums import MetadataResourceTypes
 from zenml.metadata.metadata_types import MetadataType, MetadataTypeEnum
 from zenml.models.v2.base.scoped import (
     WorkspaceScopedRequest,
 )
+from zenml.models.v2.misc.run_metadata import RunMetadataResource
 
 # ------------------ Request Model ------------------
 
@@ -30,14 +30,12 @@ from zenml.models.v2.base.scoped import (
 class RunMetadataRequest(WorkspaceScopedRequest):
     """Request model for run metadata."""
 
-    resource_id: UUID = Field(
-        title="The ID of the resource that this metadata belongs to.",
-    )
-    resource_type: MetadataResourceTypes = Field(
-        title="The type of the resource that this metadata belongs to.",
+    resources: List[RunMetadataResource] = Field(
+        title="The list of resources that this metadata belongs to."
     )
     stack_component_id: Optional[UUID] = Field(
-        title="The ID of the stack component that this metadata belongs to."
+        title="The ID of the stack component that this metadata belongs to.",
+        default=None,
     )
     values: Dict[str, "MetadataType"] = Field(
         title="The metadata to be created.",
@@ -45,3 +43,26 @@ class RunMetadataRequest(WorkspaceScopedRequest):
     types: Dict[str, "MetadataTypeEnum"] = Field(
         title="The types of the metadata to be created.",
     )
+    publisher_step_id: Optional[UUID] = Field(
+        title="The ID of the step execution that published this metadata.",
+        default=None,
+    )
+
+    @model_validator(mode="after")
+    def validate_values_keys(self) -> "RunMetadataRequest":
+        """Validates if the keys in the metadata are properly defined.
+
+        Returns:
+            self
+
+        Raises:
+            ValueError: if one of the key in the metadata contains `:`
+        """
+        invalid_keys = [key for key in self.values.keys() if ":" in key]
+        if invalid_keys:
+            raise ValueError(
+                "You can not use colons (`:`) in the key names when you "
+                "are creating metadata for your ZenML objects. Please change "
+                f"the following keys: {invalid_keys}"
+            )
+        return self

zenml/models/v2/core/step_run.py

@@ -142,7 +142,7 @@ class StepRunRequest(WorkspaceScopedRequest):
 class StepRunUpdate(BaseModel):
     """Update model for step runs."""
 
-    outputs: Dict[str, UUID] = Field(
+    outputs: Dict[str, List[UUID]] = Field(
         title="The IDs of the output artifact versions of the step run.",
         default={},
     )
@@ -594,6 +594,7 @@ class StepRunFilter(WorkspaceScopedFilter):
         from zenml.zen_stores.schemas import (
             ModelSchema,
             ModelVersionSchema,
+            RunMetadataResourceSchema,
             RunMetadataSchema,
             StepRunSchema,
         )
@@ -612,10 +613,11 @@ class StepRunFilter(WorkspaceScopedFilter):
 
             for key, value in self.run_metadata.items():
                 additional_filter = and_(
-                    RunMetadataSchema.resource_id == StepRunSchema.id,
-                    RunMetadataSchema.resource_type
+                    RunMetadataResourceSchema.resource_id == StepRunSchema.id,
+                    RunMetadataResourceSchema.resource_type
                     == MetadataResourceTypes.STEP_RUN,
-                    RunMetadataSchema.key == key,
+                    RunMetadataResourceSchema.run_metadata_id
+                    == RunMetadataSchema.id,
                     self.generate_custom_query_conditions_for_column(
                         value=value,
                         table=RunMetadataSchema,

zenml/models/v2/misc/run_metadata.py

@@ -0,0 +1,38 @@
+#  Copyright (c) ZenML GmbH 2024. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at:
+#
+#       https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+#  or implied. See the License for the specific language governing
+#  permissions and limitations under the License.
+"""Utility classes for modeling run metadata."""
+
+from datetime import datetime
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+from zenml.enums import MetadataResourceTypes
+from zenml.metadata.metadata_types import MetadataType
+
+
+class RunMetadataResource(BaseModel):
+    """Utility class to help identify resources to tag metadata to."""
+
+    id: UUID = Field(title="The ID of the resource.")
+    type: MetadataResourceTypes = Field(title="The type of the resource.")
+
+
+class RunMetadataEntry(BaseModel):
+    """Utility class to sort/list run metadata entries."""
+
+    value: MetadataType = Field(title="The value for the run metadata entry")
+    created: datetime = Field(
+        title="The timestamp when this resource was created."
+    )

zenml/orchestrators/input_utils.py

@@ -20,7 +20,7 @@ from zenml.client import Client
 from zenml.config.step_configurations import Step
 from zenml.enums import ArtifactSaveType, StepRunInputArtifactType
 from zenml.exceptions import InputResolutionError
-from zenml.utils import pagination_utils
+from zenml.utils import pagination_utils, string_utils
 
 if TYPE_CHECKING:
     from zenml.models import PipelineRunResponse
@@ -53,7 +53,8 @@ def resolve_step_inputs(
     current_run_steps = {
         run_step.name: run_step
         for run_step in pagination_utils.depaginate(
-            Client().list_run_steps, pipeline_run_id=pipeline_run.id
+            Client().list_run_steps,
+            pipeline_run_id=pipeline_run.id,
         )
     }
 
@@ -66,11 +67,23 @@ def resolve_step_inputs(
                 f"No step `{input_.step_name}` found in current run."
             )
 
+        # Try to get the substitutions from the pipeline run first, as we
+        # already have a hydrated version of that. In the unlikely case
+        # that the pipeline run is outdated, we fetch it from the step
+        # run instead which will costs us one hydration call.
+        substitutions = (
+            pipeline_run.step_substitutions.get(step_run.name)
+            or step_run.config.substitutions
+        )
+        output_name = string_utils.format_name_template(
+            input_.output_name, substitutions=substitutions
+        )
+
         try:
-            outputs = step_run.outputs[input_.output_name]
+            outputs = step_run.outputs[output_name]
         except KeyError:
             raise InputResolutionError(
-                f"No step output `{input_.output_name}` found for step "
+                f"No step output `{output_name}` found for step "
                 f"`{input_.step_name}`."
             )
 
@@ -83,12 +96,12 @@ def resolve_step_inputs(
             # This should never happen, there can only be a single regular step
             # output for a name
             raise InputResolutionError(
-                f"Too many step outputs for output `{input_.output_name}` of "
+                f"Too many step outputs for output `{output_name}` of "
                 f"step `{input_.step_name}`."
             )
         elif len(step_outputs) == 0:
             raise InputResolutionError(
-                f"No step output `{input_.output_name}` found for step "
+                f"No step output `{output_name}` found for step "
                 f"`{input_.step_name}`."
             )
 

zenml/orchestrators/publish_utils.py

@@ -21,6 +21,7 @@ from zenml.enums import ExecutionStatus, MetadataResourceTypes
 from zenml.models import (
     PipelineRunResponse,
     PipelineRunUpdate,
+    RunMetadataResource,
     StepRunResponse,
     StepRunUpdate,
 )
@@ -32,7 +33,7 @@ if TYPE_CHECKING:
 
 
 def publish_successful_step_run(
-    step_run_id: "UUID", output_artifact_ids: Dict[str, "UUID"]
+    step_run_id: "UUID", output_artifact_ids: Dict[str, List["UUID"]]
 ) -> "StepRunResponse":
     """Publishes a successful step run.
 
@@ -129,8 +130,11 @@ def publish_pipeline_run_metadata(
     for stack_component_id, metadata in pipeline_run_metadata.items():
         client.create_run_metadata(
             metadata=metadata,
-            resource_id=pipeline_run_id,
-            resource_type=MetadataResourceTypes.PIPELINE_RUN,
+            resources=[
+                RunMetadataResource(
+                    id=pipeline_run_id, type=MetadataResourceTypes.PIPELINE_RUN
+                )
+            ],
             stack_component_id=stack_component_id,
         )
 
@@ -150,7 +154,10 @@ def publish_step_run_metadata(
     for stack_component_id, metadata in step_run_metadata.items():
         client.create_run_metadata(
             metadata=metadata,
-            resource_id=step_run_id,
-            resource_type=MetadataResourceTypes.STEP_RUN,
+            resources=[
+                RunMetadataResource(
+                    id=step_run_id, type=MetadataResourceTypes.STEP_RUN
+                )
+            ],
             stack_component_id=stack_component_id,
         )

zenml/orchestrators/step_launcher.py

@@ -309,8 +309,12 @@ class StepLauncher:
             The created or existing pipeline run,
             and a boolean indicating whether the run was created or reused.
         """
-        run_name = orchestrator_utils.get_run_name(
-            run_name_template=self._deployment.run_name_template
+        start_time = datetime.utcnow()
+        run_name = string_utils.format_name_template(
+            name_template=self._deployment.run_name_template,
+            substitutions=self._deployment.pipeline_configuration._get_full_substitutions(
+                start_time
+            ),
         )
 
         logger.debug("Creating pipeline run %s", run_name)
@@ -329,7 +333,7 @@ class StepLauncher:
             ),
             status=ExecutionStatus.RUNNING,
             orchestrator_environment=get_run_environment_dict(),
-            start_time=datetime.utcnow(),
+            start_time=start_time,
             tags=self._deployment.pipeline_configuration.tags,
         )
         return client.zen_store.get_or_create_run(pipeline_run)

zenml/orchestrators/step_run_utils.py

@@ -309,6 +309,9 @@ def create_cached_step_runs(
         for invocation_id in cache_candidates:
             visited_invocations.add(invocation_id)
 
+            # Make sure the request factory has the most up to date pipeline
+            # run to avoid hydration calls
+            request_factory.pipeline_run = pipeline_run
             try:
                 step_run_request = request_factory.create_request(
                     invocation_id
@@ -354,13 +357,16 @@ def create_cached_step_runs(
 
 
 def get_or_create_model_version_for_pipeline_run(
-    model: "Model", pipeline_run: PipelineRunResponse
+    model: "Model",
+    pipeline_run: PipelineRunResponse,
+    substitutions: Dict[str, str],
 ) -> Tuple[ModelVersionResponse, bool]:
     """Get or create a model version as part of a pipeline run.
 
     Args:
         model: The model to get or create.
         pipeline_run: The pipeline run for which the model should be created.
+        substitutions: Substitutions to apply to the model version name.
 
     Returns:
         The model version and a boolean indicating whether it was newly created
@@ -374,12 +380,14 @@ def get_or_create_model_version_for_pipeline_run(
         return model._get_model_version(), False
     elif model.version:
         if isinstance(model.version, str):
-            start_time = pipeline_run.start_time or datetime.utcnow()
             model.version = string_utils.format_name_template(
                 model.version,
-                date=start_time.strftime("%Y_%m_%d"),
-                time=start_time.strftime("%H_%M_%S_%f"),
+                substitutions=substitutions,
             )
+        model.name = string_utils.format_name_template(
+            model.name,
+            substitutions=substitutions,
+        )
 
         return (
             model._get_or_create_model_version(),
@@ -460,7 +468,9 @@ def prepare_pipeline_run_model_version(
         model_version = pipeline_run.model_version
     elif config_model := pipeline_run.config.model:
         model_version, _ = get_or_create_model_version_for_pipeline_run(
-            model=config_model, pipeline_run=pipeline_run
+            model=config_model,
+            pipeline_run=pipeline_run,
+            substitutions=pipeline_run.config.substitutions,
         )
         pipeline_run = Client().zen_store.update_run(
             run_id=pipeline_run.id,
@@ -492,7 +502,9 @@ def prepare_step_run_model_version(
         model_version = step_run.model_version
     elif config_model := step_run.config.model:
         model_version, created = get_or_create_model_version_for_pipeline_run(
-            model=config_model, pipeline_run=pipeline_run
+            model=config_model,
+            pipeline_run=pipeline_run,
+            substitutions=step_run.config.substitutions,
         )
         step_run = Client().zen_store.update_run_step(
             step_run_id=step_run.id,