dagster 1.12.11__py3-none-any.whl → 1.12.13__py3-none-any.whl

dagster/_cli/asset.py

@@ -43,7 +43,11 @@ def asset_cli():
 @click.option("--partition", help="Asset partition to target", required=False)
 @click.option(
     "--partition-range",
-    help="Asset partition range to target i.e. <start>...<end>",
+    help=(
+        "Asset partition range to materialize in the format <start>...<end>. "
+        "Requires all assets to have a BackfillPolicy.single_run() policy, which allows "
+        "the partition range to be executed in a single run. For example: 2025-01-01...2025-01-05"
+    ),
     required=False,
 )
 @click.option(
@@ -163,12 +167,18 @@ def execute_materialize_command(
         for asset_key in asset_keys:
             backfill_policy = implicit_job_def.asset_layer.get(asset_key).backfill_policy
             if (
-                backfill_policy is not None
-                and backfill_policy.policy_type != BackfillPolicyType.SINGLE_RUN
+                backfill_policy is None
+                or backfill_policy.policy_type != BackfillPolicyType.SINGLE_RUN
             ):
                 check.failed(
-                    "Provided partition range, but not all assets have a single-run backfill policy."
+                    "Partition ranges with the CLI require all selected assets to have a "
+                    "BackfillPolicy.single_run() policy. This allows the partition range to be "
+                    "executed in a single run. Assets without this policy would require creating "
+                    "a backfill with separate runs per partition, which needs a running daemon "
+                    "process. Consider using the Dagster UI or a running daemon to execute "
+                    "partition ranges for assets without a single-run backfill policy."
                 )
+
         try:
             implicit_job_def.validate_partition_key(
                 partition_range_start, selected_asset_keys=asset_keys, context=context
@@ -181,6 +191,7 @@ def execute_materialize_command(
                 "All selected assets must have a PartitionsDefinition containing the passed"
                 f" partition key `{partition_range_start}` or have no PartitionsDefinition."
             )
+
         tags = {
             ASSET_PARTITION_RANGE_START_TAG: partition_range_start,
             ASSET_PARTITION_RANGE_END_TAG: partition_range_end,

dagster/_cli/job.py

@@ -405,11 +405,16 @@ def execute_execute_command(
             for asset_key in job_def.asset_layer.executable_asset_keys:
                 backfill_policy = job_def.asset_layer.get(asset_key).backfill_policy
                 if (
-                    backfill_policy is not None
-                    and backfill_policy.policy_type != BackfillPolicyType.SINGLE_RUN
+                    backfill_policy is None
+                    or backfill_policy.policy_type != BackfillPolicyType.SINGLE_RUN
                 ):
                     check.failed(
-                        "Provided partition range, but not all assets have a single-run backfill policy."
+                        "Partition ranges with the CLI require all selected assets to have a "
+                        "BackfillPolicy.single_run() policy. This allows the partition range to be "
+                        "executed in a single run. Assets without this policy would require creating "
+                        "a backfill with separate runs per partition, which needs a running daemon "
+                        "process. Consider using the Dagster UI or a running daemon to execute "
+                        "partition ranges for assets without a single-run backfill policy."
                     )
             try:
                 job_def.validate_partition_key(

dagster/_core/asset_graph_view/asset_graph_view.py

@@ -21,6 +21,7 @@ from dagster._core.definitions.events import AssetKeyPartitionKey
 from dagster._core.definitions.freshness import FreshnessState
 from dagster._core.definitions.partitions.context import (
     PartitionLoadingContext,
+    partition_loading_context,
     use_partition_loading_context,
 )
 from dagster._core.definitions.partitions.definition import (
@@ -162,10 +163,7 @@ class AssetGraphView(LoadingContext):
         return self._queryer
 
     def _get_partitions_def(self, key: T_EntityKey) -> Optional["PartitionsDefinition"]:
-        if isinstance(key, AssetKey):
-            return self.asset_graph.get(key).partitions_def
-        else:
-            return None
+        return self.asset_graph.get(key).partitions_def
 
     @cached_method
     @use_partition_loading_context
@@ -374,6 +372,16 @@ class AssetGraphView(LoadingContext):
         )
         return EntitySubset(self, key=key, value=_ValidatedEntitySubsetValue(value))
 
+    @use_partition_loading_context
+    def get_subset_from_partition_keys(
+        self,
+        key: T_EntityKey,
+        partitions_def: "PartitionsDefinition",
+        partition_keys: AbstractSet[str],
+    ) -> EntitySubset[T_EntityKey]:
+        value = partitions_def.subset_with_partition_keys(partition_keys)
+        return EntitySubset(self, key=key, value=_ValidatedEntitySubsetValue(value))
+
     @use_partition_loading_context
     def compute_parent_subset_and_required_but_nonexistent_subset(
         self, parent_key, subset: EntitySubset[T_EntityKey]
@@ -548,11 +556,22 @@ class AssetGraphView(LoadingContext):
             check.failed(f"Unsupported partitions_def: {partitions_def}")
 
     async def compute_subset_with_status(
-        self, key: AssetCheckKey, status: Optional["AssetCheckExecutionResolvedStatus"]
-    ):
+        self,
+        key: AssetCheckKey,
+        status: Optional["AssetCheckExecutionResolvedStatus"],
+        from_subset: EntitySubset,
+    ) -> EntitySubset[AssetCheckKey]:
+        """Returns the subset of an asset check that matches a given status."""
         from dagster._core.storage.event_log.base import AssetCheckSummaryRecord
 
-        """Returns the subset of an asset check that matches a given status."""
+        # Handle partitioned asset checks
+        if self._get_partitions_def(key):
+            with partition_loading_context(new_ctx=self._partition_loading_context):
+                return await self._get_partitioned_check_subset_with_status(
+                    key, status, from_subset
+                )
+
+        # Handle non-partitioned asset checks with existing logic
         summary = await AssetCheckSummaryRecord.gen(self, key)
         latest_record = summary.last_check_execution_record if summary else None
         resolved_status = (
@@ -586,31 +605,64 @@ class AssetGraphView(LoadingContext):
             return self.get_empty_subset(key=key)
 
     async def _compute_run_in_progress_check_subset(
-        self, key: AssetCheckKey
+        self, key: AssetCheckKey, from_subset: EntitySubset
     ) -> EntitySubset[AssetCheckKey]:
         from dagster._core.storage.asset_check_execution_record import (
             AssetCheckExecutionResolvedStatus,
         )
 
         return await self.compute_subset_with_status(
-            key, AssetCheckExecutionResolvedStatus.IN_PROGRESS
+            key, AssetCheckExecutionResolvedStatus.IN_PROGRESS, from_subset
         )
 
     async def _compute_execution_failed_check_subset(
-        self, key: AssetCheckKey
+        self, key: AssetCheckKey, from_subset: EntitySubset
     ) -> EntitySubset[AssetCheckKey]:
         from dagster._core.storage.asset_check_execution_record import (
             AssetCheckExecutionResolvedStatus,
         )
 
         return await self.compute_subset_with_status(
-            key, AssetCheckExecutionResolvedStatus.EXECUTION_FAILED
+            key, AssetCheckExecutionResolvedStatus.EXECUTION_FAILED, from_subset
         )
 
     async def _compute_missing_check_subset(
-        self, key: AssetCheckKey
+        self, key: AssetCheckKey, from_subset: EntitySubset
+    ) -> EntitySubset[AssetCheckKey]:
+        return await self.compute_subset_with_status(key, None, from_subset)
+
+    @use_partition_loading_context
+    async def _get_partitioned_check_subset_with_status(
+        self,
+        key: AssetCheckKey,
+        status: Optional["AssetCheckExecutionResolvedStatus"],
+        from_subset: EntitySubset,
     ) -> EntitySubset[AssetCheckKey]:
-        return await self.compute_subset_with_status(key, None)
+        from dagster._core.storage.asset_check_state import AssetCheckState
+
+        check_node = self.asset_graph.get(key)
+        if not check_node or not check_node.partitions_def:
+            check.failed(f"Asset check {key} not found or not partitioned.")
+
+        cache_value = (
+            await AssetCheckState.gen(self, (key, check_node.partitions_def))
+            or AssetCheckState.empty()
+        )
+
+        if status is None:
+            known_statuses = self.get_empty_subset(key=key)
+            for serializable_subset in cache_value.subsets.values():
+                subset = self.get_subset_from_serializable_subset(serializable_subset)
+                if subset:
+                    known_statuses = known_statuses.compute_union(subset)
+            return from_subset.compute_difference(known_statuses) or self.get_empty_subset(key=key)
+        else:
+            serializable_subset = cache_value.subsets.get(status)
+            if serializable_subset is None:
+                return self.get_empty_subset(key=key)
+            return self.get_subset_from_serializable_subset(
+                serializable_subset
+            ) or self.get_empty_subset(key=key)
 
     async def _compute_run_in_progress_asset_subset(self, key: AssetKey) -> EntitySubset[AssetKey]:
         from dagster._core.storage.partition_status_cache import AssetStatusCacheValue
@@ -735,15 +787,21 @@ class AssetGraphView(LoadingContext):
             )
 
     @cached_method
-    async def compute_run_in_progress_subset(self, *, key: EntityKey) -> EntitySubset:
+    async def compute_run_in_progress_subset(
+        self, *, key: EntityKey, from_subset: EntitySubset
+    ) -> EntitySubset:
         return await _dispatch(
             key=key,
-            check_method=self._compute_run_in_progress_check_subset,
+            check_method=functools.partial(
+                self._compute_run_in_progress_check_subset, from_subset=from_subset
+            ),
             asset_method=self._compute_run_in_progress_asset_subset,
         )
 
     @cached_method
-    async def compute_backfill_in_progress_subset(self, *, key: EntityKey) -> EntitySubset:
+    async def compute_backfill_in_progress_subset(
+        self, *, key: EntityKey, from_subset: EntitySubset
+    ) -> EntitySubset:
         async def get_empty_subset(key: EntityKey) -> EntitySubset:
             return self.get_empty_subset(key=key)
 
@@ -755,10 +813,14 @@ class AssetGraphView(LoadingContext):
         )
 
     @cached_method
-    async def compute_execution_failed_subset(self, *, key: EntityKey) -> EntitySubset:
+    async def compute_execution_failed_subset(
+        self, *, key: EntityKey, from_subset: EntitySubset
+    ) -> EntitySubset:
         return await _dispatch(
             key=key,
-            check_method=self._compute_execution_failed_check_subset,
+            check_method=functools.partial(
+                self._compute_execution_failed_check_subset, from_subset=from_subset
+            ),
             asset_method=self._compute_execution_failed_asset_subset,
         )
 
@@ -768,7 +830,9 @@ class AssetGraphView(LoadingContext):
     ) -> EntitySubset:
         return await _dispatch(
             key=key,
-            check_method=self._compute_missing_check_subset,
+            check_method=functools.partial(
+                self._compute_missing_check_subset, from_subset=from_subset
+            ),
             asset_method=functools.partial(
                 self._compute_missing_asset_subset, from_subset=from_subset
             ),

dagster/_core/asset_graph_view/entity_subset.py

@@ -69,10 +69,13 @@ class EntitySubset(Generic[T_EntityKey]):
         return SerializableEntitySubset(key=self._key, value=self._value)
 
     def expensively_compute_partition_keys(self) -> AbstractSet[str]:
-        return {
-            check.not_none(akpk.partition_key, "No None partition keys")
-            for akpk in self.expensively_compute_asset_partitions()
-        }
+        internal_value = self.get_internal_value()
+        if isinstance(internal_value, PartitionsSubset):
+            return set(internal_value.get_partition_keys())
+        elif internal_value:
+            check.failed("Subset is not partitioned")
+        else:
+            return set()
 
     def expensively_compute_asset_partitions(self) -> AbstractSet[AssetKeyPartitionKey]:
         if not isinstance(self.key, AssetKey):
@@ -106,11 +109,13 @@ class EntitySubset(Generic[T_EntityKey]):
         return self._oper(other, operator.and_)
 
     def compute_intersection_with_partition_keys(
-        self: "EntitySubset[AssetKey]", partition_keys: AbstractSet[str]
-    ) -> "EntitySubset[AssetKey]":
-        key = check.inst(self.key, AssetKey)
-        partition_subset = self._asset_graph_view.get_asset_subset_from_asset_partitions(
-            self.key, {AssetKeyPartitionKey(key, pk) for pk in partition_keys}
+        self: "EntitySubset[T_EntityKey]", partition_keys: AbstractSet[str]
+    ) -> "EntitySubset[T_EntityKey]":
+        if self.partitions_def is None:
+            return self._asset_graph_view.get_empty_subset(key=self.key)
+
+        partition_subset = self._asset_graph_view.get_subset_from_partition_keys(
+            self.key, self.partitions_def, partition_keys
         )
         return self.compute_intersection(partition_subset)
 

dagster/_core/asset_graph_view/serializable_entity_subset.py

@@ -50,6 +50,12 @@ class SerializableEntitySubset(Generic[T_EntityKey]):
     key: T_EntityKey
     value: EntitySubsetValue
 
+    @classmethod
+    def empty(
+        cls, key: T_EntityKey, partitions_def: Optional[PartitionsDefinition]
+    ) -> "SerializableEntitySubset[T_EntityKey]":
+        return cls(key=key, value=partitions_def.empty_subset() if partitions_def else False)
+
     @classmethod
     def from_coercible_value(
         cls,
@@ -132,6 +138,10 @@ class SerializableEntitySubset(Generic[T_EntityKey]):
     def is_compatible_with_partitions_def(
         self, partitions_def: Optional[PartitionsDefinition]
     ) -> bool:
+        from dagster._core.definitions.partitions.definition.time_window import (
+            TimeWindowPartitionsDefinition,
+        )
+
         if self.is_partitioned:
             # for some PartitionSubset types, we have access to the underlying partitions
             # definitions, so we can ensure those are identical
@@ -150,6 +160,11 @@ class SerializableEntitySubset(Generic[T_EntityKey]):
                     and partitions_def.has_partition_key(r.end)
                     for r in self.value.key_ranges
                 )
+            elif isinstance(self.value, DefaultPartitionsSubset) and isinstance(
+                partitions_def, TimeWindowPartitionsDefinition
+            ):
+                return all(partitions_def.has_partition_key(k) for k in self.value.subset)
+
             else:
                 return partitions_def is not None
         else:

dagster/_core/code_pointer.py

@@ -2,6 +2,7 @@ import importlib
 import inspect
 import os
 import sys
+import uuid
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Sequence
 from pathlib import Path
@@ -59,7 +60,11 @@ def rebase_file(relative_path_in_file: str, file_path_resides_in: str) -> str:
     )
 
 
-def load_python_file(python_file: Union[str, Path], working_directory: Optional[str]) -> ModuleType:
+def load_python_file(
+    python_file: Union[str, Path],
+    working_directory: Optional[str],
+    add_uuid_suffix: bool = False,
+) -> ModuleType:
     """Takes a path to a python file and returns a loaded module."""
     check.inst_param(python_file, "python_file", (str, Path))
     check.opt_str_param(working_directory, "working_directory")
@@ -68,6 +73,8 @@ def load_python_file(python_file: Union[str, Path], working_directory: Optional[
     os.stat(python_file)
 
     module_name = os.path.splitext(os.path.basename(python_file))[0]
+    if add_uuid_suffix:
+        module_name = f"{module_name}_{uuid.uuid4().hex}"
 
     # Use the passed in working directory for local imports (sys.path[0] isn't
     # consistently set in the different entry points that Dagster uses to import code)

dagster/_core/definitions/asset_checks/asset_check_evaluation.py

@@ -1,34 +1,27 @@
 from collections.abc import Mapping
-from typing import NamedTuple, Optional
+from typing import Optional
+
+import dagster_shared.check as check
+from dagster_shared.record import IHaveNew, record, record_custom, replace
 
-import dagster._check as check
 from dagster._core.definitions.asset_checks.asset_check_spec import (
     AssetCheckKey,
     AssetCheckSeverity,
 )
 from dagster._core.definitions.events import AssetKey, MetadataValue, RawMetadataValue
 from dagster._core.definitions.metadata import normalize_metadata
+from dagster._core.definitions.partitions.subset import PartitionsSubset
 from dagster._serdes import whitelist_for_serdes
 
 
 @whitelist_for_serdes
-class AssetCheckEvaluationPlanned(
-    NamedTuple(
-        "_AssetCheckEvaluationPlanned",
-        [
-            ("asset_key", AssetKey),
-            ("check_name", str),
-        ],
-    )
-):
+@record
+class AssetCheckEvaluationPlanned:
     """Metadata for the event when an asset check is launched."""
 
-    def __new__(cls, asset_key: AssetKey, check_name: str):
-        return super().__new__(
-            cls,
-            asset_key=check.inst_param(asset_key, "asset_key", AssetKey),
-            check_name=check.str_param(check_name, "check_name"),
-        )
+    asset_key: AssetKey
+    check_name: str
+    partitions_subset: Optional[PartitionsSubset] = None
 
     @property
     def asset_check_key(self) -> AssetCheckKey:
@@ -36,46 +29,18 @@ class AssetCheckEvaluationPlanned(
 
 
 @whitelist_for_serdes
-class AssetCheckEvaluationTargetMaterializationData(
-    NamedTuple(
-        "_AssetCheckEvaluationTargetMaterializationData",
-        [
-            ("storage_id", int),
-            ("run_id", str),
-            ("timestamp", float),
-        ],
-    )
-):
+@record
+class AssetCheckEvaluationTargetMaterializationData:
     """A pointer to the latest materialization at execution time of an asset check."""
 
-    def __new__(cls, storage_id: int, run_id: str, timestamp: float):
-        return super().__new__(
-            cls,
-            storage_id=check.int_param(storage_id, "storage_id"),
-            run_id=check.str_param(run_id, "run_id"),
-            timestamp=check.float_param(timestamp, "timestamp"),
-        )
+    storage_id: int
+    run_id: str
+    timestamp: float
 
 
 @whitelist_for_serdes(storage_field_names={"passed": "success"})
-class AssetCheckEvaluation(
-    NamedTuple(
-        "_AssetCheckEvaluation",
-        [
-            ("asset_key", AssetKey),
-            ("check_name", str),
-            ("passed", bool),
-            ("metadata", Mapping[str, MetadataValue]),
-            (
-                "target_materialization_data",
-                Optional[AssetCheckEvaluationTargetMaterializationData],
-            ),
-            ("severity", AssetCheckSeverity),
-            ("description", Optional[str]),
-            ("blocking", Optional[bool]),
-        ],
-    )
-):
+@record_custom
+class AssetCheckEvaluation(IHaveNew):
     """Represents the outcome of a evaluating an asset check.
 
     Args:
@@ -97,8 +62,20 @@ class AssetCheckEvaluation(
             A text description of the result of the check evaluation.
         blocking (Optional[bool]):
             Whether the check is blocking.
+        partition (Optional[str]):
+            The partition that the check was evaluated on, if applicable.
     """
 
+    asset_key: AssetKey
+    check_name: str
+    passed: bool
+    metadata: Mapping[str, MetadataValue]
+    target_materialization_data: Optional[AssetCheckEvaluationTargetMaterializationData]
+    severity: AssetCheckSeverity
+    description: Optional[str]
+    blocking: Optional[bool]
+    partition: Optional[str]
+
     def __new__(
         cls,
         asset_key: AssetKey,
@@ -109,25 +86,21 @@ class AssetCheckEvaluation(
         severity: AssetCheckSeverity = AssetCheckSeverity.ERROR,
         description: Optional[str] = None,
         blocking: Optional[bool] = None,
+        partition: Optional[str] = None,
     ):
-        normed_metadata = normalize_metadata(
-            check.opt_mapping_param(metadata, "metadata", key_type=str),
-        )
-
         return super().__new__(
             cls,
-            asset_key=check.inst_param(asset_key, "asset_key", AssetKey),
-            check_name=check.str_param(check_name, "check_name"),
-            passed=check.bool_param(passed, "passed"),
-            metadata=normed_metadata,
-            target_materialization_data=check.opt_inst_param(
-                target_materialization_data,
-                "target_materialization_data",
-                AssetCheckEvaluationTargetMaterializationData,
+            asset_key=asset_key,
+            check_name=check_name,
+            passed=passed,
+            metadata=normalize_metadata(
+                check.opt_mapping_param(metadata, "metadata", key_type=str)
             ),
-            severity=check.inst_param(severity, "severity", AssetCheckSeverity),
-            description=check.opt_str_param(description, "description"),
-            blocking=check.opt_bool_param(blocking, "blocking"),
+            target_materialization_data=target_materialization_data,
+            severity=severity,
+            description=description,
+            blocking=blocking,
+            partition=partition,
         )
 
     @property
@@ -138,4 +111,4 @@ class AssetCheckEvaluation(
         normed_metadata = normalize_metadata(
             check.opt_mapping_param(metadata, "metadata", key_type=str),
         )
-        return self._replace(metadata=normed_metadata)
+        return replace(self, metadata=normed_metadata)

dagster/_core/definitions/asset_checks/asset_check_result.py

@@ -172,6 +172,15 @@ class AssetCheckResult(
         else:
             target_materialization_data = None
 
+        if step_context.has_partition_key:
+            check_spec = assets_def_for_check.get_spec_for_check_key(check_key)
+            if check_spec.partitions_def is not None:
+                partition = step_context.partition_key
+            else:
+                partition = None
+        else:
+            partition = None
+
         return AssetCheckEvaluation(
             check_name=check_key.name,
             asset_key=check_key.asset_key,
@@ -181,6 +190,7 @@ class AssetCheckResult(
             severity=self.severity,
             description=self.description,
             blocking=assets_def_for_check.get_spec_for_check_key(check_key).blocking,
+            partition=partition,
         )
 
     def with_metadata(self, metadata: Mapping[str, RawMetadataValue]) -> "AssetCheckResult":  # pyright: ignore[reportIncompatibleMethodOverride]

dagster/_core/definitions/asset_checks/asset_check_spec.py

@@ -10,9 +10,11 @@ from dagster_shared.record import (
     replace,
 )
 from dagster_shared.serdes import whitelist_for_serdes
+from dagster_shared.utils.warnings import preview_warning
 
 from dagster._annotations import PublicAttr, public
 from dagster._core.definitions.asset_key import AssetCheckKey, AssetKey, CoercibleToAssetKey
+from dagster._core.definitions.partitions.definition import PartitionsDefinition
 
 if TYPE_CHECKING:
     from dagster._core.definitions.assets.definition.asset_dep import AssetDep, CoercibleToAssetDep
@@ -58,6 +60,7 @@ class AssetCheckSpec(IHaveNew, LegacyNamedTupleMixin):
     blocking: PublicAttr[bool]
     metadata: PublicAttr[Mapping[str, Any]]
     automation_condition: PublicAttr[Optional[LazyAutomationCondition]]
+    partitions_def: PublicAttr[Optional[PartitionsDefinition]]
 
     """Defines information about an asset check, except how to execute it.
 
@@ -80,6 +83,9 @@ class AssetCheckSpec(IHaveNew, LegacyNamedTupleMixin):
             that multi-asset is responsible for enforcing that downstream assets within the
             same step do not execute after a blocking asset check fails.
         metadata (Optional[Mapping[str, Any]]):  A dict of static metadata for this asset check.
+        automation_condition (Optional[AutomationCondition[AssetCheckKey]]): The AutomationCondition for this asset check.
+        partitions_def (Optional[PartitionsDefinition]): The PartitionsDefinition for this asset check. Must be either None
+            or the same as the PartitionsDefinition of the asset specified by `asset`.
     """
 
     def __new__(
@@ -92,11 +98,15 @@ class AssetCheckSpec(IHaveNew, LegacyNamedTupleMixin):
         blocking: bool = False,
         metadata: Optional[Mapping[str, Any]] = None,
         automation_condition: Optional["AutomationCondition[AssetCheckKey]"] = None,
+        partitions_def: Optional[PartitionsDefinition] = None,
     ):
         from dagster._core.definitions.assets.definition.asset_dep import (
             coerce_to_deps_and_check_duplicates,
         )
 
+        if partitions_def is not None:
+            preview_warning("Specifying a partitions_def on an AssetCheckSpec")
+
         asset_key = AssetKey.from_coercible_or_definition(asset)
 
         additional_asset_deps = coerce_to_deps_and_check_duplicates(
@@ -119,6 +129,7 @@ class AssetCheckSpec(IHaveNew, LegacyNamedTupleMixin):
             blocking=blocking,
             metadata=metadata or {},
             automation_condition=automation_condition,
+            partitions_def=partitions_def,
         )
 
     def get_python_identifier(self) -> str:

dagster/_core/definitions/assets/graph/asset_graph.py

@@ -189,6 +189,7 @@ class AssetGraph(BaseAssetGraph[AssetNode]):
                 v.get_spec_for_check_key(k).description,
                 v.get_spec_for_check_key(k).automation_condition,
                 v.get_spec_for_check_key(k).metadata,
+                v.get_spec_for_check_key(k).partitions_def,
             )
             for k, v in assets_defs_by_check_key.items()
         }

dagster/_core/definitions/assets/graph/base_asset_graph.py

@@ -217,6 +217,7 @@ class AssetCheckNode(BaseEntityNode[AssetCheckKey]):
         description: Optional[str],
         automation_condition: Optional["AutomationCondition[AssetCheckKey]"],
         metadata: ArbitraryMetadataMapping,
+        partitions_def: Optional[PartitionsDefinition],
     ):
         self.key = key
         self.blocking = blocking
@@ -224,6 +225,7 @@ class AssetCheckNode(BaseEntityNode[AssetCheckKey]):
         self._additional_deps = additional_deps
         self._description = description
         self._metadata = metadata
+        self._partitions_def = partitions_def
 
     @property
     def parent_entity_keys(self) -> AbstractSet[AssetKey]:
@@ -235,8 +237,7 @@ class AssetCheckNode(BaseEntityNode[AssetCheckKey]):
 
     @property
     def partitions_def(self) -> Optional[PartitionsDefinition]:
-        # all checks are unpartitioned
-        return None
+        return self._partitions_def
 
     @property
     def partition_mappings(self) -> Mapping[EntityKey, PartitionMapping]:
@@ -266,6 +267,10 @@ class BaseAssetGraph(ABC, Generic[T_AssetNode]):
     def asset_nodes(self) -> Iterable[T_AssetNode]:
         return self._asset_nodes_by_key.values()
 
+    @property
+    def asset_check_nodes(self) -> Iterable[AssetCheckNode]:
+        return self._asset_check_nodes_by_key.values()
+
     @property
     def nodes(self) -> Iterable[BaseEntityNode]:
         return [
@@ -668,6 +673,28 @@ class BaseAssetGraph(ABC, Generic[T_AssetNode]):
                         f"Invalid partition mapping from {node.key.to_user_string()} to {parent.key.to_user_string()}"
                     ) from e
 
+        # Validate that asset checks have compatible partitions_def with their target asset
+        for node in self.asset_check_nodes:
+            if node.partitions_def is None:
+                continue
+
+            target_asset_key = node.key.asset_key
+            if not self.has(target_asset_key):
+                raise DagsterInvalidDefinitionError(
+                    f"Partitioned asset check '{node.key.to_user_string()}' targets "
+                    f"asset '{target_asset_key.to_user_string()}' "
+                    "but the asset does not exist in the graph."
+                )
+            # If the check is partitioned, it must have the same partitions_def as the asset
+            if node.partitions_def != self.get(target_asset_key).partitions_def:
+                raise DagsterInvalidDefinitionError(
+                    f"Asset check '{node.key.to_user_string()}' targets asset '{target_asset_key.to_user_string()}' "
+                    "but has a different partitions definition. "
+                    f"Asset check partitions_def: {node.partitions_def}, "
+                    f"Asset partitions_def: {self.get(target_asset_key).partitions_def}. "
+                    "Partitioned asset checks must have the same partitions definition as their target asset."
+                )
+
     def upstream_key_iterator(self, asset_key: AssetKey) -> Iterator[AssetKey]:
         """Iterates through all asset keys which are upstream of the given key."""
         visited: set[AssetKey] = set()