dagster 1.12.2__py3-none-any.whl → 1.12.4__py3-none-any.whl

dagster/_config/pythonic_config/conversion_utils.py

@@ -148,7 +148,8 @@ def _convert_pydantic_field(
             config=config_type,
             description=pydantic_field.description,
             is_required=pydantic_field.is_required()
-            and not is_closed_python_optional_type(field_type),
+            and not is_closed_python_optional_type(field_type)
+            and default_to_pass == FIELD_NO_DEFAULT_PROVIDED,
             default_value=default_to_pass,
         )
 

dagster/_config/pythonic_config/resource.py

@@ -704,7 +704,7 @@ class PartialResource(
         resource_cls: type[ConfigurableResourceFactory[TResValue]],
         data: dict[str, Any],
     ):
-        resource_pointers, _data_without_resources = separate_resource_params(resource_cls, data)
+        resource_pointers, data_without_resources = separate_resource_params(resource_cls, data)
 
         super().__init__(data=data, resource_cls=resource_cls)  # type: ignore  # extends BaseModel, takes kwargs
 
@@ -724,7 +724,9 @@ class PartialResource(
                 k: v for k, v in resource_pointers.items() if (not _is_fully_configured(v))
             },
             config_schema=infer_schema_from_config_class(
-                resource_cls, fields_to_omit=set(resource_pointers.keys())
+                resource_cls,
+                fields_to_omit=set(resource_pointers.keys()),
+                default=data_without_resources,
             ),
             resource_fn=resource_fn,
             description=resource_cls.__doc__,

dagster/_config/source.py

@@ -60,12 +60,17 @@ class IntSourceType(ScalarUnion):
         key, cfg = next(iter(value.items()))
         check.invariant(key == "env", "Only valid key is env")
         value = _ensure_env_variable(cfg)
+        validation_failed = False
         try:
             return int(value)
-        except ValueError as e:
+        except ValueError:
+            # raise exception separately to ensure the exception chain doesn't leak the value of the env var
+            validation_failed = True
+
+        if validation_failed:
             raise PostProcessingError(
-                f'Value "{value}" stored in env variable "{cfg}" cannot be coerced into an int.'
-            ) from e
+                f'Value stored in env variable "{cfg}" cannot be coerced into an int.'
+            )
 
 
 class BoolSourceType(ScalarUnion):
@@ -87,12 +92,18 @@ class BoolSourceType(ScalarUnion):
         key, cfg = next(iter(value.items()))
         check.invariant(key == "env", "Only valid key is env")
         value = _ensure_env_variable(cfg)
+        validation_failed = False
+
         try:
             return get_boolean_string_value(value)
-        except ValueError as e:
+        except ValueError:
+            # raise exception separately to ensure the exception chain doesn't leak the value of the env var
+            validation_failed = True
+
+        if validation_failed:
             raise PostProcessingError(
-                f'Value "{value}" stored in env variable "{cfg}" cannot be coerced into an bool.'
-            ) from e
+                f'Value stored in env variable "{cfg}" cannot be coerced into an bool.'
+            )
 
 
 StringSource: StringSourceType = StringSourceType()

dagster/_core/definitions/asset_daemon_cursor.py

@@ -11,9 +11,10 @@ from dagster_shared.serdes.serdes import (
     PackableValue,
     SerializableNonScalarKeyMapping,
     UnpackContext,
+    UnpackedValue,
     WhitelistMap,
+    inner_unpack_value,
     pack_value,
-    unpack_value,
     whitelist_for_serdes,
 )
 
@@ -53,8 +54,8 @@ class ObserveRequestTimestampSerializer(FieldSerializer):
         unpacked_value: JsonSerializableValue,
         whitelist_map: WhitelistMap,
         context: UnpackContext,
