zenml-nightly 0.54.1.dev20240118__py3-none-any.whl → 0.54.1.dev20240120__py3-none-any.whl

zenml/new/steps/step_context.py

@@ -32,7 +32,7 @@ if TYPE_CHECKING:
     from zenml.config.step_run_info import StepRunInfo
     from zenml.materializers.base_materializer import BaseMaterializer
     from zenml.metadata.metadata_types import MetadataType
-    from zenml.model.model_version import ModelVersion
+    from zenml.model.model import Model
     from zenml.models import (
         ArtifactVersionResponse,
         PipelineResponse,
@@ -163,33 +163,33 @@ class StepContext(metaclass=SingletonMetaClass):
         )
 
     @property
-    def model_version(self) -> "ModelVersion":
-        """Returns configured ModelVersion.
+    def model(self) -> "Model":
+        """Returns configured Model.
 
-        Order of resolution to search for ModelVersion is:
-            1. ModelVersion from @step
-            2. ModelVersion from @pipeline
+        Order of resolution to search for Model is:
+            1. Model from @step
+            2. Model from @pipeline
 
         Returns:
-            The `ModelVersion` object associated with the current step.
+            The `Model` object associated with the current step.
 
         Raises:
-            StepContextError: If the `ModelVersion` object is not set in `@step` or `@pipeline`.
+            StepContextError: If the `Model` object is not set in `@step` or `@pipeline`.
         """
-        if self.step_run.config.model_version is not None:
-            model_version = self.step_run.config.model_version
-        elif self.pipeline_run.config.model_version is not None:
-            model_version = self.pipeline_run.config.model_version
+        if self.step_run.config.model is not None:
+            model = self.step_run.config.model
+        elif self.pipeline_run.config.model is not None:
+            model = self.pipeline_run.config.model
         else:
             raise StepContextError(
-                f"Unable to get ModelVersion in step '{self.step_name}' of pipeline "
+                f"Unable to get Model in step '{self.step_name}' of pipeline "
                 f"run '{self.pipeline_run.id}': it was not set in `@step` or `@pipeline`."
             )
 
         # warm-up the model version
-        model_version._get_or_create_model_version()
+        model._get_or_create_model_version()
 
-        return model_version
+        return model
 
     @property
     def inputs(self) -> Dict[str, "ArtifactVersionResponse"]:

zenml/new/steps/step_decorator.py

@@ -33,7 +33,7 @@ if TYPE_CHECKING:
     from zenml.config.base_settings import SettingsOrDict
     from zenml.config.source import Source
     from zenml.materializers.base_materializer import BaseMaterializer
-    from zenml.model.model_version import ModelVersion
+    from zenml.model.model import Model
     from zenml.steps import BaseStep
 
     MaterializerClassOrSource = Union[str, Source, Type[BaseMaterializer]]
@@ -67,7 +67,7 @@ def step(
     extra: Optional[Dict[str, Any]] = None,
     on_failure: Optional["HookSpecification"] = None,
     on_success: Optional["HookSpecification"] = None,
-    model_version: Optional["ModelVersion"] = None,
+    model: Optional["Model"] = None,
 ) -> Callable[["F"], "BaseStep"]:
     ...
 
@@ -87,7 +87,7 @@ def step(
     extra: Optional[Dict[str, Any]] = None,
     on_failure: Optional["HookSpecification"] = None,
     on_success: Optional["HookSpecification"] = None,
-    model_version: Optional["ModelVersion"] = None,
+    model: Optional["Model"] = None,
 ) -> Union["BaseStep", Callable[["F"], "BaseStep"]]:
     """Decorator to create a ZenML step.
 
