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

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/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(

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

@@ -8,7 +8,7 @@ from typing_extensions import Self
 
 import dagster._check as check
 from dagster._annotations import public
-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,
@@ -93,6 +93,32 @@ class SinceCondition(BuiltinAutomationCondition[T_EntityKey]):
     def children(self) -> Sequence[AutomationCondition[T_EntityKey]]:
         return [self.trigger_condition, self.reset_condition]
 
+    def get_node_unique_id(
+        self,
+        *,
+        parent_unique_id: Optional[str],
+        index: Optional[int],
+        target_key: Optional[EntityKey],
+    ) -> str:
+        # since 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(  # pyright: ignore[reportIncompatibleMethodOverride]
         self, context: AutomationContext[T_EntityKey]
     ) -> AutomationResult[T_EntityKey]:

dagster/_core/definitions/selector.py

@@ -315,6 +315,10 @@ class InstigatorSelector:
     def get_id(self) -> str:
         return create_snapshot_id(self)
 
+    @property
+    def instigator_name(self) -> str:
+        return self.name
+
 
 @record
 class GraphSelector:

dagster/_core/execution/backfill.py

@@ -26,6 +26,7 @@ from dagster._core.remote_representation.external_data import job_name_for_parti
 from dagster._core.storage.dagster_run import (
     CANCELABLE_RUN_STATUSES,
     NOT_FINISHED_STATUSES,
+    DagsterRunStatus,
     RunsFilter,
 )
 from dagster._core.storage.tags import BACKFILL_ID_TAG, USER_TAG