-    ) -> PackableValue:
-        return unpack_value(unpacked_value, dict, whitelist_map, context)
+    ) -> UnpackedValue:
+        return inner_unpack_value(unpacked_value, whitelist_map, context)
 
 
 @whitelist_for_serdes(

dagster/_core/definitions/asset_sensor_definition.py

@@ -14,10 +14,12 @@ from dagster._core.definitions.sensor_definition import (
     SensorDefinition,
     SensorReturnTypesUnion,
     SensorType,
+    resolve_jobs_from_targets_for_with_attributes,
     validate_and_get_resource_dict,
 )
 from dagster._core.definitions.target import ExecutableDefinition
 from dagster._core.definitions.utils import check_valid_name
+from dagster._utils import IHasInternalInit
 
 
 class AssetSensorParamNames(NamedTuple):
@@ -44,7 +46,7 @@ def get_asset_sensor_param_names(fn: Callable[..., Any]) -> AssetSensorParamName
 
 
 @public
-class AssetSensorDefinition(SensorDefinition):
+class AssetSensorDefinition(SensorDefinition, IHasInternalInit):
     """Define an asset sensor that initiates a set of runs based on the materialization of a given
     asset.
 
@@ -95,6 +97,8 @@ class AssetSensorDefinition(SensorDefinition):
         metadata: Optional[RawMetadataMapping] = None,
     ):
         self._asset_key = check.inst_param(asset_key, "asset_key", AssetKey)
+        self._asset_materialization_fn = asset_materialization_fn
+        self._job_name = job_name
 
         from dagster._core.event_api import AssetRecordsFilter
 
@@ -106,6 +110,7 @@ class AssetSensorDefinition(SensorDefinition):
             check.opt_set_param(required_resource_keys, "required_resource_keys", of_type=str)
             | resource_arg_names
         )
+        self._raw_required_resource_keys = combined_required_resource_keys
 
         def _wrap_asset_fn(materialization_fn) -> Any:
             def _fn(context) -> Any:
@@ -184,3 +189,58 @@ class AssetSensorDefinition(SensorDefinition):
     @property
     def sensor_type(self) -> SensorType:
         return SensorType.ASSET
+
+    @staticmethod
+    def dagster_internal_init(  # type: ignore
+        *,
+        name: str,
+        asset_key: AssetKey,
+        job_name: Optional[str],
+        asset_materialization_fn: Callable[..., SensorReturnTypesUnion],
+        minimum_interval_seconds: Optional[int],
+        description: Optional[str],
+        job: Optional[ExecutableDefinition],
+        jobs: Optional[Sequence[ExecutableDefinition]],
+        default_status: DefaultSensorStatus,
+        required_resource_keys: Optional[set[str]],
+        tags: Optional[Mapping[str, str]],
+        metadata: Optional[RawMetadataMapping],
+    ) -> "AssetSensorDefinition":
+        return AssetSensorDefinition(
+            name=name,
+            asset_key=asset_key,
+            job_name=job_name,
+            asset_materialization_fn=asset_materialization_fn,
+            minimum_interval_seconds=minimum_interval_seconds,
+            description=description,
+            job=job,
+            jobs=jobs,
+            default_status=default_status,
+            required_resource_keys=required_resource_keys,
+            tags=tags,
+            metadata=metadata,
+        )
+
+    def with_attributes(
+        self,
+        *,
+        jobs: Optional[Sequence[ExecutableDefinition]] = None,
+        metadata: Optional[RawMetadataMapping] = None,
+    ) -> "AssetSensorDefinition":
+        """Returns a copy of this sensor with the attributes replaced."""
+        job_name, new_job, new_jobs = resolve_jobs_from_targets_for_with_attributes(self, jobs)
+
+        return AssetSensorDefinition.dagster_internal_init(
+            name=self.name,
+            asset_key=self._asset_key,
+            job_name=job_name,
+            asset_materialization_fn=self._asset_materialization_fn,
+            minimum_interval_seconds=self.minimum_interval_seconds,
+            description=self.description,
+            job=new_job,
+            jobs=new_jobs,
+            default_status=self.default_status,
+            required_resource_keys=self._raw_required_resource_keys,
+            tags=self._tags,
+            metadata=metadata if metadata is not None else self._metadata,
+        )

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

@@ -40,9 +40,10 @@ from dagster._core.definitions.freshness_policy import LegacyFreshnessPolicy
 from dagster._core.definitions.metadata import ArbitraryMetadataMapping
 from dagster._core.definitions.partitions.definition import PartitionsDefinition
 from dagster._core.definitions.partitions.mapping import PartitionMapping
+from dagster._core.definitions.selector import ScheduleSelector, SensorSelector
 from dagster._core.definitions.utils import DEFAULT_GROUP_NAME
 from dagster._core.remote_representation.external import RemoteRepository
-from dagster._core.remote_representation.handle import InstigatorHandle, RepositoryHandle
+from dagster._core.remote_representation.handle import RepositoryHandle
 from dagster._core.workspace.workspace import CurrentWorkspace
 from dagster._record import ImportFrom, record
 from dagster._utils.cached_method import cached_method
@@ -395,31 +396,33 @@ class RemoteWorkspaceAssetNode(RemoteAssetNode):
             )
         )
 
-    def get_targeting_schedule_handles(
+    def get_targeting_schedule_selectors(
         self,
-    ) -> Sequence[InstigatorHandle]:
+    ) -> Sequence[ScheduleSelector]:
         selectors = []
         for node in self.repo_scoped_asset_infos:
             for schedule_name in node.targeting_schedule_names:
                 selectors.append(
-                    InstigatorHandle(
-                        repository_handle=node.handle,
-                        instigator_name=schedule_name,
+                    ScheduleSelector(
+                        location_name=node.handle.location_name,
+                        repository_name=node.handle.repository_name,
+                        schedule_name=schedule_name,
                     )
                 )
 
         return selectors
 
-    def get_targeting_sensor_handles(
+    def get_targeting_sensor_selectors(
         self,
-    ) -> Sequence[InstigatorHandle]:
+    ) -> Sequence[SensorSelector]:
         selectors = []
         for node in self.repo_scoped_asset_infos:
             for sensor_name in node.targeting_sensor_names:
                 selectors.append(
-                    InstigatorHandle(
-                        repository_handle=node.handle,
-                        instigator_name=sensor_name,
+                    SensorSelector(
+                        location_name=node.handle.location_name,
+                        repository_name=node.handle.repository_name,
+                        sensor_name=sensor_name,
                     )
                 )
         return selectors

dagster/_core/definitions/automation_condition_sensor_definition.py

@@ -1,4 +1,4 @@
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 from functools import partial
 from typing import Any, Optional, cast
 
@@ -16,8 +16,10 @@ from dagster._core.definitions.sensor_definition import (
     SensorEvaluationContext,
     SensorType,
 )
+from dagster._core.definitions.target import ExecutableDefinition
 from dagster._core.definitions.utils import check_valid_name
 from dagster._core.errors import DagsterInvalidInvocationError
+from dagster._utils import IHasInternalInit
 from dagster._utils.tags import normalize_tags
 
 MAX_ENTITIES = 500
@@ -79,7 +81,7 @@ def not_supported(context) -> None:
 @public
 @beta_param(param="use_user_code_server")
 @beta_param(param="default_condition")
-class AutomationConditionSensorDefinition(SensorDefinition):
+class AutomationConditionSensorDefinition(SensorDefinition, IHasInternalInit):
     """Targets a set of assets and repeatedly evaluates all the AutomationConditions on all of
     those assets to determine which to request runs for.
 
@@ -171,6 +173,8 @@ class AutomationConditionSensorDefinition(SensorDefinition):
         )
 
         self._run_tags = normalize_tags(run_tags)