@@ -117,7 +117,7 @@ def step(
         on_success: Callback function in event of success of the step. Can be a
             function with no arguments, or a source path to such a function
             (e.g. `module.my_function`).
-        model_version: configuration of the model version in the Model Control Plane.
+        model: configuration of the model in the Model Control Plane.
 
     Returns:
         The step instance.
@@ -149,7 +149,7 @@ def step(
             extra=extra,
             on_failure=on_failure,
             on_success=on_success,
-            model_version=model_version,
+            model=model,
         )
 
         return step_instance

zenml/orchestrators/input_utils.py

@@ -87,7 +87,7 @@ def resolve_step_inputs(
         issue_found = False
         try:
             if config_.metadata_name is None and config_.artifact_name:
-                if artifact_ := config_.model_version.get_artifact(
+                if artifact_ := config_.model.get_artifact(
                     config_.artifact_name, config_.artifact_version
                 ):
                     input_artifacts[name] = artifact_
@@ -95,14 +95,12 @@ def resolve_step_inputs(
                     issue_found = True
             elif config_.artifact_name is None and config_.metadata_name:
                 # metadata values should go directly in parameters, as primitive types
-                step.config.parameters[
-                    name
-                ] = config_.model_version.run_metadata[
+                step.config.parameters[name] = config_.model.run_metadata[
                     config_.metadata_name
                 ].value
             elif config_.metadata_name and config_.artifact_name:
                 # metadata values should go directly in parameters, as primitive types
-                if artifact_ := config_.model_version.get_artifact(
+                if artifact_ := config_.model.get_artifact(
                     config_.artifact_name, config_.artifact_version
                 ):
                     step.config.parameters[name] = artifact_.run_metadata[
@@ -118,8 +116,8 @@ def resolve_step_inputs(
         if issue_found:
             raise ValueError(
                 "Cannot fetch requested information from model "
-                f"`{config_.model_version.name}` version "
-                f"`{config_.model_version.version}` given artifact "
+                f"`{config_.model.name}` version "
+                f"`{config_.model.version}` given artifact "
                 f"`{config_.artifact_name}`, artifact version "
                 f"`{config_.artifact_version}`, and metadata "
                 f"key `{config_.metadata_name}` passed into "

zenml/orchestrators/step_launcher.py

@@ -31,7 +31,7 @@ from zenml.enums import ExecutionStatus
 from zenml.environment import get_run_environment_dict
 from zenml.logger import get_logger
 from zenml.logging import step_logging
-from zenml.model.utils import link_artifact_config_to_model_version
+from zenml.model.utils import link_artifact_config_to_model
 from zenml.models import (
     ArtifactVersionResponse,
     LogsRequest,
@@ -53,7 +53,7 @@ from zenml.stack import Stack
 from zenml.utils import string_utils
 
 if TYPE_CHECKING:
-    from zenml.model.model_version import ModelVersion
+    from zenml.model.model import Model
     from zenml.step_operators import BaseStepOperator
 
 logger = get_logger(__name__)
@@ -310,11 +310,9 @@ class StepLauncher:
             Tuple that specifies whether the step needs to be executed as
             well as the response model of the registered step run.
         """
-        model_version = (
-            self._deployment.step_configurations[
-                step_run.name
-            ].config.model_version
-            or self._deployment.pipeline_configuration.model_version
+        model = (
+            self._deployment.step_configurations[step_run.name].config.model
+            or self._deployment.pipeline_configuration.model
         )
         input_artifacts, parent_step_ids = input_utils.resolve_step_inputs(
             step=self._step,
@@ -362,8 +360,8 @@ class StepLauncher:
                     output_name: artifact.id
                     for output_name, artifact in cached_outputs.items()
                 }
-                self._link_cached_artifacts_to_model_version(
-                    model_version_from_context=model_version,
+                self._link_cached_artifacts_to_model(
+                    model_from_context=model,
                     step_run=step_run,
                 )
                 step_run.status = ExecutionStatus.CACHED
@@ -371,15 +369,15 @@ class StepLauncher:
 
         return execution_needed, step_run
 
-    def _link_cached_artifacts_to_model_version(
+    def _link_cached_artifacts_to_model(
         self,
-        model_version_from_context: Optional["ModelVersion"],
+        model_from_context: Optional["Model"],
         step_run: StepRunRequest,
     ) -> None:
         """Links the output artifacts of the cached step to the model version in Control Plane.
 
         Args:
-            model_version_from_context: The model version of the current step.
+            model_from_context: The model version of the current step.
             step_run: The step to run.
         """
         from zenml.artifacts.artifact_config import ArtifactConfig
@@ -397,15 +395,10 @@ class StepLauncher:
                     artifact_config_ = annotation.artifact_config.copy()
                 else:
                     artifact_config_ = ArtifactConfig(name=output_name_)
-                    logger.info(
-                        f"Linking artifact `{artifact_config_.name}` to "
-                        f"model `{artifact_config_.model_name}` version "
-                        f"`{artifact_config_.model_version}` implicitly."
-                    )
 
-                link_artifact_config_to_model_version(
+                link_artifact_config_to_model(
                     artifact_config=artifact_config_,
-                    model_version=model_version_from_context,
+                    model=model_from_context,
                     artifact_version_id=output_id,
                 )
 

zenml/orchestrators/step_runner.py

@@ -634,8 +634,8 @@ class StepRunner:
 
     def _prepare_model_context_for_step(self) -> None:
         try:
-            model_version = get_step_context().model_version
-            model_version._get_or_create_model_version()
+            model = get_step_context().model
+            model._get_or_create_model_version()
         except StepContextError:
             return
 
@@ -657,11 +657,9 @@ class StepRunner:
                 get_step_context()._get_output(artifact_name).artifact_config
             )
             if artifact_config is not None:
-                if (
-                    model_version := artifact_config._model_version
-                ) is not None:
+                if (model := artifact_config._model) is not None:
                     model_version_response = (
-                        model_version._get_or_create_model_version()
+                        model._get_or_create_model_version()
                     )
                     models.add(
                         (
@@ -680,7 +678,7 @@ class StepRunner:
             Set of tuples of (model_id, model_version_id).
         """
         try:
-            mc = get_step_context().model_version
+            mc = get_step_context().model
             model_version = mc._get_or_create_model_version()
             return {(model_version.model.id, model_version.id)}
         except StepContextError:
@@ -731,11 +729,11 @@ class StepRunner:
 
         # Add models from external artifacts
         for external_artifact in external_artifacts:
-            if external_artifact.model_version:
+            if external_artifact.model:
                 models.add(
                     (
-                        external_artifact.model_version.model_id,
-                        external_artifact.model_version.id,
+                        external_artifact.model.model_id,
+                        external_artifact.model.id,
                     )
                 )
 

zenml/pipelines/base_pipeline.py

@@ -49,7 +49,7 @@ PARAM_SETTINGS = "settings"
 PARAM_EXTRA_OPTIONS = "extra"
 PARAM_ON_FAILURE = "on_failure"
 PARAM_ON_SUCCESS = "on_success"
-PARAM_MODEL_VERSION = "model_version"
+PARAM_MODEL = "model"
 
 TEMPLATE_NAME_ATTRIBUTE = "_template_name"
 

zenml/pipelines/pipeline_decorator.py

@@ -26,7 +26,7 @@ from typing import (
 )
 
 from zenml.logger import get_logger
-from zenml.model.model_version import ModelVersion
+from zenml.model.model import Model
 from zenml.pipelines.base_pipeline import (
     CLASS_CONFIGURATION,
     PARAM_ENABLE_ARTIFACT_METADATA,
@@ -34,7 +34,7 @@ from zenml.pipelines.base_pipeline import (
     PARAM_ENABLE_CACHE,
     PARAM_ENABLE_STEP_LOGS,
     PARAM_EXTRA_OPTIONS,
-    PARAM_MODEL_VERSION,
+    PARAM_MODEL,
     PARAM_ON_FAILURE,
     PARAM_ON_SUCCESS,
     PARAM_PIPELINE_NAME,
@@ -68,7 +68,7 @@ def pipeline(
     enable_step_logs: Optional[bool] = None,
     settings: Optional[Dict[str, "SettingsOrDict"]] = None,
     extra: Optional[Dict[str, Any]] = None,
-    model_version: Optional["ModelVersion"] = None,
+    model: Optional["Model"] = None,
 ) -> Callable[[F], Type[BasePipeline]]:
     ...
 
@@ -85,7 +85,7 @@ def pipeline(
     extra: Optional[Dict[str, Any]] = None,
     on_failure: Optional["HookSpecification"] = None,
     on_success: Optional["HookSpecification"] = None,
-    model_version: Optional["ModelVersion"] = None,
+    model: Optional["Model"] = None,
 ) -> Union[Type[BasePipeline], Callable[[F], Type[BasePipeline]]]:
     """Outer decorator function for the creation of a ZenML pipeline.
 
@@ -105,7 +105,7 @@ def pipeline(
         on_success: Callback function in event of success of the step. Can be a
             function with no arguments, or a source path to such a function
             (e.g. `module.my_function`).
-        model_version: configuration of the model version in the Model Control Plane.
+        model: configuration of the model in the Model Control Plane.
 
     Returns:
         the inner decorator which creates the pipeline class based on the
@@ -137,7 +137,7 @@ def pipeline(
                     PARAM_EXTRA_OPTIONS: extra,
                     PARAM_ON_FAILURE: on_failure,
                     PARAM_ON_SUCCESS: on_success,
-                    PARAM_MODEL_VERSION: model_version,
+                    PARAM_MODEL: model,
                 },
                 "__module__": func.__module__,
                 "__doc__": func.__doc__,

zenml/steps/base_step.py

@@ -71,7 +71,7 @@ if TYPE_CHECKING:
         StepConfigurationUpdate,
     )
     from zenml.model.lazy_load import ModelVersionDataLazyLoader
-    from zenml.model.model_version import ModelVersion
+    from zenml.model.model import Model
 
     ParametersOrDict = Union["BaseParameters", Dict[str, Any]]
     MaterializerClassOrSource = Union[str, Source, Type["BaseMaterializer"]]
@@ -137,7 +137,7 @@ class BaseStep(metaclass=BaseStepMeta):
         extra: Optional[Dict[str, Any]] = None,
         on_failure: Optional["HookSpecification"] = None,
         on_success: Optional["HookSpecification"] = None,
-        model_version: Optional["ModelVersion"] = None,
+        model: Optional["Model"] = None,
         **kwargs: Any,
     ) -> None:
         """Initializes a step.
@@ -166,7 +166,7 @@ class BaseStep(metaclass=BaseStepMeta):
             on_success: Callback function in event of success of the step. Can
                 be a function with no arguments, or a source path to such a
                 function (e.g. `module.my_function`).
-            model_version: configuration of the model version in the Model Control Plane.
+            model: configuration of the model version in the Model Control Plane.
             **kwargs: Keyword arguments passed to the step.
         """
         from zenml.config.step_configurations import PartialStepConfiguration
@@ -213,13 +213,13 @@ class BaseStep(metaclass=BaseStepMeta):
             name,
             "enabled" if enable_step_logs is not False else "disabled",
         )
-        if model_version is not None:
+        if model is not None:
             logger.debug(
                 "Step '%s': Is in Model context %s.",
                 name,
                 {
-                    "model": model_version.name,
-                    "version": model_version.version,
+                    "model": model.name,
+                    "version": model.version,
                 },
             )
 
@@ -239,7 +239,7 @@ class BaseStep(metaclass=BaseStepMeta):
             extra=extra,
             on_failure=on_failure,
             on_success=on_success,
-            model_version=model_version,
+            model=model,
         )
         self._verify_and_apply_init_params(*args, **kwargs)
 
@@ -505,14 +505,14 @@ class BaseStep(metaclass=BaseStepMeta):
                     )
             elif isinstance(value, LazyArtifactVersionResponse):
                 model_artifacts_or_metadata[key] = ModelVersionDataLazyLoader(
-                    model_version=value._lazy_load_model_version,
+                    model=value._lazy_load_model,
                     artifact_name=value._lazy_load_name,
                     artifact_version=value._lazy_load_version,
                     metadata_name=None,
                 )
             elif isinstance(value, LazyRunMetadataResponse):
                 model_artifacts_or_metadata[key] = ModelVersionDataLazyLoader(
-                    model_version=value._lazy_load_model_version,
+                    model=value._lazy_load_model,
                     artifact_name=value._lazy_load_artifact_name,
                     artifact_version=value._lazy_load_artifact_version,
                     metadata_name=value._lazy_load_metadata_name,
@@ -684,7 +684,7 @@ class BaseStep(metaclass=BaseStepMeta):
         extra: Optional[Dict[str, Any]] = None,
         on_failure: Optional["HookSpecification"] = None,
         on_success: Optional["HookSpecification"] = None,
-        model_version: Optional["ModelVersion"] = None,
+        model: Optional["Model"] = None,
         merge: bool = True,
     ) -> T:
         """Configures the step.
@@ -722,7 +722,7 @@ class BaseStep(metaclass=BaseStepMeta):
             on_success: Callback function in event of success of the step. Can
                 be a function with no arguments, or a source path to such a
                 function (e.g. `module.my_function`).
-            model_version: configuration of the model version in the Model Control Plane.
+            model: configuration of the model version in the Model Control Plane.
             merge: If `True`, will merge the given dictionary configurations
                 like `parameters` and `settings` with existing
                 configurations. If `False` the given configurations will
@@ -796,7 +796,7 @@ class BaseStep(metaclass=BaseStepMeta):
                 "extra": extra,
                 "failure_hook_source": failure_hook_source,
                 "success_hook_source": success_hook_source,
-                "model_version": model_version,
+                "model": model,
             }
         )
         config = StepConfigurationUpdate(**values)
@@ -819,7 +819,7 @@ class BaseStep(metaclass=BaseStepMeta):
         extra: Optional[Dict[str, Any]] = None,
         on_failure: Optional["HookSpecification"] = None,
         on_success: Optional["HookSpecification"] = None,
-        model_version: Optional["ModelVersion"] = None,
+        model: Optional["Model"] = None,
         merge: bool = True,
     ) -> "BaseStep":
         """Copies the step and applies the given configurations.
@@ -846,7 +846,7 @@ class BaseStep(metaclass=BaseStepMeta):
             on_success: Callback function in event of success of the step. Can
                 be a function with no arguments, or a source path to such a
                 function (e.g. `module.my_function`).
-            model_version: configuration of the model version in the Model Control Plane.
+            model: configuration of the model version in the Model Control Plane.
             merge: If `True`, will merge the given dictionary configurations
                 like `parameters` and `settings` with existing
                 configurations. If `False` the given configurations will
@@ -870,7 +870,7 @@ class BaseStep(metaclass=BaseStepMeta):
             extra=extra,
             on_failure=on_failure,
             on_success=on_success,
-            model_version=model_version,
+            model=model,
             merge=merge,
         )
         return step_copy

zenml/steps/step_decorator.py

@@ -36,7 +36,7 @@ if TYPE_CHECKING:
     from zenml.config.base_settings import SettingsOrDict
     from zenml.config.source import Source
     from zenml.materializers.base_materializer import BaseMaterializer
-    from zenml.model.model_version import ModelVersion
+    from zenml.model.model import Model
 
     MaterializerClassOrSource = Union[str, "Source", Type["BaseMaterializer"]]
     HookSpecification = Union[str, "Source", FunctionType]
@@ -63,7 +63,7 @@ PARAM_SETTINGS = "settings"
 PARAM_EXTRA_OPTIONS = "extra"
 PARAM_ON_FAILURE = "on_failure"
 PARAM_ON_SUCCESS = "on_success"
-PARAM_MODEL_VERSION = "model_version"
+PARAM_MODEL = "model"
 
 logger = get_logger(__name__)
 
@@ -108,7 +108,7 @@ def step(
     extra: Optional[Dict[str, Any]] = None,
     on_failure: Optional["HookSpecification"] = None,
     on_success: Optional["HookSpecification"] = None,
-    model_version: Optional["ModelVersion"] = None,
+    model: Optional["Model"] = None,
 ) -> Callable[[F], Type[BaseStep]]:
     ...
 
@@ -128,7 +128,7 @@ def step(
     extra: Optional[Dict[str, Any]] = None,
     on_failure: Optional["HookSpecification"] = None,
     on_success: Optional["HookSpecification"] = None,
-    model_version: Optional["ModelVersion"] = None,
+    model: Optional["Model"] = None,
 ) -> Union[Type[BaseStep], Callable[[F], Type[BaseStep]]]:
     """Outer decorator function for the creation of a ZenML step.
 
@@ -161,7 +161,7 @@ def step(
         on_success: Callback function in event of success of the step. Can be a
             function with no arguments, or a source path to such a function
             (e.g. `module.my_function`).
-        model_version: configuration of the model version in the Model Control Plane.
+        model: configuration of the model version in the Model Control Plane.
 
     Returns:
         The inner decorator which creates the step class based on the
@@ -204,7 +204,7 @@ def step(
                     PARAM_EXTRA_OPTIONS: extra,
                     PARAM_ON_FAILURE: on_failure,
                     PARAM_ON_SUCCESS: on_success,
-                    PARAM_MODEL_VERSION: model_version,
+                    PARAM_MODEL: model,
                 },
                 "__module__": func.__module__,
                 "__doc__": func.__doc__,

zenml/steps/utils.py

@@ -14,17 +14,24 @@
 
 """Utility functions and classes to run ZenML steps."""
 
+
 import ast
+import contextlib
 import inspect
 import textwrap
 from typing import Any, Callable, Dict, Optional, Tuple, Union
+from uuid import UUID
 
 import pydantic.typing as pydantic_typing
 from pydantic import BaseModel
 from typing_extensions import Annotated
 
 from zenml.artifacts.artifact_config import ArtifactConfig
+from zenml.client import Client
+from zenml.enums import MetadataResourceTypes
 from zenml.logger import get_logger
+from zenml.metadata.metadata_types import MetadataType
+from zenml.new.steps.step_context import get_step_context
 from zenml.steps.step_output import Output
 from zenml.utils import source_code_utils
 
@@ -403,3 +410,64 @@ def has_only_none_returns(func: Callable[..., Any]) -> bool:
     visitor.visit(tree)
 
     return visitor.has_only_none_returns
+
+
+def log_step_metadata(
+    metadata: Dict[str, "MetadataType"],
+    step_name: Optional[str] = None,
+    pipeline_name_id_or_prefix: Optional[Union[str, UUID]] = None,
+    pipeline_version: Optional[str] = None,
+    run_id: Optional[str] = None,
+) -> None:
+    """Logs step metadata.
+
+    Args:
+        metadata: The metadata to log.
+        step_name: The name of the step to log metadata for. Can be omitted
+            when being called inside a step.
+        pipeline_name_id_or_prefix: The name of the pipeline to log metadata
+            for. Can be omitted when being called inside a step.
+        pipeline_version: The version of the pipeline to log metadata for.
+            Can be omitted when being called inside a step.
+        run_id: The ID of the run to log metadata for. Can be omitted when
+            being called inside a step.
+
+    Raises:
+        ValueError: If no step name is provided and the function is not called
+            from within a step or if no pipeline name or ID is provided and
+            the function is not called from within a step.
+    """
+    step_context = None
+    if not step_name:
+        with contextlib.suppress(RuntimeError):
+            step_context = get_step_context()
+            step_name = step_context.step_name
+    # not running within a step and no user-provided step name
+    if not step_name:
+        raise ValueError(
+            "No step name provided and you are not running "
+            "within a step. Please provide a step name."
+        )
+
+    client = Client()
+    if step_context:
+        step_run_id = step_context.step_run.id
+    elif run_id:
+        step_run_id = UUID(int=int(run_id))
+    else:
+        if not pipeline_name_id_or_prefix:
+            raise ValueError(
+                "No pipeline name or ID provided and you are not running "
+                "within a step. Please provide a pipeline name or ID, or "
+                "provide a run ID."
+            )
+        pipeline_run = client.get_pipeline(
+            name_id_or_prefix=pipeline_name_id_or_prefix,
+            version=pipeline_version,
+        ).last_run
+        step_run_id = pipeline_run.steps[step_name].id
+    client.create_run_metadata(
+        metadata=metadata,
+        resource_id=step_run_id,
+        resource_type=MetadataResourceTypes.STEP_RUN,
+    )

zenml/zen_server/deploy/helm/templates/server-db-job.yaml

@@ -8,7 +8,7 @@ metadata:
   annotations:
     "helm.sh/hook": pre-install,pre-upgrade
     "helm.sh/hook-weight": "-1"
-    "helm.sh/hook-delete-policy": before-hook-creation,hook-succeeded 
+    "helm.sh/hook-delete-policy": before-hook-creation{{ if not .Values.zenml.debug }},hook-succeeded{{ end }}
 spec:
   backoffLimit: 2
   template:

zenml/zen_server/deploy/helm/templates/server-secret.yaml

@@ -55,5 +55,5 @@ metadata:
   annotations:
     "helm.sh/hook": "pre-install,pre-upgrade"
     "helm.sh/hook-weight": "-3"  
-    "helm.sh/hook-delete-policy": before-hook-creation,hook-succeeded
+    "helm.sh/hook-delete-policy": before-hook-creation{{ if not .Values.zenml.debug }},hook-succeeded{{ end }}
 {{ include "secret.content" . }}

zenml/zen_server/deploy/helm/templates/serviceaccount.yaml

@@ -20,7 +20,7 @@ metadata:
   annotations:
     "helm.sh/hook": "pre-install,pre-upgrade"
     "helm.sh/hook-weight": "-2" # Set your desired hook weight here
-    "helm.sh/hook-delete-policy": before-hook-creation,hook-succeeded
+    "helm.sh/hook-delete-policy": before-hook-creation{{ if not .Values.zenml.debug }},hook-succeeded{{ end }}
   {{- with .Values.serviceAccount.annotations }}
     {{- toYaml . | nindent 4 }}
   {{- end }}

zenml/zen_server/utils.py

@@ -272,12 +272,17 @@ def make_dependable(cls: Type[BaseModel]) -> Callable[..., Any]:
         def f(model: Model = Depends(make_dependable(Model))):
             ...
 
+    UPDATE: Function from above mentioned Github issue was extended to support
+    multi-input parameters, e.g. tags: List[str]. It needs a default set to Query(<default>),
+    rather just plain <default>.
+
     Args:
         cls: The model class.
 
     Returns:
         Function to use in FastAPI `Depends`.
     """
+    from fastapi import Query
 
     def init_cls_and_handle_errors(*args: Any, **kwargs: Any) -> BaseModel:
         from fastapi import HTTPException
@@ -290,7 +295,20 @@ def make_dependable(cls: Type[BaseModel]) -> Callable[..., Any]:
                 error["loc"] = tuple(["query"] + list(error["loc"]))
             raise HTTPException(422, detail=e.errors())
 
-    init_cls_and_handle_errors.__signature__ = inspect.signature(cls)  # type: ignore[attr-defined]
+    params = {v.name: v for v in inspect.signature(cls).parameters.values()}
+    query_params = getattr(cls, "API_MULTI_INPUT_PARAMS", [])
+    for qp in query_params:
+        if qp in params:
+            params[qp] = inspect.Parameter(
+                name=params[qp].name,
+                default=Query(params[qp].default),
+                kind=params[qp].kind,
+                annotation=params[qp].annotation,
+            )
+
+    init_cls_and_handle_errors.__signature__ = inspect.Signature(  # type: ignore[attr-defined]
+        parameters=[v for v in params.values()]
+    )
 
     return init_cls_and_handle_errors