zenml-nightly 0.82.0.dev20250512__py3-none-any.whl → 0.82.0.dev20250514__py3-none-any.whl

zenml/VERSION

@@ -1 +1 @@
-0.82.0.dev20250512
+0.82.0.dev20250514

zenml/cli/login.py

@@ -1061,7 +1061,7 @@ def logout(
             if clear:
                 credentials_store.clear_credentials(server_url=server)
             cli_utils.declare(
-                f"Logged out from {server}."
+                f"Logged out from {server}.\n"
                 f"Hint: You can run `zenml login '{server}'` to log in again "
                 "to the same server or 'zenml server list' to view other available "
                 "servers that you can connect to with 'zenml login <server-url>'."

zenml/config/build_configuration.py

@@ -135,6 +135,9 @@ class BuildConfiguration(BaseModel):
         Returns:
             Whether files should be included in the image.
         """
+        if self.settings.local_project_install_command:
+            return True
+
         if self.should_download_files(code_repository=code_repository):
             return False
 
@@ -153,6 +156,9 @@ class BuildConfiguration(BaseModel):
         Returns:
             Whether files should be downloaded in the image.
         """
+        if self.settings.local_project_install_command:
+            return False
+
         if self.should_download_files_from_code_repository(
             code_repository=code_repository
         ):
@@ -176,6 +182,9 @@ class BuildConfiguration(BaseModel):
         Returns:
             Whether files should be downloaded from the code repository.
         """
+        if self.settings.local_project_install_command:
+            return False
+
         if (
             code_repository
             and self.settings.allow_download_from_code_repository

zenml/config/docker_settings.py

@@ -91,12 +91,21 @@ class DockerSettings(BaseSettings):
     --------------------------------
     Depending on the configuration of this object, requirements will be
     installed in the following order (each step optional):
-    - The packages installed in your local python environment
+    - The packages installed in your local python environment (extracted using
+      `pip freeze`)
     - The packages required by the stack unless this is disabled by setting
-      `install_stack_requirements=False`.
+      `install_stack_requirements=False`
     - The packages specified via the `required_integrations`
+    - The packages defined inside a pyproject.toml file given by the
+      `pyproject_path` attribute.
     - The packages specified via the `requirements` attribute
 
+    If neither `replicate_local_python_environment`, `pyproject_path` or
+    `requirements` are specified, ZenML will try to automatically find a
+    requirements.txt or pyproject.toml file in your current source root
+    and installs packages from the first one it finds. You can disable this
+    behavior by setting `disable_automatic_requirements_detection=True`.
+
     Attributes:
         parent_image: Full name of the Docker image that should be
             used as the parent for the image that will be built. Defaults to
@@ -137,10 +146,29 @@ class DockerSettings(BaseSettings):
             packages.
         python_package_installer_args: Arguments to pass to the python package
             installer.
-        replicate_local_python_environment: If not `None`, ZenML will use the
-            specified method to generate a requirements file that replicates
-            the packages installed in the currently running python environment.
-            This requirements file will then be installed in the Docker image.
+        disable_automatic_requirements_detection: If set to True, ZenML will
+            not automatically detect requirements.txt files or pyproject.toml
+            files in your source root.
+        replicate_local_python_environment: If set to True, ZenML will run
+            `pip freeze` to gather the requirements of the local Python
+            environment and then install them in the Docker image.
+        pyproject_path: Path to a pyproject.toml file. If given, the
+            dependencies will be exported to a requirements.txt
+            formatted file using the `pyproject_export_command` and then
+            installed inside the Docker image.
+        pyproject_export_command: Command to export the dependencies inside a
+            pyproject.toml file to a requirements.txt formatted file. If not
+            given and ZenML needs to export the requirements anyway, `uv export`
+            and `poetry export` will be tried to see if one of them works. This
+            command can contain a `{directory}` placeholder which will be
+            replaced with the directory in which the pyproject.toml file is
+            stored.
+            **Note**: This command will be run before any code files are copied
+            into the image. It is therefore not possible to install a local
+            project using this command. This command should exclude any local
+            projects, and you can specify a `local_project_install_command`
+            instead which will be run after the code files are copied into the
+            image.
         requirements: Path to a requirements file or a list of required pip
             packages. During the image build, these requirements will be
             installed using pip. If you need to use a different tool to
@@ -149,13 +177,16 @@ class DockerSettings(BaseSettings):
         required_integrations: List of ZenML integrations that should be
             installed. All requirements for the specified integrations will
             be installed inside the Docker image.
-        required_hub_plugins: DEPRECATED/UNUSED.
         install_stack_requirements: If `True`, ZenML will automatically detect
             if components of your active stack are part of a ZenML integration
             and install the corresponding requirements and apt packages.
             If you set this to `False` or use custom components in your stack,
             you need to make sure these get installed by specifying them in
             the `requirements` and `apt_packages` attributes.
+        local_project_install_command: Command to install a local project in
+            the Docker image. This is run after the code files are copied into
+            the image, and it is therefore only possible when code is included
+            in the image, not downloaded at runtime.
         apt_packages: APT packages to install inside the Docker image.
         environment: Dictionary of environment variables to set inside the
             Docker image.
@@ -170,14 +201,6 @@ class DockerSettings(BaseSettings):
             from a code repository if possible.
         allow_download_from_artifact_store: If `True`, code can be downloaded
             from the artifact store.
-        build_options: DEPRECATED, use parent_image_build_config.build_options
-            instead.
-        dockerignore: DEPRECATED, use build_config.dockerignore instead.
-        copy_files: DEPRECATED/UNUSED.
-        copy_global_config: DEPRECATED/UNUSED.
-        source_files: DEPRECATED. Use allow_including_files_in_images,
-            allow_download_from_code_repository and
-            allow_download_from_artifact_store instead.
     """
 
     parent_image: Optional[str] = None
@@ -191,14 +214,18 @@ class DockerSettings(BaseSettings):
         PythonPackageInstaller.PIP
     )
     python_package_installer_args: Dict[str, Any] = {}
+    disable_automatic_requirements_detection: bool = True
     replicate_local_python_environment: Optional[
-        Union[List[str], PythonEnvironmentExportMethod]
+        Union[List[str], PythonEnvironmentExportMethod, bool]
     ] = Field(default=None, union_mode="left_to_right")
+    pyproject_path: Optional[str] = None
+    pyproject_export_command: Optional[List[str]] = None
     requirements: Union[None, str, List[str]] = Field(
         default=None, union_mode="left_to_right"
     )
     required_integrations: List[str] = []
     install_stack_requirements: bool = True
+    local_project_install_command: Optional[str] = None
     apt_packages: List[str] = []
     environment: Dict[str, Any] = {}
     user: Optional[str] = None
@@ -221,6 +248,8 @@ class DockerSettings(BaseSettings):
         "copy_global_config",
         "source_files",
         "required_hub_plugins",
+        "build_options",
+        "dockerignore",
     )
 
     @model_validator(mode="before")