@@ -557,9 +558,11 @@ def cancel_backfill_runs_and_cancellation_complete(
 
     while True:
         # Cancel all cancelable runs for the backfill in batches
+
+        # start with the queued runs since those will be faster to cancel
         runs_to_cancel_in_iteration = instance.run_storage.get_runs(
             filters=RunsFilter(
-                statuses=CANCELABLE_RUN_STATUSES,
+                statuses=[DagsterRunStatus.QUEUED],
                 tags={
                     BACKFILL_ID_TAG: backfill_id,
                 },
@@ -567,16 +570,38 @@ def cancel_backfill_runs_and_cancellation_complete(
             limit=CANCELABLE_RUNS_BATCH_SIZE,
             ascending=True,
         )
+
         if not runs_to_cancel_in_iteration:
-            break
+            # once all queued runs are canceled, cancel all other cancelable runs
+            runs_to_cancel_in_iteration = instance.run_storage.get_runs(
+                filters=RunsFilter(
+                    statuses=CANCELABLE_RUN_STATUSES,
+                    tags={
+                        BACKFILL_ID_TAG: backfill_id,
+                    },
+                ),
+                limit=CANCELABLE_RUNS_BATCH_SIZE,
+                ascending=True,
+            )
+            if not runs_to_cancel_in_iteration:
+                break
 
         canceled_any_runs = True
         for run in runs_to_cancel_in_iteration:
             run_id = run.run_id
             logger.info(f"Terminating submitted run {run_id}")
-            # calling cancel_run will immediately set its status to CANCELING or CANCELED,
+
+            # in both cases this will synchonrously set its status to CANCELING or CANCELED,
             # ensuring that it will not be returned in the next loop
-            instance.run_coordinator.cancel_run(run_id)
+
+            if run.status == DagsterRunStatus.QUEUED:
+                instance.report_run_canceling(
+                    run,
+                    message="Canceling run from the queue.",
+                )
+                instance.report_run_canceled(run)
+            else:
+                instance.run_launcher.terminate(run_id)
 
     if canceled_any_runs:
         # since we are canceling some runs in this iteration, we know that there is more work to do.

dagster/_core/execution/context/output.py

@@ -236,8 +236,8 @@ class OutputContext:
         """A dict of the metadata that is assigned to the output at execution time."""
         if self._warn_on_step_context_use:
             warnings.warn(
-                "You are using InputContext.upstream_output.output_metadata."
-                "Output metadata is not available when accessed from the InputContext."
+                "You are using InputContext.upstream_output.output_metadata. "
+                "Output metadata is not available when accessed from the InputContext. "
                 "https://github.com/dagster-io/dagster/issues/20094"
             )
             return {}
@@ -369,9 +369,9 @@ class OutputContext:
     def step_context(self) -> "StepExecutionContext":
         if self._warn_on_step_context_use:
             warnings.warn(
-                "You are using InputContext.upstream_output.step_context"
-                "This use on upstream_output is deprecated and will fail in the future"
-                "Try to obtain what you need directly from InputContext"
+                "You are using InputContext.upstream_output.step_context. "
+                "This use on upstream_output is deprecated and will fail in the future. "
+                "Try to obtain what you need directly from InputContext. "
                 "For more details: https://github.com/dagster-io/dagster/issues/7900"
             )
 
@@ -389,9 +389,9 @@ class OutputContext:
         """Whether the current run is a partitioned run."""
         if self._warn_on_step_context_use:
             warnings.warn(
-                "You are using InputContext.upstream_output.has_partition_key"
-                "This use on upstream_output is deprecated and will fail in the future"
-                "Try to obtain what you need directly from InputContext"
+                "You are using InputContext.upstream_output.has_partition_key. "
+                "This use on upstream_output is deprecated and will fail in the future. "
+                "Try to obtain what you need directly from InputContext. "
                 "For more details: https://github.com/dagster-io/dagster/issues/7900"
             )
 
@@ -406,9 +406,9 @@ class OutputContext:
         """
         if self._warn_on_step_context_use:
             warnings.warn(
-                "You are using InputContext.upstream_output.partition_key"
-                "This use on upstream_output is deprecated and will fail in the future"
-                "Try to obtain what you need directly from InputContext"
+                "You are using InputContext.upstream_output.partition_key. "
+                "This use on upstream_output is deprecated and will fail in the future. "
+                "Try to obtain what you need directly from InputContext. "
                 "For more details: https://github.com/dagster-io/dagster/issues/7900"
             )
 
@@ -425,9 +425,9 @@ class OutputContext:
         """Returns True if the asset being stored is partitioned."""
         if self._warn_on_step_context_use:
             warnings.warn(
-                "You are using InputContext.upstream_output.has_asset_partitions"
-                "This use on upstream_output is deprecated and will fail in the future"
-                "Try to obtain what you need directly from InputContext"
+                "You are using InputContext.upstream_output.has_asset_partitions. "
+                "This use on upstream_output is deprecated and will fail in the future. "
+                "Try to obtain what you need directly from InputContext. "
                 "For more details: https://github.com/dagster-io/dagster/issues/7900"
             )
 
@@ -446,9 +446,9 @@ class OutputContext:
         """
         if self._warn_on_step_context_use:
             warnings.warn(
-                "You are using InputContext.upstream_output.asset_partition_key"
-                "This use on upstream_output is deprecated and will fail in the future"
-                "Try to obtain what you need directly from InputContext"
+                "You are using InputContext.upstream_output.asset_partition_key. "
+                "This use on upstream_output is deprecated and will fail in the future. "
+                "Try to obtain what you need directly from InputContext. "
                 "For more details: https://github.com/dagster-io/dagster/issues/7900"
             )
 
@@ -463,9 +463,9 @@ class OutputContext:
         """
         if self._warn_on_step_context_use:
             warnings.warn(
-                "You are using InputContext.upstream_output.asset_partition_key_range"
-                "This use on upstream_output is deprecated and will fail in the future"
-                "Try to obtain what you need directly from InputContext"
+                "You are using InputContext.upstream_output.asset_partition_key_range. "
+                "This use on upstream_output is deprecated and will fail in the future. "
+                "Try to obtain what you need directly from InputContext. "
                 "For more details: https://github.com/dagster-io/dagster/issues/7900"
             )
 
@@ -480,9 +480,9 @@ class OutputContext:
         """
         if self._warn_on_step_context_use:
             warnings.warn(
-                "You are using InputContext.upstream_output.asset_partition_keys"
-                "This use on upstream_output is deprecated and will fail in the future"
-                "Try to obtain what you need directly from InputContext"
+                "You are using InputContext.upstream_output.asset_partition_keys. "
+                "This use on upstream_output is deprecated and will fail in the future. "
+                "Try to obtain what you need directly from InputContext. "
                 "For more details: https://github.com/dagster-io/dagster/issues/7900"
             )
 
@@ -503,9 +503,9 @@ class OutputContext:
         """
         if self._warn_on_step_context_use:
             warnings.warn(
-                "You are using InputContext.upstream_output.asset_partitions_time_window"
-                "This use on upstream_output is deprecated and will fail in the future"
-                "Try to obtain what you need directly from InputContext"
+                "You are using InputContext.upstream_output.asset_partitions_time_window. "
+                "This use on upstream_output is deprecated and will fail in the future. "
+                "Try to obtain what you need directly from InputContext. "
                 "For more details: https://github.com/dagster-io/dagster/issues/7900"
             )
 

dagster/_core/workspace/context.py

@@ -26,6 +26,7 @@ from dagster._core.definitions.data_version import CachingStaleStatusResolver
 from dagster._core.definitions.partitions.context import partition_loading_context
 from dagster._core.definitions.partitions.definition import PartitionsDefinition
 from dagster._core.definitions.selector import (
+    InstigatorSelector,
     JobSelector,
     JobSubsetSelector,
     RepositorySelector,
@@ -69,7 +70,7 @@ from dagster._core.remote_representation.grpc_server_state_subscriber import (
     LocationStateChangeEventType,
     LocationStateSubscriber,
 )
-from dagster._core.remote_representation.handle import InstigatorHandle, RepositoryHandle
+from dagster._core.remote_representation.handle import RepositoryHandle
 from dagster._core.snap.dagster_types import DagsterTypeSnap
 from dagster._core.snap.mode import ResourceDefSnap
 from dagster._core.snap.node import GraphDefSnap, OpDefSnap
@@ -284,6 +285,9 @@ class BaseWorkspaceRequestContext(LoadingContext):
     def viewer_has_any_owner_definition_permissions(self) -> bool:
         return False
 
+    def read_partition_subsets_from_asset_health(self) -> bool:
+        return False
+
     def get_viewer_tags(self) -> dict[str, str]:
         return {}
 
@@ -596,7 +600,7 @@ class BaseWorkspaceRequestContext(LoadingContext):
         )
 
     def get_sensor(
-        self, selector: Union[InstigatorHandle, SensorSelector]
+        self, selector: Union[SensorSelector, InstigatorSelector]
     ) -> Optional[RemoteSensor]:
         if not self.has_code_location(selector.location_name):
             return None
@@ -613,7 +617,7 @@ class BaseWorkspaceRequestContext(LoadingContext):
         return repository.get_sensor(selector.instigator_name)
 
     def get_schedule(
-        self, selector: Union[InstigatorHandle, ScheduleSelector]
+        self, selector: Union[ScheduleSelector, InstigatorSelector]
     ) -> Optional[RemoteSchedule]:
         if not self.has_code_location(selector.location_name):
             return None