zenml-nightly 0.83.1.dev20250626__py3-none-any.whl → 0.83.1.dev20250628__py3-none-any.whl

zenml/VERSION

@@ -1 +1 @@
-0.83.1.dev20250626
+0.83.1.dev20250628

zenml/client.py

@@ -6420,9 +6420,15 @@ class Client(metaclass=ClientMetaClass):
         if model_version_name_or_number_or_id is None:
             model_version_name_or_number_or_id = ModelStages.LATEST
 
-        if isinstance(model_version_name_or_number_or_id, UUID):
+        if is_valid_uuid(model_version_name_or_number_or_id):
+            assert not isinstance(model_version_name_or_number_or_id, int)
+            model_version_id = (
+                UUID(model_version_name_or_number_or_id)
+                if isinstance(model_version_name_or_number_or_id, str)
+                else model_version_name_or_number_or_id
+            )
             return self.zen_store.get_model_version(
-                model_version_id=model_version_name_or_number_or_id,
+                model_version_id=model_version_id,
                 hydrate=hydrate,
             )
         elif isinstance(model_version_name_or_number_or_id, int):

zenml/integrations/aws/flavors/sagemaker_orchestrator_flavor.py

@@ -130,7 +130,7 @@ class SagemakerOrchestratorSettings(BaseSettings):
     )
 
     processor_role: Optional[str] = None
-    processor_tags: Dict[str, str] = {}
+    processor_tags: Optional[Dict[str, str]] = None
     _deprecation_validator = deprecation_utils.deprecate_pydantic_attributes(
         ("processor_role", "execution_role"), ("processor_tags", "tags")
     )

zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator.py

@@ -46,6 +46,9 @@ from kubernetes import client as k8s_client
 from kubernetes import config as k8s_config
 
 from zenml.config.base_settings import BaseSettings
+from zenml.constants import (
+    METADATA_ORCHESTRATOR_RUN_ID,
+)
 from zenml.enums import StackComponentType
 from zenml.integrations.kubernetes.flavors.kubernetes_orchestrator_flavor import (
     KubernetesOrchestratorConfig,
@@ -61,6 +64,7 @@ from zenml.integrations.kubernetes.orchestrators.manifest_utils import (
 )
 from zenml.integrations.kubernetes.pod_settings import KubernetesPodSettings
 from zenml.logger import get_logger
+from zenml.metadata.metadata_types import MetadataType
 from zenml.orchestrators import ContainerizedOrchestrator, SubmissionResult
 from zenml.orchestrators.utils import get_orchestrator_run_name
 from zenml.stack import StackValidator
@@ -467,9 +471,7 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
         # This will internally also build the command/args for all step pods.
         command = KubernetesOrchestratorEntrypointConfiguration.get_entrypoint_command()
         args = KubernetesOrchestratorEntrypointConfiguration.get_entrypoint_arguments(
-            run_name=orchestrator_run_name,
             deployment_id=deployment.id,
-            kubernetes_namespace=self.config.kubernetes_namespace,
             run_id=placeholder_run.id if placeholder_run else None,
         )
 
@@ -508,6 +510,18 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
                 }
             )
 
+        orchestrator_pod_labels = {
+            "pipeline": kube_utils.sanitize_label(pipeline_name),
+        }
+
+        if placeholder_run:
+            orchestrator_pod_labels["run_id"] = kube_utils.sanitize_label(
+                str(placeholder_run.id)
+            )
+            orchestrator_pod_labels["run_name"] = kube_utils.sanitize_label(
+                str(placeholder_run.name)
+            )
+
         # Schedule as CRON job if CRON schedule is given.
         if deployment.schedule:
             if not deployment.schedule.cron_expression:
@@ -519,9 +533,7 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
             cron_expression = deployment.schedule.cron_expression
             cron_job_manifest = build_cron_job_manifest(
                 cron_expression=cron_expression,
-                run_name=orchestrator_run_name,
                 pod_name=pod_name,
-                pipeline_name=pipeline_name,
                 image_name=image,
                 command=command,
                 args=args,
@@ -533,6 +545,7 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
                 successful_jobs_history_limit=settings.successful_jobs_history_limit,
                 failed_jobs_history_limit=settings.failed_jobs_history_limit,
                 ttl_seconds_after_finished=settings.ttl_seconds_after_finished,
+                labels=orchestrator_pod_labels,
             )
 
             self._k8s_batch_api.create_namespaced_cron_job(
@@ -547,9 +560,7 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
         else:
             # Create and run the orchestrator pod.
             pod_manifest = build_pod_manifest(
-                run_name=orchestrator_run_name,
                 pod_name=pod_name,
-                pipeline_name=pipeline_name,
                 image_name=image,
                 command=command,
                 args=args,
@@ -557,6 +568,7 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
                 pod_settings=orchestrator_pod_settings,
                 service_account_name=service_account_name,
                 env=environment,
+                labels=orchestrator_pod_labels,
                 mount_local_stores=self.config.is_local,
             )
 
@@ -572,6 +584,11 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
                 startup_timeout=settings.pod_startup_timeout,
             )
 
+            metadata: Dict[str, MetadataType] = {
+                METADATA_ORCHESTRATOR_RUN_ID: pod_name,
+            }
+
+            # Wait for the orchestrator pod to finish and stream logs.
             if settings.synchronous:
 
                 def _wait_for_run_to_finish() -> None:
@@ -588,7 +605,8 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
                     )
 
                 return SubmissionResult(
-                    wait_for_completion=_wait_for_run_to_finish
+                    metadata=metadata,
+                    wait_for_completion=_wait_for_run_to_finish,
                 )
             else:
                 logger.info(
@@ -597,7 +615,9 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
                     f"Run the following command to inspect the logs: "
                     f"`kubectl logs {pod_name} -n {self.config.kubernetes_namespace}`."
                 )
-                return None
+                return SubmissionResult(
+                    metadata=metadata,
+                )
 
     def _get_service_account_name(
         self, settings: KubernetesOrchestratorSettings
@@ -642,3 +662,18 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
                 "Unable to read run id from environment variable "
                 f"{ENV_ZENML_KUBERNETES_RUN_ID}."
             )
+
+    def get_pipeline_run_metadata(
+        self, run_id: UUID
+    ) -> Dict[str, "MetadataType"]:
+        """Get general component-specific metadata for a pipeline run.
+
+        Args:
+            run_id: The ID of the pipeline run.
+
+        Returns:
+            A dictionary of metadata.
+        """
+        return {
+            METADATA_ORCHESTRATOR_RUN_ID: self.get_orchestrator_run_id(),
+        }

zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator_entrypoint.py

@@ -15,8 +15,7 @@
 
 import argparse
 import socket
-from typing import Any, Dict, cast
-from uuid import UUID
+from typing import Callable, Dict, Optional, cast
 
 from kubernetes import client as k8s_client
 
