zenml-nightly 0.84.3.dev20250903__tar.gz → 0.84.3.dev20250906__tar.gz

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: zenml-nightly
-Version: 0.84.3.dev20250903
+Version: 0.84.3.dev20250906
 Summary: ZenML: Write production-ready ML code.
 License: Apache-2.0
 Keywords: machine learning,production,pipeline,mlops,devops

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zenml-nightly"
-version = "0.84.3.dev20250903"
+version = "0.84.3.dev20250906"
 packages = [{ include = "zenml", from = "src" }]
 description = "ZenML: Write production-ready ML code."
 authors = ["ZenML GmbH <info@zenml.io>"]

zenml_nightly-0.84.3.dev20250906/src/zenml/VERSION

@@ -0,0 +1 @@
+0.84.3.dev20250906

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/artifacts/utils.py

@@ -178,6 +178,8 @@ def _store_artifact_data_and_prepare_request(
         # the materializer
         combined_metadata.update(metadata or {})
 
+    content_hash = materializer.compute_content_hash(data)
+
     artifact_version_request = ArtifactVersionRequest(
         artifact_name=name,
         version=version,
@@ -186,6 +188,7 @@ def _store_artifact_data_and_prepare_request(
         uri=materializer.uri,
         materializer=source_utils.resolve(materializer.__class__),
         data_type=source_utils.resolve(data_type),
+        content_hash=content_hash,
         project=Client().active_project.id,
         artifact_store_id=artifact_store.id,
         visualizations=visualizations,

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/config/__init__.py

@@ -11,18 +11,7 @@
 #  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.
-"""The `config` module contains classes and functions that manage user-specific configuration.
-
-ZenML's configuration is stored in a file called
-``config.yaml``, located on the user's directory for configuration files.
-(The exact location differs from operating system to operating system.)
-
-The ``GlobalConfiguration`` class is the main class in this module. It provides
-a Pydantic configuration object that is used to store and retrieve
-configuration. This ``GlobalConfiguration`` object handles the serialization and
-deserialization of the configuration options that are stored in the file in
-order to persist the configuration across sessions.
-"""
+"""Config classes."""
 from zenml.config.docker_settings import (
     DockerSettings,
     PythonPackageInstaller,
@@ -32,6 +21,7 @@ from zenml.config.resource_settings import ResourceSettings, ByteUnit
 from zenml.config.retry_config import StepRetryConfig
 from zenml.config.schedule import Schedule
 from zenml.config.store_config import StoreConfiguration
+from zenml.config.cache_policy import CachePolicy
 
 __all__ = [
     "DockerSettings",
@@ -42,4 +32,5 @@ __all__ = [
     "StepRetryConfig",
     "Schedule",
     "StoreConfiguration",
+    "CachePolicy",
 ]

zenml_nightly-0.84.3.dev20250906/src/zenml/config/cache_policy.py

@@ -0,0 +1,104 @@
+#  Copyright (c) ZenML GmbH 2025. 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.
+"""Cache policy."""
+
+from typing import Any, List, Optional, Union
+
+from pydantic import BaseModel, BeforeValidator, Field
+from typing_extensions import Annotated
+
+from zenml.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class CachePolicy(BaseModel):
+    """Cache policy."""
+
+    include_step_code: bool = Field(
+        default=True,
+        description="Whether to include the step code in the cache key.",
+    )
+    include_step_parameters: bool = Field(
+        default=True,
+        description="Whether to include the step parameters in the cache key.",
+    )
+    include_artifact_values: bool = Field(
+        default=True,
+        description="Whether to include the artifact values in the cache key. "
+        "If the materializer for an artifact doesn't support generating a "
+        "content hash, the artifact ID will be used as a fallback if enabled.",
+    )
+    include_artifact_ids: bool = Field(
+        default=True,
+        description="Whether to include the artifact IDs in the cache key.",
+    )
+    ignored_inputs: Optional[List[str]] = Field(
+        default=None,
+        description="List of input names to ignore in the cache key.",
+    )
+
+    @classmethod
+    def default(cls) -> "CachePolicy":
+        """Default cache policy.
+
+        Returns:
+            The default cache policy.
+        """
+        return cls(
+            include_step_code=True,
+            include_step_parameters=True,
+            include_artifact_values=True,
+            include_artifact_ids=True,
+            ignored_inputs=None,
+        )
+
+    @classmethod
+    def from_string(cls, value: str) -> "CachePolicy":
+        """Create a cache policy from a string.
+
+        Args:
+            value: The string to create a cache policy from.
+
+        Raises:
+            ValueError: If the string is not a valid cache policy.
+
+        Returns:
+            The cache policy.
+        """
+        if value.lower() == "default":
+            return cls.default()
+        else:
+            raise ValueError(f"Invalid cache policy: {value}")
+
+
+def _convert_cache_policy(value: Any) -> Any:
+    """Converts a potential cache policy string to a cache policy object.
+
+    Args:
+        value: The value to convert.
+
+    Returns:
+        The converted value.
+    """
+    if isinstance(value, str):
+        return CachePolicy.from_string(value)
+
+    return value
+
+
+CachePolicyWithValidator = Annotated[
+    CachePolicy, BeforeValidator(_convert_cache_policy)
+]
+CachePolicyOrString = Union[CachePolicy, str]

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/config/compiler.py

@@ -208,6 +208,7 @@ class Compiler:
                 model=config.model,
                 retry=config.retry,
                 parameters=config.parameters,
+                cache_policy=config.cache_policy,
             )
 
         invalid_step_configs = set(config.steps) - set(pipeline.invocations)

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/config/pipeline_configurations.py

@@ -18,6 +18,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 from pydantic import SerializeAsAny, field_validator
 
+from zenml.config.cache_policy import CachePolicyWithValidator
 from zenml.config.constants import DOCKER_SETTINGS_KEY
 from zenml.config.retry_config import StepRetryConfig
 from zenml.config.source import SourceWithValidator
@@ -51,6 +52,7 @@ class PipelineConfigurationUpdate(StrictBaseModel):
     parameters: Optional[Dict[str, Any]] = None
     retry: Optional[StepRetryConfig] = None
     substitutions: Dict[str, str] = {}
+    cache_policy: Optional[CachePolicyWithValidator] = None
 
     def finalize_substitutions(
         self, start_time: Optional[datetime] = None, inplace: bool = False

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/config/pipeline_run_configuration.py

@@ -19,6 +19,7 @@ from uuid import UUID
 from pydantic import Field, SerializeAsAny
 
 from zenml.config.base_settings import BaseSettings
+from zenml.config.cache_policy import CachePolicyWithValidator
 from zenml.config.retry_config import StepRetryConfig
 from zenml.config.schedule import Schedule
 from zenml.config.source import SourceWithValidator
@@ -55,3 +56,4 @@ class PipelineRunConfiguration(
     failure_hook_source: Optional[SourceWithValidator] = None
     success_hook_source: Optional[SourceWithValidator] = None
     substitutions: Dict[str, str] = {}
+    cache_policy: Optional[CachePolicyWithValidator] = None

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/config/step_configurations.py

@@ -37,6 +37,7 @@ from zenml.artifacts.external_artifact_config import (
 )
 from zenml.client_lazy_loader import ClientLazyLoader
 from zenml.config.base_settings import BaseSettings, SettingsOrDict
+from zenml.config.cache_policy import CachePolicy, CachePolicyWithValidator
 from zenml.config.constants import DOCKER_SETTINGS_KEY, RESOURCE_SETTINGS_KEY
 from zenml.config.retry_config import StepRetryConfig
 from zenml.config.source import Source, SourceWithValidator
@@ -155,6 +156,7 @@ class StepConfigurationUpdate(StrictBaseModel):
     model: Optional[Model] = None
     retry: Optional[StepRetryConfig] = None
     substitutions: Dict[str, str] = {}
+    cache_policy: Optional[CachePolicyWithValidator] = None
 
     outputs: Mapping[str, PartialArtifactConfiguration] = {}
 
@@ -200,6 +202,7 @@ class PartialStepConfiguration(StepConfigurationUpdate):
     model_artifacts_or_metadata: Mapping[str, ModelVersionDataLazyLoader] = {}
     client_lazy_loaders: Mapping[str, ClientLazyLoader] = {}
     outputs: Mapping[str, PartialArtifactConfiguration] = {}
+    cache_policy: CachePolicyWithValidator = CachePolicy.default()
 
     # TODO: In Pydantic v2, the `model_` is a protected namespaces for all
     #  fields defined under base models. If not handled, this raises a warning.
@@ -291,6 +294,7 @@ class StepConfiguration(PartialStepConfiguration):
                 "success_hook_source",
                 "retry",
                 "substitutions",
+                "cache_policy",
             },
             exclude_none=True,
         )
@@ -303,6 +307,7 @@ class StepConfiguration(PartialStepConfiguration):
                     "success_hook_source",
                     "retry",
                     "substitutions",
+                    "cache_policy",
                 },
                 exclude_none=True,
             )

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/integrations/airflow/orchestrators/dag_generator.py

@@ -225,7 +225,7 @@ else:
         dag_id=dag_config.id,
         is_paused_upon_creation=False,
         tags=dag_config.tags,
-        schedule_interval=dag_config.schedule,
+        schedule=dag_config.schedule,
         start_date=dag_config.start_date,
         end_date=dag_config.end_date,
         catchup=dag_config.catchup,

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator_entrypoint.py

@@ -57,7 +57,11 @@ from zenml.integrations.kubernetes.orchestrators.manifest_utils import (
 )
 from zenml.logger import get_logger
 from zenml.logging.step_logging import setup_orchestrator_logging
-from zenml.models import PipelineDeploymentResponse, PipelineRunResponse
+from zenml.models import (
+    PipelineDeploymentResponse,
+    PipelineRunResponse,
+    PipelineRunUpdate,
+)
 from zenml.orchestrators import publish_utils
 from zenml.orchestrators.step_run_utils import (
     StepRunRequestFactory,
@@ -257,7 +261,12 @@ def main() -> None:
     else:
         orchestrator_run_id = orchestrator_pod_name
         if args.run_id:
-            pipeline_run = client.get_pipeline_run(args.run_id)
+            pipeline_run = client.zen_store.update_run(
+                run_id=args.run_id,
+                run_update=PipelineRunUpdate(
+                    orchestrator_run_id=orchestrator_run_id
+                ),
+            )
         else:
             pipeline_run = create_placeholder_run(
                 deployment=deployment,

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/materializers/base_materializer.py

@@ -229,6 +229,17 @@ class BaseMaterializer(metaclass=BaseMaterializerMeta):
         # Optionally, extract some metadata from `data` for ZenML to store.
         return {}
 
+    def compute_content_hash(self, data: Any) -> Optional[str]:
+        """Compute the content hash of the given data.
+
+        Args:
+            data: The data to compute the content hash of.
+
+        Returns:
+            The content hash of the given data.
+        """
+        return None
+
     # ================
     # Internal Methods
     # ================

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/materializers/built_in_materializer.py

@@ -13,6 +13,8 @@
 #  permissions and limitations under the License.
 """Implementation of ZenML's builtin materializer."""
 
+import hashlib
+import json
 import os
 from typing import (
     TYPE_CHECKING,
@@ -138,6 +140,20 @@ class BuiltInMaterializer(BaseMaterializer):
 
         return {}
 
+    def compute_content_hash(self, data: Any) -> Optional[str]:
+        """Compute the content hash of the given data.
+
+        Args:
+            data: The data to compute the content hash of.
+
+        Returns:
+            The content hash of the given data.
+        """
+        hash_ = hashlib.md5(usedforsecurity=False)
+        hash_.update(self.__class__.__name__.encode())
+        hash_.update(json.dumps(data, sort_keys=True).encode())
+        return hash_.hexdigest()
+
 
 class BytesMaterializer(BaseMaterializer):
     """Handle `bytes` data type, which is not JSON serializable."""
@@ -189,6 +205,20 @@ class BytesMaterializer(BaseMaterializer):
         """
         return {self.data_path.replace("\\", "/"): VisualizationType.MARKDOWN}
 
+    def compute_content_hash(self, data: Any) -> Optional[str]:
+        """Compute the content hash of the given data.
+
+        Args:
+            data: The data to compute the content hash of.
+
+        Returns:
+            The content hash of the given data.
+        """
+        hash_ = hashlib.md5(usedforsecurity=False)
+        hash_.update(self.__class__.__name__.encode())
+        hash_.update(data)
+        return hash_.hexdigest()
+
 
 def _all_serializable(iterable: Iterable[Any]) -> bool:
     """For an iterable, check whether all of its elements are JSON-serializable.
@@ -224,6 +254,21 @@ def _is_serializable(obj: Any) -> bool:
     return False
 
 
+def _custom_json_converter(obj: Any) -> Any:
+    """Custom JSON converter that handles sets and tuples.
+
+    Args:
+        obj: The object to convert.
+
+    Returns:
+        The converted object.
+    """
+    if isinstance(obj, (set, tuple)):
+        return list(obj)
+
+    return obj
+
+
 def find_type_by_str(type_str: str) -> Type[Any]:
     """Get a Python type, given its string representation.
 
@@ -489,3 +534,24 @@ class BuiltInContainerMaterializer(BaseMaterializer):
         if hasattr(data, "__len__"):
             return {"length": len(data)}
         return {}
+
+    def compute_content_hash(self, data: Any) -> Optional[str]:
+        """Compute the content hash of the given data.
+
+        Args:
+            data: The data to compute the content hash of.
+
+        Returns:
+            The content hash of the given data.
+        """
+        if _is_serializable(data):
+            hash_ = hashlib.md5(usedforsecurity=False)
+            hash_.update(self.__class__.__name__.encode())
+            hash_.update(
+                json.dumps(
+                    data, sort_keys=True, default=_custom_json_converter
+                ).encode()
+            )
+            return hash_.hexdigest()
+
+        return None

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/materializers/pydantic_materializer.py

@@ -13,8 +13,10 @@
 #  permissions and limitations under the License.
 """Implementation of ZenML's pydantic materializer."""
 
+import hashlib
+import json
 import os
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, Tuple, Type
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Tuple, Type
 
 from pydantic import BaseModel
 
@@ -66,3 +68,21 @@ class PydanticMaterializer(BaseMaterializer):
             The extracted metadata as a dictionary.
         """
         return {"schema": data.schema()}
+
+    def compute_content_hash(self, data: BaseModel) -> Optional[str]:
+        """Compute the content hash of the given data.
+
+        Args:
+            data: The data to compute the content hash of.
+
+        Returns:
+            The content hash of the given data.
+        """
+        hash_ = hashlib.md5(usedforsecurity=False)
+        hash_.update(self.__class__.__name__.encode())
+
+        json_data = data.model_dump(mode="json")
+        hash_.update(json.dumps(json_data, sort_keys=True).encode())
+        return hash_.hexdigest()
+
+        return None

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/materializers/structured_string_materializer.py

@@ -13,8 +13,9 @@
 #  permissions and limitations under the License.
 """Implementation of HTMLString materializer."""
 
+import hashlib
 import os
-from typing import Dict, Type, Union
+from typing import Dict, Optional, Type, Union
 
 from zenml.enums import ArtifactType, VisualizationType
 from zenml.logger import get_logger
@@ -129,3 +130,17 @@ class StructuredStringMaterializer(BaseMaterializer):
             raise ValueError(
                 f"Data type {data_type} is not supported by this materializer."
             )
+
+    def compute_content_hash(self, data: STRUCTURED_STRINGS) -> Optional[str]:
+        """Compute the content hash of the given data.
+
+        Args:
+            data: The data to compute the content hash of.
+
+        Returns:
+            The content hash of the given data.
+        """
+        hash_ = hashlib.md5(usedforsecurity=False)
+        hash_.update(self.__class__.__name__.encode())
+        hash_.update(data.encode())
+        return hash_.hexdigest()

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/materializers/uuid_materializer.py

@@ -13,6 +13,7 @@
 #  permissions and limitations under the License.
 """Implementation of ZenML's UUID materializer."""
 
+import hashlib
 import os
 import uuid
 from typing import Any, ClassVar, Dict, Optional, Tuple, Type
@@ -77,3 +78,17 @@ class UUIDMaterializer(BaseMaterializer):
         return {
             "string_representation": str(data),
         }
+
+    def compute_content_hash(self, data: uuid.UUID) -> Optional[str]:
+        """Compute the content hash of the given data.
+
+        Args:
+            data: The data to compute the content hash of.
+
+        Returns:
+            The content hash of the given data.
+        """
+        hash_ = hashlib.md5(usedforsecurity=False)
+        hash_.update(self.__class__.__name__.encode())
+        hash_.update(data.bytes)
+        return hash_.hexdigest()

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/models/v2/core/artifact_version.py

@@ -104,6 +104,11 @@ class ArtifactVersionRequest(ProjectScopedRequest):
     data_type: SourceWithValidator = Field(
         title="Data type of the artifact.",
     )
+    content_hash: Optional[str] = Field(
+        title="The content hash of the artifact version.",
+        default=None,
+        max_length=STR_FIELD_MAX_LENGTH,
+    )
     tags: Optional[List[str]] = Field(
         title="Tags of the artifact.",
         description="Should be a list of plain strings, e.g., ['tag1', 'tag2']",
@@ -201,6 +206,10 @@ class ArtifactVersionResponseBody(ProjectScopedResponseBody):
         title="ID of the artifact store in which this artifact is stored.",
         default=None,
     )
+    content_hash: Optional[str] = Field(
+        title="The content hash of the artifact version.",
+        default=None,
+    )
 
     @field_validator("version")
     @classmethod
@@ -307,6 +316,15 @@ class ArtifactVersionResponse(
         """
         return self.get_body().type
 
+    @property
+    def content_hash(self) -> Optional[str]:
+        """The `content_hash` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_body().content_hash
+
     @property
     def tags(self) -> List[TagResponse]:
         """The `tags` property.

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/models/v2/core/pipeline_run.py

@@ -144,6 +144,7 @@ class PipelineRunUpdate(BaseUpdate):
 
     status: Optional[ExecutionStatus] = None
     end_time: Optional[datetime] = None
+    orchestrator_run_id: Optional[str] = None
     # TODO: we should maybe have a different update model here, the upper
     #  three attributes should only be for internal use
     add_tags: Optional[List[str]] = Field(

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/orchestrators/base_orchestrator.py

@@ -35,7 +35,11 @@ from zenml.constants import (
     handle_bool_env_var,
 )
 from zenml.enums import ExecutionStatus, StackComponentType
-from zenml.exceptions import RunMonitoringError, RunStoppedException
+from zenml.exceptions import (
+    IllegalOperationError,
+    RunMonitoringError,
+    RunStoppedException,
+)
 from zenml.logger import get_logger
 from zenml.metadata.metadata_types import MetadataType
 from zenml.orchestrators.publish_utils import (
@@ -485,6 +489,7 @@ class BaseOrchestrator(StackComponent, ABC):
         Raises:
             NotImplementedError: If any orchestrator inheriting from the base
                 class does not implement this logic.
+            IllegalOperationError: If the run has no orchestrator run id yet.
         """
         # Check if the orchestrator supports cancellation
         if (
@@ -496,6 +501,12 @@ class BaseOrchestrator(StackComponent, ABC):
                 "support stopping pipeline runs."
             )
 
+        if not run.orchestrator_run_id:
+            raise IllegalOperationError(
+                "Cannot stop a pipeline run that has no orchestrator run id "
+                "yet."
+            )
+
         # Update pipeline status to STOPPING before calling concrete implementation
         publish_pipeline_run_status_update(
             pipeline_run_id=run.id,

{zenml_nightly-0.84.3.dev20250903 → zenml_nightly-0.84.3.dev20250906}/src/zenml/orchestrators/cache_utils.py

@@ -14,9 +14,10 @@
 """Utilities for caching."""
 
 import hashlib
-from typing import TYPE_CHECKING, Dict, Optional
+from typing import TYPE_CHECKING, Mapping, Optional
 
 from zenml.client import Client
+from zenml.constants import CODE_HASH_PARAMETER_NAME
 from zenml.enums import ExecutionStatus, SorterOps
 from zenml.logger import get_logger
 from zenml.orchestrators import step_run_utils
@@ -27,6 +28,7 @@ if TYPE_CHECKING:
     from zenml.artifact_stores import BaseArtifactStore
     from zenml.config.step_configurations import Step
     from zenml.models import (
+        ArtifactVersionResponse,
         PipelineDeploymentResponse,
         PipelineRunResponse,
         StepRunResponse,
@@ -39,7 +41,7 @@ logger = get_logger(__name__)
 
 def generate_cache_key(
     step: "Step",
-    input_artifact_ids: Dict[str, "UUID"],
+    input_artifacts: Mapping[str, "ArtifactVersionResponse"],
     artifact_store: "BaseArtifactStore",
     project_id: "UUID",
 ) -> str:
@@ -60,13 +62,14 @@ def generate_cache_key(
 
     Args:
         step: The step to generate the cache key for.
-        input_artifact_ids: The input artifact IDs for the step.
+        input_artifacts: The input artifacts for the step.
         artifact_store: The artifact store of the active stack.
         project_id: The ID of the active project.
 
     Returns:
         A cache key.
     """
+    cache_policy = step.config.cache_policy
     hash_ = hashlib.md5()  # nosec
 
     # Project ID
@@ -85,15 +88,25 @@ def generate_cache_key(
     # when committing some unrelated files
     hash_.update(step.spec.source.import_path.encode())
 
-    # Step parameters
-    for key, value in sorted(step.config.parameters.items()):
-        hash_.update(key.encode())
-        hash_.update(str(value).encode())
+    if cache_policy.include_step_parameters:
+        for key, value in sorted(step.config.parameters.items()):
+            hash_.update(key.encode())
+            hash_.update(str(value).encode())
 
     # Input artifacts
-    for name, artifact_version_id in input_artifact_ids.items():
+    for name, artifact_version in input_artifacts.items():
+        if name in (cache_policy.ignored_inputs or []):
+            continue
+
         hash_.update(name.encode())
-        hash_.update(artifact_version_id.bytes)
+
+        if (
+            artifact_version.content_hash
+            and cache_policy.include_artifact_values
+        ):
+            hash_.update(artifact_version.content_hash.encode())
+        elif cache_policy.include_artifact_ids:
+            hash_.update(artifact_version.id.bytes)
 
     # Output artifacts and materializers
     for name, output in step.config.outputs.items():
@@ -103,6 +116,12 @@ def generate_cache_key(
 
     # Custom caching parameters
     for key, value in sorted(step.config.caching_parameters.items()):
+        if (
+            key == CODE_HASH_PARAMETER_NAME
+            and not cache_policy.include_step_code
+        ):
+            continue
+
         hash_.update(key.encode())
         hash_.update(str(value).encode())