@@ -305,6 +334,58 @@ class DockerSettings(BaseSettings):
 
         return self
 
+    @model_validator(mode="after")
+    def _validate_code_files_included_if_installing_local_project(
+        self,
+    ) -> "DockerSettings":
+        """Ensures that files are included when installing a local package.
+
+        Raises:
+            ValueError: If files are not included in the Docker image
+                when trying to install a local package.
+
+        Returns:
+            The validated settings values.
+        """
+        if (
+            self.local_project_install_command
+            and not self.allow_including_files_in_images
+        ):
+            raise ValueError(
+                "Files must be included in the Docker image when trying to "
+                "install a local python package. You can do so by setting "
+                "the `allow_including_files_in_images` attribute of your "
+                "DockerSettings to `True`."
+            )
+
+        return self
+
+    @model_validator(mode="after")
+    def _deprecate_replicate_local_environment_commands(
+        self,
+    ) -> "DockerSettings":
+        """Deprecates some values for `replicate_local_python_environment`.
+
+        Returns:
+            The validated settings values.
+        """
+        if isinstance(
+            self.replicate_local_python_environment,
+            (str, list, PythonEnvironmentExportMethod),
+        ):
+            logger.warning(
+                "Specifying a command (`%s`) for "
+                "`DockerSettings.replicate_local_python_environment` is "
+                "deprecated. If you want to replicate your exact local "
+                "environment using `pip freeze`, set "
+                "`DockerSettings.replicate_local_python_environment=True`. "
+                "If you want to export requirements from a pyproject.toml "
+                "file, use `DockerSettings.pyproject_path` and "
+                "`DockerSettings.pyproject_export_command` instead."
+            )
+
+        return self
+
     model_config = ConfigDict(
         # public attributes are immutable
         frozen=True,

zenml/constants.py

@@ -341,6 +341,7 @@ DEFAULT_ZENML_SERVER_REPORT_USER_ACTIVITY_TO_DB_SECONDS = 30
 DEFAULT_ZENML_SERVER_MAX_REQUEST_BODY_SIZE_IN_BYTES = 256 * 1024 * 1024
 
 DEFAULT_REPORTABLE_RESOURCES = ["project", "pipeline", "pipeline_run", "model"]
+RUN_TEMPLATE_TRIGGERS_FEATURE_NAME = "template_run"
 
 # API Endpoint paths:
 ACTIVATE = "/activate"

zenml/integrations/kubernetes/flavors/kubernetes_orchestrator_flavor.py

@@ -15,7 +15,7 @@
 
 from typing import TYPE_CHECKING, Optional, Type
 
-from pydantic import PositiveInt
+from pydantic import NonNegativeInt, PositiveInt
 
 from zenml.config.base_settings import BaseSettings
 from zenml.constants import KUBERNETES_CLUSTER_RESOURCE_TYPE
@@ -59,6 +59,14 @@ class KubernetesOrchestratorSettings(BaseSettings):
         pod_failure_backoff: The backoff factor for pod failure retries and
             pod startup retries.
         max_parallelism: Maximum number of steps to run in parallel.
+        successful_jobs_history_limit: The number of successful jobs
+            to retain. This only applies to jobs created when scheduling a
+            pipeline.
+        failed_jobs_history_limit: The number of failed jobs to retain.
+            This only applies to jobs created when scheduling a pipeline.
+        ttl_seconds_after_finished: The amount of seconds to keep finished jobs
+            before deleting them. This only applies to jobs created when
+            scheduling a pipeline.
     """
 
     synchronous: bool = True
@@ -74,6 +82,9 @@ class KubernetesOrchestratorSettings(BaseSettings):
     pod_failure_retry_delay: int = 10
     pod_failure_backoff: float = 1.0
     max_parallelism: Optional[PositiveInt] = None
+    successful_jobs_history_limit: Optional[NonNegativeInt] = None
+    failed_jobs_history_limit: Optional[NonNegativeInt] = None
+    ttl_seconds_after_finished: Optional[NonNegativeInt] = None
 
 
 class KubernetesOrchestratorConfig(

zenml/integrations/kubernetes/orchestrators/kube_utils.py

@@ -34,7 +34,7 @@ Adjusted from https://github.com/tensorflow/tfx/blob/master/tfx/utils/kube_utils
 import enum
 import re
 import time
-from typing import Any, Callable, Dict, Optional, TypeVar, cast
+from typing import Any, Callable, Dict, List, Optional, TypeVar, cast
 
 from kubernetes import client as k8s_client
 from kubernetes import config as k8s_config
@@ -554,3 +554,26 @@ def create_and_wait_for_pod_to_start(
         total_wait += delay
         time.sleep(delay)
         delay *= startup_failure_backoff
+
+
+def get_pod_owner_references(
+    core_api: k8s_client.CoreV1Api, pod_name: str, namespace: str
+) -> List[k8s_client.V1OwnerReference]:
+    """Get owner references for a pod.
+
+    Args:
+        core_api: Kubernetes CoreV1Api client.
+        pod_name: Name of the pod.
+        namespace: Kubernetes namespace.
+
+    Returns:
+        List of owner references.
+    """
+    pod = get_pod(core_api=core_api, pod_name=pod_name, namespace=namespace)
+
+    if not pod or not pod.metadata or not pod.metadata.owner_references:
+        return []
+
+    return cast(
+        List[k8s_client.V1OwnerReference], pod.metadata.owner_references
+    )

zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator.py

@@ -523,6 +523,9 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
                 pod_settings=orchestrator_pod_settings,
                 env=environment,
                 mount_local_stores=self.config.is_local,
+                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,
             )
 
             self._k8s_batch_api.create_namespaced_cron_job(

zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator_entrypoint.py

@@ -71,7 +71,7 @@ def main() -> None:
     # Parse / extract args.
     args = parse_args()
 
-    orchestrator_run_id = socket.gethostname()
+    orchestrator_pod_name = socket.gethostname()
 
     client = Client()
 
@@ -95,7 +95,22 @@ def main() -> None:
     core_api = k8s_client.CoreV1Api(kube_client)
 
     env = get_config_environment_vars()
-    env[ENV_ZENML_KUBERNETES_RUN_ID] = orchestrator_run_id
+    env[ENV_ZENML_KUBERNETES_RUN_ID] = orchestrator_pod_name
+
+    try:
+        owner_references = kube_utils.get_pod_owner_references(
+            core_api=core_api,
+            pod_name=orchestrator_pod_name,
+            namespace=args.kubernetes_namespace,
+        )
+    except Exception as e:
+        logger.warning(f"Failed to get pod owner references: {str(e)}")
+        owner_references = []
+    else:
+        # Make sure None of the owner references are marked as controllers of
+        # the created pod, which messes with the garbage collection logic.
+        for owner_reference in owner_references:
+            owner_reference.controller = False
 
     def run_step_on_kubernetes(step_name: str) -> None:
         """Run a pipeline step in a separate Kubernetes pod.
@@ -112,7 +127,7 @@ def main() -> None:
             settings.model_dump() if settings else {}
         )
 