@@ -41,10 +40,16 @@ from zenml.integrations.kubernetes.orchestrators.manifest_utils import (
 from zenml.logger import get_logger
 from zenml.orchestrators import publish_utils
 from zenml.orchestrators.dag_runner import NodeStatus, ThreadedDagRunner
+from zenml.orchestrators.step_run_utils import (
+    StepRunRequestFactory,
+    fetch_step_runs_by_names,
+    publish_cached_step_run,
+)
 from zenml.orchestrators.utils import (
     get_config_environment_vars,
     get_orchestrator_run_name,
 )
+from zenml.pipelines.run_utils import create_placeholder_run
 
 logger = get_logger(__name__)
 
@@ -56,9 +61,7 @@ def parse_args() -> argparse.Namespace:
         Parsed args.
     """
     parser = argparse.ArgumentParser()
-    parser.add_argument("--run_name", type=str, required=True)
     parser.add_argument("--deployment_id", type=str, required=True)
-    parser.add_argument("--kubernetes_namespace", type=str, required=True)
     parser.add_argument("--run_id", type=str, required=False)
     return parser.parse_args()
 
@@ -68,7 +71,6 @@ def main() -> None:
     # Log to the container's stdout so it can be streamed by the client.
     logger.info("Kubernetes orchestrator pod started.")
 
-    # Parse / extract args.
     args = parse_args()
 
     orchestrator_pod_name = socket.gethostname()
@@ -77,6 +79,7 @@ def main() -> None:
     active_stack = client.active_stack
     orchestrator = active_stack.orchestrator
     assert isinstance(orchestrator, KubernetesOrchestrator)
+    namespace = orchestrator.config.kubernetes_namespace
 
     deployment = client.get_deployment(args.deployment_id)
     pipeline_settings = cast(
@@ -86,20 +89,6 @@ def main() -> None:
 
     step_command = StepEntrypointConfiguration.get_entrypoint_command()
 
-    if args.run_id and not pipeline_settings.prevent_orchestrator_pod_caching:
-        from zenml.orchestrators import cache_utils
-
-        run_required = (
-            cache_utils.create_cached_step_runs_and_prune_deployment(
-                deployment=deployment,
-                pipeline_run=client.get_pipeline_run(args.run_id),
-                stack=active_stack,
-            )
-        )
-
-        if not run_required:
-            return
-
     mount_local_stores = active_stack.orchestrator.config.is_local
 
     # Get a Kubernetes client from the active Kubernetes orchestrator, but
@@ -115,7 +104,7 @@ def main() -> None:
         owner_references = kube_utils.get_pod_owner_references(
             core_api=core_api,
             pod_name=orchestrator_pod_name,
-            namespace=args.kubernetes_namespace,
+            namespace=namespace,
         )
     except Exception as e:
         logger.warning(f"Failed to get pod owner references: {str(e)}")
@@ -126,6 +115,62 @@ def main() -> None:
         for owner_reference in owner_references:
             owner_reference.controller = False
 
+    if args.run_id:
+        pipeline_run = client.get_pipeline_run(args.run_id)
+    else:
+        pipeline_run = create_placeholder_run(
+            deployment=deployment,
+            orchestrator_run_id=orchestrator_pod_name,
+        )
+
+    pre_step_run: Optional[Callable[[str], bool]] = None
+
+    if not pipeline_settings.prevent_orchestrator_pod_caching:
+        step_run_request_factory = StepRunRequestFactory(
+            deployment=deployment,
+            pipeline_run=pipeline_run,
+            stack=active_stack,
+        )
+        step_runs = {}
+
+        def pre_step_run(step_name: str) -> bool:
+            """Pre-step run.
+
+            Args:
+                step_name: Name of the step.
+
+            Returns:
+                Whether the step node needs to be run.
+            """
+            step_run_request = step_run_request_factory.create_request(
+                step_name
+            )
+            try:
+                step_run_request_factory.populate_request(step_run_request)
+            except Exception as e:
+                logger.error(
+                    f"Failed to populate step run request for step {step_name}: {e}"
+                )
+                return True
+
+            if step_run_request.status == ExecutionStatus.CACHED:
+                step_run = publish_cached_step_run(
+                    step_run_request, pipeline_run
+                )
+                step_runs[step_name] = step_run
+                logger.info("Using cached version of step `%s`.", step_name)
+                return False
+
+            return True
+
+    step_pod_labels = {
+        "run_id": kube_utils.sanitize_label(str(pipeline_run.id)),
+        "run_name": kube_utils.sanitize_label(str(pipeline_run.name)),
+        "pipeline": kube_utils.sanitize_label(
+            deployment.pipeline_configuration.name
+        ),
+    }
+
     def run_step_on_kubernetes(step_name: str) -> None:
         """Run a pipeline step in a separate Kubernetes pod.
 
@@ -146,7 +191,7 @@ def main() -> None:
         ):
             max_length = (
                 kube_utils.calculate_max_pod_name_length_for_namespace(
-                    namespace=args.kubernetes_namespace
+                    namespace=namespace
                 )
             )
             pod_name_prefix = get_orchestrator_run_name(
@@ -156,9 +201,7 @@ def main() -> None:
         else:
             pod_name = f"{orchestrator_pod_name}-{step_name}"
 
-        pod_name = kube_utils.sanitize_pod_name(
-            pod_name, namespace=args.kubernetes_namespace
-        )
+        pod_name = kube_utils.sanitize_pod_name(pod_name, namespace=namespace)
 
         image = KubernetesOrchestrator.get_image(
             deployment=deployment, step_name=step_name
@@ -195,8 +238,6 @@ def main() -> None:
         # Define Kubernetes pod manifest.
         pod_manifest = build_pod_manifest(
             pod_name=pod_name,
-            run_name=args.run_name,
-            pipeline_name=deployment.pipeline_configuration.name,
             image_name=image,
             command=step_command,
             args=step_args,
@@ -207,6 +248,7 @@ def main() -> None:
             or settings.service_account_name,
             mount_local_stores=mount_local_stores,
             owner_references=owner_references,
+            labels=step_pod_labels,
         )
 
         kube_utils.create_and_wait_for_pod_to_start(
@@ -214,7 +256,7 @@ def main() -> None:
             pod_display_name=f"pod for step `{step_name}`",
             pod_name=pod_name,
             pod_manifest=pod_manifest,
-            namespace=args.kubernetes_namespace,
+            namespace=namespace,
             startup_max_retries=settings.pod_failure_max_retries,
             startup_failure_delay=settings.pod_failure_retry_delay,
             startup_failure_backoff=settings.pod_failure_backoff,
@@ -229,7 +271,7 @@ def main() -> None:
                     incluster=True
                 ),
                 pod_name=pod_name,
-                namespace=args.kubernetes_namespace,
+                namespace=namespace,
                 exit_condition_lambda=kube_utils.pod_is_done,
                 stream_logs=True,
             )
@@ -249,30 +291,15 @@ def main() -> None:
         try:
             # Some steps may have failed because the pods could not be created.
             # We need to check for this and mark the step run as failed if so.
-
-            # Fetch the pipeline run using any means possible.
-            list_args: Dict[str, Any] = {}
-            if args.run_id:
-                # For a run triggered outside of a schedule, we can use the
-                # placeholder run ID to find the pipeline run.
-                list_args = dict(id=UUID(args.run_id))
-            else:
-                # For a run triggered by a schedule, we can only use the
-                # orchestrator run ID to find the pipeline run.
-                list_args = dict(orchestrator_run_id=orchestrator_pod_name)
-
-            pipeline_runs = client.list_pipeline_runs(
-                hydrate=True,
-                project=deployment.project_id,
-                deployment_id=deployment.id,
-                **list_args,
-            )
-            if not len(pipeline_runs):
-                # No pipeline run found, so we can't mark any step runs as failed.
-                return
-
-            pipeline_run = pipeline_runs[0]
             pipeline_failed = False
+            failed_step_names = [
+                step_name
+                for step_name, node_state in node_states.items()
+                if node_state == NodeStatus.FAILED
+            ]
+            step_runs = fetch_step_runs_by_names(
+                step_run_names=failed_step_names, pipeline_run=pipeline_run
+            )
 
             for step_name, node_state in node_states.items():
                 if node_state != NodeStatus.FAILED:
@@ -280,18 +307,14 @@ def main() -> None:
 
                 pipeline_failed = True
 
-                # If steps failed for any reason, we need to mark the step run as
-                # failed, if it exists and it wasn't already in a final state.
-
-                step_run = pipeline_run.steps.get(step_name)
-
-                # Try to update the step run status, if it exists and is in
-                # a transient state.
-                if step_run and step_run.status in {
-                    ExecutionStatus.INITIALIZING,
-                    ExecutionStatus.RUNNING,
-                }:
-                    publish_utils.publish_failed_step_run(step_run.id)
+                if step_run := step_runs.get(step_name, None):
+                    # Try to update the step run status, if it exists and is in
+                    # a transient state.
+                    if step_run and step_run.status in {
+                        ExecutionStatus.INITIALIZING,
+                        ExecutionStatus.RUNNING,
+                    }:
+                        publish_utils.publish_failed_step_run(step_run.id)
 
             # If any steps failed and the pipeline run is still in a transient
             # state, we need to mark it as failed.
@@ -319,6 +342,7 @@ def main() -> None:
         ThreadedDagRunner(
             dag=pipeline_dag,
             run_fn=run_step_on_kubernetes,
+            preparation_fn=pre_step_run,
             finalize_fn=finalize_run,
             parallel_node_startup_waiting_period=parallel_node_startup_waiting_period,
             max_parallelism=pipeline_settings.max_parallelism,
@@ -333,7 +357,7 @@ def main() -> None:
             try:
                 kube_utils.delete_secret(
                     core_api=core_api,
-                    namespace=args.kubernetes_namespace,
+                    namespace=namespace,
                     secret_name=secret_name,
                 )
             except k8s_client.rest.ApiException as e:

zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator_entrypoint_configuration.py

@@ -18,9 +18,7 @@ from typing import TYPE_CHECKING, List, Optional, Set
 if TYPE_CHECKING:
     from uuid import UUID
 
-RUN_NAME_OPTION = "run_name"
 DEPLOYMENT_ID_OPTION = "deployment_id"
-NAMESPACE_OPTION = "kubernetes_namespace"
 RUN_ID_OPTION = "run_id"
 
 
@@ -35,9 +33,7 @@ class KubernetesOrchestratorEntrypointConfiguration:
             Entrypoint options.
         """
         options = {
-            RUN_NAME_OPTION,
             DEPLOYMENT_ID_OPTION,
-            NAMESPACE_OPTION,
         }
         return options
 
@@ -58,29 +54,21 @@ class KubernetesOrchestratorEntrypointConfiguration:
     @classmethod
     def get_entrypoint_arguments(
         cls,
-        run_name: str,
         deployment_id: "UUID",
-        kubernetes_namespace: str,
         run_id: Optional["UUID"] = None,
     ) -> List[str]:
         """Gets all arguments that the entrypoint command should be called with.
 
         Args:
-            run_name: Name of the ZenML run.
             deployment_id: ID of the deployment.
-            kubernetes_namespace: Name of the Kubernetes namespace.
             run_id: Optional ID of the pipeline run. Not set for scheduled runs.
 
         Returns:
             List of entrypoint arguments.
         """
         args = [
-            f"--{RUN_NAME_OPTION}",
-            run_name,
             f"--{DEPLOYMENT_ID_OPTION}",
             str(deployment_id),
-            f"--{NAMESPACE_OPTION}",
-            kubernetes_namespace,
         ]
 
         if run_id:

zenml/integrations/kubernetes/orchestrators/manifest_utils.py

@@ -26,7 +26,6 @@ from zenml.constants import ENV_ZENML_ENABLE_REPO_INIT_WARNINGS
 from zenml.integrations.airflow.orchestrators.dag_generator import (
     ENV_ZENML_LOCAL_STORES_PATH,
 )
-from zenml.integrations.kubernetes.orchestrators import kube_utils
 from zenml.integrations.kubernetes.pod_settings import KubernetesPodSettings
 from zenml.logger import get_logger
 
@@ -97,8 +96,6 @@ def add_local_stores_mount(
 
 def build_pod_manifest(
     pod_name: str,
-    run_name: str,
-    pipeline_name: str,
     image_name: str,
     command: List[str],
     args: List[str],
@@ -106,6 +103,7 @@ def build_pod_manifest(
     pod_settings: Optional[KubernetesPodSettings] = None,
     service_account_name: Optional[str] = None,
     env: Optional[Dict[str, str]] = None,
+    labels: Optional[Dict[str, str]] = None,
     mount_local_stores: bool = False,
     owner_references: Optional[List[k8s_client.V1OwnerReference]] = None,
 ) -> k8s_client.V1Pod:
@@ -113,8 +111,6 @@ def build_pod_manifest(
 
     Args:
         pod_name: Name of the pod.
-        run_name: Name of the ZenML run.
-        pipeline_name: Name of the ZenML pipeline.
         image_name: Name of the Docker image.
         command: Command to execute the entrypoint in the pod.
         args: Arguments provided to the entrypoint command.
@@ -124,6 +120,7 @@ def build_pod_manifest(
             Can be used to assign certain roles to a pod, e.g., to allow it to
             run Kubernetes commands from within the cluster.
         env: Environment variables to set.
+        labels: Labels to add to the pod.
         mount_local_stores: Whether to mount the local stores path inside the
             pod.
         owner_references: List of owner references for the pod.
@@ -162,7 +159,7 @@ def build_pod_manifest(
     if service_account_name is not None:
         pod_spec.service_account_name = service_account_name
 
-    labels = {}
+    labels = labels or {}
 
     if pod_settings:
         add_pod_settings(pod_spec, pod_settings)
@@ -171,14 +168,6 @@ def build_pod_manifest(
         if pod_settings.labels:
             labels.update(pod_settings.labels)
 
-    # Add run_name and pipeline_name to the labels
-    labels.update(
-        {
-            "run": kube_utils.sanitize_label(run_name),
-            "pipeline": kube_utils.sanitize_label(pipeline_name),
-        }
-    )
-
     pod_metadata = k8s_client.V1ObjectMeta(
         name=pod_name,
         labels=labels,
@@ -272,8 +261,6 @@ def add_pod_settings(
 def build_cron_job_manifest(
     cron_expression: str,
     pod_name: str,
-    run_name: str,
-    pipeline_name: str,
     image_name: str,
     command: List[str],
     args: List[str],
@@ -281,6 +268,7 @@ def build_cron_job_manifest(
     pod_settings: Optional[KubernetesPodSettings] = None,
     service_account_name: Optional[str] = None,
     env: Optional[Dict[str, str]] = None,
+    labels: Optional[Dict[str, str]] = None,
     mount_local_stores: bool = False,
     successful_jobs_history_limit: Optional[int] = None,
     failed_jobs_history_limit: Optional[int] = None,
@@ -291,8 +279,6 @@ def build_cron_job_manifest(
     Args:
         cron_expression: CRON job schedule expression, e.g. "* * * * *".
         pod_name: Name of the pod.
-        run_name: Name of the ZenML run.
-        pipeline_name: Name of the ZenML pipeline.
         image_name: Name of the Docker image.
         command: Command to execute the entrypoint in the pod.
         args: Arguments provided to the entrypoint command.
@@ -302,6 +288,7 @@ def build_cron_job_manifest(
             Can be used to assign certain roles to a pod, e.g., to allow it to
             run Kubernetes commands from within the cluster.
         env: Environment variables to set.
+        labels: Labels to add to the pod.
         mount_local_stores: Whether to mount the local stores path inside the
             pod.
         successful_jobs_history_limit: The number of successful jobs to retain.
@@ -314,8 +301,6 @@ def build_cron_job_manifest(
     """
     pod_manifest = build_pod_manifest(
         pod_name=pod_name,
-        run_name=run_name,
-        pipeline_name=pipeline_name,
         image_name=image_name,
         command=command,
         args=args,
@@ -323,6 +308,7 @@ def build_cron_job_manifest(
         pod_settings=pod_settings,
         service_account_name=service_account_name,
         env=env,
+        labels=labels,
         mount_local_stores=mount_local_stores,
     )
 

zenml/integrations/kubernetes/step_operators/kubernetes_step_operator.py

@@ -205,9 +205,7 @@ class KubernetesStepOperator(BaseStepOperator):
 
         # Create and run the orchestrator pod.
         pod_manifest = build_pod_manifest(
-            run_name=info.run_name,
             pod_name=pod_name,
-            pipeline_name=info.pipeline.name,
             image_name=image_name,
             command=command,
             args=args,
@@ -216,6 +214,10 @@ class KubernetesStepOperator(BaseStepOperator):
             pod_settings=settings.pod_settings,
             env=environment,
             mount_local_stores=False,
+            labels={
+                "run_id": kube_utils.sanitize_label(str(info.run_id)),
+                "pipeline": kube_utils.sanitize_label(info.pipeline.name),
+            },
         )
 
         kube_utils.create_and_wait_for_pod_to_start(

zenml/integrations/vllm/services/vllm_deployment.py

@@ -150,7 +150,7 @@ class VLLMDeploymentService(LocalDaemonService, BaseDeploymentService):
 
         try:
             parser: argparse.ArgumentParser = make_arg_parser(
-                FlexibleArgumentParser()  # type: ignore[no-untyped-call]
+                FlexibleArgumentParser()
             )
             # pass in empty list to get default args
             # otherwise it will try to get the args from sys.argv

zenml/models/v2/core/pipeline_run.py

@@ -125,6 +125,15 @@ class PipelineRunRequest(ProjectScopedRequest):
         title="Logs of the pipeline run.",
     )
 
+    @property
+    def is_placeholder_request(self) -> bool:
+        """Whether the request is a placeholder request.
+
+        Returns:
+            Whether the request is a placeholder request.
+        """
+        return self.status == ExecutionStatus.INITIALIZING
+
     model_config = ConfigDict(protected_namespaces=())
 
 
@@ -480,6 +489,7 @@ class PipelineRunResponse(
             for step in pagination_utils.depaginate(
                 Client().list_run_steps,
                 pipeline_run_id=self.id,
+                project=self.project_id,
             )
         }