+        self._sensor_target = target
+        self._emit_backfills = emit_backfills
 
         # only store this value in the metadata if it's True
         if emit_backfills:
@@ -210,3 +214,56 @@ class AutomationConditionSensorDefinition(SensorDefinition):
     @property
     def sensor_type(self) -> SensorType:
         return SensorType.AUTOMATION if self._use_user_code_server else SensorType.AUTO_MATERIALIZE
+
+    @staticmethod
+    def dagster_internal_init(  # type: ignore
+        *,
+        name: str,
+        target: CoercibleToAssetSelection,
+        tags: Optional[Mapping[str, str]],
+        run_tags: Optional[Mapping[str, Any]],
+        default_status: DefaultSensorStatus,
+        minimum_interval_seconds: Optional[int],
+        description: Optional[str],
+        metadata: Optional[RawMetadataMapping],
+        emit_backfills: bool,
+        use_user_code_server: bool,
+        default_condition: Optional[AutomationCondition],
+    ) -> "AutomationConditionSensorDefinition":
+        return AutomationConditionSensorDefinition(
+            name=name,
+            target=target,
+            tags=tags,
+            run_tags=run_tags,
+            default_status=default_status,
+            minimum_interval_seconds=minimum_interval_seconds,
+            description=description,
+            metadata=metadata,
+            emit_backfills=emit_backfills,
+            use_user_code_server=use_user_code_server,
+            default_condition=default_condition,
+        )
+
+    def with_attributes(
+        self,
+        *,
+        jobs: Optional[Sequence[ExecutableDefinition]] = None,
+        metadata: Optional[RawMetadataMapping] = None,
+    ) -> "AutomationConditionSensorDefinition":
+        """Returns a copy of this sensor with the attributes replaced.
+
+        Note: jobs parameter is ignored for AutomationConditionSensorDefinition as it doesn't use jobs.
+        """
+        return AutomationConditionSensorDefinition.dagster_internal_init(
+            name=self.name,
+            target=self._sensor_target,
+            tags=self._tags,
+            run_tags=self._run_tags,
+            default_status=self.default_status,
+            minimum_interval_seconds=self.minimum_interval_seconds,
+            description=self.description,
+            metadata=metadata if metadata is not None else self._metadata,
+            emit_backfills=self._emit_backfills,
+            use_user_code_server=self._use_user_code_server,
+            default_condition=self._default_condition,
+        )