-        if settings.pod_name_prefix and not orchestrator_run_id.startswith(
+        if settings.pod_name_prefix and not orchestrator_pod_name.startswith(
             settings.pod_name_prefix
         ):
             max_length = (
@@ -125,7 +140,7 @@ def main() -> None:
             )
             pod_name = f"{pod_name_prefix}-{step_name}"
         else:
-            pod_name = f"{orchestrator_run_id}-{step_name}"
+            pod_name = f"{orchestrator_pod_name}-{step_name}"
 
         pod_name = kube_utils.sanitize_pod_name(
             pod_name, namespace=args.kubernetes_namespace
@@ -179,6 +194,7 @@ def main() -> None:
             service_account_name=settings.step_pod_service_account_name
             or settings.service_account_name,
             mount_local_stores=mount_local_stores,
+            owner_references=owner_references,
         )
 
         kube_utils.create_and_wait_for_pod_to_start(
@@ -231,7 +247,7 @@ def main() -> None:
             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_run_id)
+                list_args = dict(orchestrator_run_id=orchestrator_pod_name)
 
             pipeline_runs = client.list_pipeline_runs(
                 hydrate=True,

zenml/integrations/kubernetes/orchestrators/manifest_utils.py

@@ -107,6 +107,7 @@ def build_pod_manifest(
     service_account_name: Optional[str] = None,
     env: Optional[Dict[str, str]] = None,
     mount_local_stores: bool = False,
+    owner_references: Optional[List[k8s_client.V1OwnerReference]] = None,
 ) -> k8s_client.V1Pod:
     """Build a Kubernetes pod manifest for a ZenML run or step.
 
@@ -125,6 +126,7 @@ def build_pod_manifest(
         env: Environment variables to set.
         mount_local_stores: Whether to mount the local stores path inside the
             pod.
+        owner_references: List of owner references for the pod.
 
     Returns:
         Pod manifest.
@@ -180,6 +182,7 @@ def build_pod_manifest(
     pod_metadata = k8s_client.V1ObjectMeta(
         name=pod_name,
         labels=labels,
+        owner_references=owner_references,
     )
 
     if pod_settings and pod_settings.annotations:
@@ -279,6 +282,9 @@ def build_cron_job_manifest(
     service_account_name: Optional[str] = None,
     env: Optional[Dict[str, str]] = None,
     mount_local_stores: bool = False,
+    successful_jobs_history_limit: Optional[int] = None,
+    failed_jobs_history_limit: Optional[int] = None,
+    ttl_seconds_after_finished: Optional[int] = None,
 ) -> k8s_client.V1CronJob:
     """Create a manifest for launching a pod as scheduled CRON job.
 
@@ -298,6 +304,10 @@ def build_cron_job_manifest(
         env: Environment variables to set.
         mount_local_stores: Whether to mount the local stores path inside the
             pod.
+        successful_jobs_history_limit: The number of successful jobs to retain.
+        failed_jobs_history_limit: The number of failed jobs to retain.
+        ttl_seconds_after_finished: The amount of seconds to keep finished jobs
+            before deleting them.
 
     Returns:
         CRON job manifest.
@@ -318,6 +328,8 @@ def build_cron_job_manifest(
 
     job_spec = k8s_client.V1CronJobSpec(
         schedule=cron_expression,
+        successful_jobs_history_limit=successful_jobs_history_limit,
+        failed_jobs_history_limit=failed_jobs_history_limit,
         job_template=k8s_client.V1JobTemplateSpec(
             metadata=pod_manifest.metadata,
             spec=k8s_client.V1JobSpec(
@@ -325,6 +337,7 @@ def build_cron_job_manifest(
                     metadata=pod_manifest.metadata,
                     spec=pod_manifest.spec,
                 ),
+                ttl_seconds_after_finished=ttl_seconds_after_finished,
             ),
         ),
     )

zenml/orchestrators/step_launcher.py

@@ -292,6 +292,10 @@ class StepLauncher:
                             artifacts=step_run.outputs,
                             model_version=model_version,
                         )
+                    step_run_utils.cascade_tags_for_output_artifacts(
+                        artifacts=step_run.outputs,
+                        tags=pipeline_run.config.tags,
+                    )
 
         except:  # noqa: E722
             logger.error(f"Pipeline run `{pipeline_run.name}` failed.")

zenml/orchestrators/step_run_utils.py

@@ -13,8 +13,9 @@
 #  permissions and limitations under the License.
 """Utilities for creating step runs."""
 
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Dict, List, Optional, Set, Tuple, Union
 
+from zenml import Tag, add_tags
 from zenml.client import Client
 from zenml.config.step_configurations import Step
 from zenml.constants import CODE_HASH_PARAMETER_NAME, TEXT_FIELD_MAX_LENGTH
@@ -333,6 +334,11 @@ def create_cached_step_runs(
                     model_version=model_version,
                 )
 
+            cascade_tags_for_output_artifacts(
+                artifacts=step_run.outputs,
+                tags=pipeline_run.config.tags,
+            )
+
             logger.info("Using cached version of step `%s`.", invocation_id)
             cached_invocations.add(invocation_id)
 
@@ -382,3 +388,26 @@ def link_output_artifacts_to_model_version(
                 artifact_version=output_artifact,
                 model_version=model_version,
             )
+
+
+def cascade_tags_for_output_artifacts(
+    artifacts: Dict[str, List[ArtifactVersionResponse]],
+    tags: Optional[List[Union[str, Tag]]] = None,
+) -> None:
+    """Tag the outputs of a step run.
+
+    Args:
+        artifacts: The step output artifacts.
+        tags: The tags to add to the artifacts.
+    """
+    if tags is None:
+        return
+
+    cascade_tags = [t for t in tags if isinstance(t, Tag) and t.cascade]
+
+    for output_artifacts in artifacts.values():
+        for output_artifact in output_artifacts:
+            add_tags(
+                tags=[t.name for t in cascade_tags],
+                artifact_version_id=output_artifact.id,
+            )

zenml/pipelines/build_utils.py

@@ -80,6 +80,11 @@ def requires_included_code(
     for step in deployment.step_configurations.values():
         docker_settings = step.config.docker_settings
 
+        if docker_settings.local_project_install_command:
+            # When installing a local package, we need to include the code
+            # files in the container image.
+            return True
+
         if docker_settings.allow_download_from_artifact_store:
             return False
 
@@ -136,6 +141,9 @@ def code_download_possible(
         Whether code download is possible for the deployment.
     """
     for step in deployment.step_configurations.values():
+        if step.config.docker_settings.local_project_install_command:
+            return False
+
         if step.config.docker_settings.allow_download_from_artifact_store:
             continue