dagster/_core/definitions/declarative_automation/automation_condition.py

@@ -15,6 +15,7 @@ from dagster._core.definitions.asset_key import (
     AssetCheckKey,
     AssetKey,
     CoercibleToAssetKey,
+    EntityKey,
     T_EntityKey,
 )
 from dagster._core.definitions.declarative_automation.serialized_objects import (
@@ -136,7 +137,9 @@ class AutomationCondition(ABC, Generic[T_EntityKey]):
         self, *, parent_unique_id: Optional[str] = None, index: Optional[int] = None
     ) -> AutomationConditionSnapshot:
         """Returns a serializable snapshot of the entire AutomationCondition tree."""
-        unique_id = self.get_node_unique_id(parent_unique_id=parent_unique_id, index=index)
+        unique_id = self.get_node_unique_id(
+            parent_unique_id=parent_unique_id, index=index, target_key=None
+        )
         node_snapshot = self.get_node_snapshot(unique_id)
         children = [
             child.get_snapshot(parent_unique_id=unique_id, index=i)
@@ -144,12 +147,22 @@ class AutomationCondition(ABC, Generic[T_EntityKey]):
         ]
         return AutomationConditionSnapshot(node_snapshot=node_snapshot, children=children)
 
-    def get_node_unique_id(self, *, parent_unique_id: Optional[str], index: Optional[int]) -> str:
+    def get_node_unique_id(
+        self,
+        *,
+        parent_unique_id: Optional[str],
+        index: Optional[int],
+        target_key: Optional[EntityKey],
+    ) -> str:
         """Returns a unique identifier for this condition within the broader condition tree."""
         return non_secure_md5_hash_str(f"{parent_unique_id}{index}{self.name}".encode())
 
     def get_backcompat_node_unique_ids(
-        self, *, parent_unique_id: Optional[str] = None, index: Optional[int] = None
+        self,
+        *,
+        parent_unique_id: Optional[str] = None,
+        index: Optional[int] = None,
+        target_key: Optional[EntityKey] = None,
     ) -> Sequence[str]:
         """Used for backwards compatibility when condition unique id logic changes."""
         return []
@@ -159,6 +172,7 @@ class AutomationCondition(ABC, Generic[T_EntityKey]):
         *,
         parent_unique_ids: Sequence[Optional[str]],
         child_indices: Sequence[Optional[int]],
+        target_key: Optional[EntityKey],
     ) -> Sequence[str]:
         unique_ids = []
         for parent_unique_id in parent_unique_ids:
@@ -166,10 +180,14 @@ class AutomationCondition(ABC, Generic[T_EntityKey]):
                 unique_ids.extend(
                     [
                         self.get_node_unique_id(
-                            parent_unique_id=parent_unique_id, index=child_index
+                            parent_unique_id=parent_unique_id,
+                            index=child_index,
+                            target_key=target_key,
                         ),
                         *self.get_backcompat_node_unique_ids(
-                            parent_unique_id=parent_unique_id, index=child_index
+                            parent_unique_id=parent_unique_id,
+                            index=child_index,
+                            target_key=target_key,
                         ),
                     ]
                 )
@@ -180,7 +198,7 @@ class AutomationCondition(ABC, Generic[T_EntityKey]):
     ) -> str:
         """Returns a unique identifier for the entire subtree."""
         node_unique_id = self.get_node_unique_id(
-            parent_unique_id=parent_node_unique_id, index=index
+            parent_unique_id=parent_node_unique_id, index=index, target_key=None
         )
         child_unique_ids = [
             child.get_unique_id(parent_node_unique_id=node_unique_id, index=i)
@@ -845,6 +863,22 @@ class BuiltinAutomationCondition(AutomationCondition[T_EntityKey]):
         """Returns a copy of this AutomationCondition with a human-readable label."""
         return copy(self, label=label)
 
+    def _get_stable_unique_id(self, target_key: Optional[EntityKey]) -> str:
+        """Returns an identifier that is stable regardless of where it exists in the broader condition tree.
+        This should only be used for conditions that don't change their output based on what conditions are
+        evaluated before them (i.e. they explicitly set their candidate subset to the entire subset).
+        """
+        child_ids = [
+            child.get_node_unique_id(
+                parent_unique_id=None,
+                index=i,
+                target_key=target_key,
+            )
+            for i, child in enumerate(self.children)
+        ]
+        parts = [self.name, *child_ids, target_key.to_user_string() if target_key else ""]
+        return non_secure_md5_hash_str("".join(parts).encode())
+
 
 @public
 @hidden_param(param="subsets_with_metadata", breaking_version="", emit_runtime_warning=False)

dagster/_core/definitions/declarative_automation/automation_context.py

@@ -73,7 +73,9 @@ class AutomationContext(Generic[T_EntityKey]):
         condition = check.not_none(
             evaluator.asset_graph.get(key).automation_condition or evaluator.default_condition
         )
-        unique_ids = condition.get_node_unique_ids(parent_unique_ids=[None], child_indices=[None])
+        unique_ids = condition.get_node_unique_ids(
+            parent_unique_ids=[None], child_indices=[None], target_key=None
+        )
 
         return AutomationContext(
             condition=condition,
@@ -101,7 +103,11 @@ class AutomationContext(Generic[T_EntityKey]):
         check.invariant(len(child_indices) > 0, "Must be at least one child index")
 
         unique_ids = child_condition.get_node_unique_ids(
-            parent_unique_ids=self.condition_unique_ids, child_indices=child_indices
+            parent_unique_ids=self.condition_unique_ids,
+            child_indices=child_indices,
+            target_key=candidate_subset.key
+            if candidate_subset.key != self.root_context.key
+            else None,
         )
         return AutomationContext(
             condition=child_condition,

dagster/_core/definitions/declarative_automation/legacy/legacy_context.py

@@ -88,7 +88,7 @@ class LegacyRuleEvaluationContext:
             condition=condition,
             cursor=cursor,
             node_cursor=cursor.node_cursors_by_unique_id.get(
-                condition.get_node_unique_id(parent_unique_id=None, index=0)
+                condition.get_node_unique_id(parent_unique_id=None, index=0, target_key=None)
             )
             if cursor
             else None,
@@ -224,17 +224,23 @@ class LegacyRuleEvaluationContext:
         # Or(MaterializeCond, Not(SkipCond), Not(DiscardCond))
         if len(self.condition.children) != 3:
             return None
-        unique_id = self.condition.get_node_unique_id(parent_unique_id=None, index=None)
+        unique_id = self.condition.get_node_unique_id(
+            parent_unique_id=None, index=None, target_key=None
+        )
 
         # get Not(DiscardCond)
         not_discard_condition = self.condition.children[2]
-        unique_id = not_discard_condition.get_node_unique_id(parent_unique_id=unique_id, index=2)
+        unique_id = not_discard_condition.get_node_unique_id(
+            parent_unique_id=unique_id, index=2, target_key=None
+        )
         if not isinstance(not_discard_condition, NotAutomationCondition):
             return None
 
         # get DiscardCond
         discard_condition = not_discard_condition.children[0]
-        unique_id = discard_condition.get_node_unique_id(parent_unique_id=unique_id, index=0)
+        unique_id = discard_condition.get_node_unique_id(
+            parent_unique_id=unique_id, index=0, target_key=None
+        )
         if not isinstance(discard_condition, RuleCondition) or not isinstance(
             discard_condition.rule, DiscardOnMaxMaterializationsExceededRule
         ):

dagster/_core/definitions/declarative_automation/legacy/rule_condition.py

@@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, Optional
 
 from dagster_shared.serdes import whitelist_for_serdes
 
-from dagster._core.definitions.asset_key import AssetKey
+from dagster._core.definitions.asset_key import AssetKey, EntityKey
 from dagster._core.definitions.auto_materialize_rule import AutoMaterializeRule
 from dagster._core.definitions.declarative_automation.automation_condition import (
     AutomationResult,
@@ -24,7 +24,13 @@ class RuleCondition(BuiltinAutomationCondition[AssetKey]):
 
     rule: AutoMaterializeRule
 
-    def get_node_unique_id(self, *, parent_unique_id: Optional[str], index: Optional[int]) -> str:
+    def get_node_unique_id(
+        self,
+        *,
+        parent_unique_id: Optional[str],
+        index: Optional[int],
+        target_key: Optional[EntityKey],
+    ) -> str:
         # preserves old (bad) behavior of not including the parent_unique_id to avoid invalidating
         # old serialized information
         parts = [self.rule.__class__.__name__, self.description]

dagster/_core/definitions/declarative_automation/operators/check_operators.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, AbstractSet, Any, Optional, Sequence  # noqa:
 from dagster_shared.serdes import whitelist_for_serdes
 
 import dagster._check as check
-from dagster._core.definitions.asset_key import AssetCheckKey, AssetKey
+from dagster._core.definitions.asset_key import AssetCheckKey, AssetKey, EntityKey
 from dagster._core.definitions.assets.graph.base_asset_graph import BaseAssetGraph, BaseAssetNode
 from dagster._core.definitions.declarative_automation.automation_condition import (
     AutomationCondition,
@@ -56,16 +56,30 @@ class ChecksAutomationCondition(BuiltinAutomationCondition[AssetKey]):
     def requires_cursor(self) -> bool:
         return False
 
-    def get_node_unique_id(self, *, parent_unique_id: Optional[str], index: Optional[int]) -> str:
+    def get_node_unique_id(
+        self,
+        *,
+        parent_unique_id: Optional[str],
+        index: Optional[int],
+        target_key: Optional[EntityKey],
+    ) -> str:
         """Ignore allow_selection / ignore_selection for the cursor hash."""
         parts = [str(parent_unique_id), str(index), self.base_name]
         return non_secure_md5_hash_str("".join(parts).encode())
 
     def get_backcompat_node_unique_ids(
-        self, *, parent_unique_id: Optional[str] = None, index: Optional[int] = None
+        self,
+        *,
+        parent_unique_id: Optional[str] = None,
+        index: Optional[int] = None,
+        target_key: Optional[EntityKey] = None,
     ) -> Sequence[str]:
         # backcompat for previous cursors where the allow/ignore selection influenced the hash
-        return [super().get_node_unique_id(parent_unique_id=parent_unique_id, index=index)]
+        return [
+            super().get_node_unique_id(
+                parent_unique_id=parent_unique_id, index=index, target_key=target_key
+            )
+        ]
 
     def allow(self, selection: "AssetSelection") -> "ChecksAutomationCondition":
         """Returns a copy of this condition that will only consider dependencies within the provided

dagster/_core/definitions/declarative_automation/operators/dep_operators.py

@@ -8,7 +8,7 @@ from typing_extensions import Self
 import dagster._check as check
 from dagster._annotations import public
 from dagster._core.asset_graph_view.asset_graph_view import U_EntityKey
-from dagster._core.definitions.asset_key import AssetKey, T_EntityKey
+from dagster._core.definitions.asset_key import AssetKey, EntityKey, T_EntityKey
 from dagster._core.definitions.assets.graph.base_asset_graph import BaseAssetGraph, BaseAssetNode
 from dagster._core.definitions.declarative_automation.automation_condition import (
     AutomationCondition,
@@ -123,16 +123,30 @@ class DepsAutomationCondition(BuiltinAutomationCondition[T_EntityKey]):
     def requires_cursor(self) -> bool:
         return False
 
-    def get_node_unique_id(self, *, parent_unique_id: Optional[str], index: Optional[int]) -> str:
+    def get_node_unique_id(
+        self,
+        *,
+        parent_unique_id: Optional[str],
+        index: Optional[int],
+        target_key: Optional[EntityKey],
+    ) -> str:
         """Ignore allow_selection / ignore_selection for the cursor hash."""
         parts = [str(parent_unique_id), str(index), self.base_name]
         return non_secure_md5_hash_str("".join(parts).encode())
 
     def get_backcompat_node_unique_ids(
-        self, *, parent_unique_id: Optional[str] = None, index: Optional[int] = None
+        self,
+        *,
+        parent_unique_id: Optional[str] = None,
+        index: Optional[int] = None,
+        target_key: Optional[EntityKey] = None,
     ) -> Sequence[str]:
         # backcompat for previous cursors where the allow/ignore selection influenced the hash
-        return [super().get_node_unique_id(parent_unique_id=parent_unique_id, index=index)]
+        return [
+            super().get_node_unique_id(
+                parent_unique_id=parent_unique_id, index=index, target_key=target_key
+            )
+        ]
 
     @public
     def allow(self, selection: "AssetSelection") -> "DepsAutomationCondition":

dagster/_core/definitions/declarative_automation/operators/newly_true_operator.py

@@ -5,7 +5,7 @@ from dagster_shared.serdes import whitelist_for_serdes
 
 from dagster._core.asset_graph_view.entity_subset import EntitySubset
 from dagster._core.asset_graph_view.serializable_entity_subset import SerializableEntitySubset
-from dagster._core.definitions.asset_key import T_EntityKey
+from dagster._core.definitions.asset_key import EntityKey, T_EntityKey
 from dagster._core.definitions.declarative_automation.automation_condition import (
     AutomationCondition,
     AutomationResult,
@@ -39,6 +39,32 @@ class NewlyTrueCondition(BuiltinAutomationCondition[T_EntityKey]):
             return None
         return context.asset_graph_view.get_subset_from_serializable_subset(true_subset)
 
+    def get_node_unique_id(
+        self,
+        *,
+        parent_unique_id: Optional[str],
+        index: Optional[int],
+        target_key: Optional[EntityKey],
+    ) -> str:
+        # newly true conditions should have stable cursoring logic regardless of where they
+        # exist in the broader condition tree, as they're always evaluated over the entire
+        # subset
+        return self._get_stable_unique_id(target_key)
+
+    def get_backcompat_node_unique_ids(
+        self,
+        *,
+        parent_unique_id: Optional[str] = None,
+        index: Optional[int] = None,
+        target_key: Optional[EntityKey] = None,
+    ) -> Sequence[str]:
+        return [
+            # get the standard globally-aware unique id for backcompat purposes
+            super().get_node_unique_id(
+                parent_unique_id=parent_unique_id, index=index, target_key=target_key
+            )
+        ]
+
     async def evaluate(self, context: AutomationContext) -> AutomationResult:  # pyright: ignore[reportIncompatibleMethodOverride]
         # evaluate child condition
         child_result = await context.for_child_condition(