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

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/metadata/metadata_value.py

@@ -1,10 +1,10 @@
+import json
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Mapping, Sequence
 from datetime import datetime
 from os import PathLike
 from typing import Any, Generic, Optional, Union
 
-import dagster_shared.seven as seven
 from dagster_shared.record import IHaveNew, LegacyNamedTupleMixin, record, record_custom
 from dagster_shared.serdes.serdes import (
     FieldSerializer,
@@ -668,8 +668,9 @@ class JsonMetadataValue(
 
     def __new__(cls, data: Optional[Union[Sequence[Any], Mapping[str, Any]]]):
         try:
-            # check that the value is JSON serializable
-            seven.dumps(data)
+            # check that the value is JSON serializable (and do any transformation
+            # that json.dumps would do under the hood, like enums to string values)
+            data = json.loads(json.dumps(data))
         except TypeError:
             raise DagsterInvalidMetadata("Value is not JSON serializable.")
         return super().__new__(cls, data=data)

dagster/_core/definitions/multi_asset_sensor_definition.py

@@ -22,6 +22,7 @@ from dagster._core.definitions.sensor_definition import (
     SensorType,
     get_context_param_name,
     get_sensor_context_from_args_or_kwargs,
+    resolve_jobs_from_targets_for_with_attributes,
     validate_and_get_resource_dict,
 )
 from dagster._core.definitions.target import ExecutableDefinition
@@ -33,7 +34,7 @@ from dagster._core.errors import (
 )
 from dagster._core.instance import DagsterInstance
 from dagster._core.instance.ref import InstanceRef
-from dagster._utils import normalize_to_repository
+from dagster._utils import IHasInternalInit, normalize_to_repository
 from dagster._utils.warnings import deprecation_warning, normalize_renamed_param
 
 if TYPE_CHECKING:
@@ -1103,7 +1104,7 @@ MultiAssetMaterializationFunction = Callable[
     "multi_asset_sensors may be used."
 )
 @public
-class MultiAssetSensorDefinition(SensorDefinition):
+class MultiAssetSensorDefinition(SensorDefinition, IHasInternalInit):
     """Define an asset sensor that initiates a set of runs based on the materialization of a list of
     assets.
 
@@ -1245,6 +1246,9 @@ class MultiAssetSensorDefinition(SensorDefinition):
             return _fn
 
         self._raw_asset_materialization_fn = asset_materialization_fn
+        self._monitored_assets = monitored_assets
+        self._job_name = job_name
+        self._raw_required_resource_keys = combined_required_resource_keys
 
         super().__init__(
             name=check_valid_name(name),
@@ -1288,3 +1292,61 @@ class MultiAssetSensorDefinition(SensorDefinition):
     @property
     def sensor_type(self) -> SensorType:
         return SensorType.MULTI_ASSET
+
+    @staticmethod
+    def dagster_internal_init(  # type: ignore
+        *,
+        name: str,
+        monitored_assets: Union[Sequence[AssetKey], AssetSelection],
+        job_name: Optional[str],
+        asset_materialization_fn: MultiAssetMaterializationFunction,
+        minimum_interval_seconds: Optional[int],
+        description: Optional[str],
+        job: Optional[ExecutableDefinition],
+        jobs: Optional[Sequence[ExecutableDefinition]],
+        default_status: DefaultSensorStatus,
+        request_assets: Optional[AssetSelection],
+        required_resource_keys: Optional[set[str]],
+        tags: Optional[Mapping[str, str]],
+        metadata: Optional[RawMetadataMapping],
+    ) -> "MultiAssetSensorDefinition":
+        return MultiAssetSensorDefinition(
+            name=name,
+            monitored_assets=monitored_assets,
+            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,
+            request_assets=request_assets,
+            required_resource_keys=required_resource_keys,
+            tags=tags,
+            metadata=metadata,
+        )
+
+    def with_attributes(
+        self,
+        *,
+        jobs: Optional[Sequence[ExecutableDefinition]] = None,
+        metadata: Optional[RawMetadataMapping] = None,
+    ) -> "MultiAssetSensorDefinition":
+        """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 MultiAssetSensorDefinition.dagster_internal_init(
+            name=self.name,
+            monitored_assets=self._monitored_assets,
+            job_name=job_name,
+            asset_materialization_fn=self._raw_asset_materialization_fn,
+            minimum_interval_seconds=self.minimum_interval_seconds,
+            description=self.description,
+            job=new_job,
+            jobs=new_jobs,
+            default_status=self.default_status,
+            request_assets=self.asset_selection,
+            required_resource_keys=self._raw_required_resource_keys,
+            tags=self._tags,
+            metadata=metadata if metadata is not None else self._metadata,
+        )

dagster/_core/definitions/op_definition.py

@@ -1,4 +1,5 @@
 import inspect
+import re
 from collections.abc import Iterator, Mapping, Sequence, Set
 from typing import (  # noqa: UP035
     TYPE_CHECKING,
@@ -36,7 +37,7 @@ from dagster._core.definitions.resource_requirement import (
     ResourceRequirement,
 )
 from dagster._core.definitions.result import MaterializeResult, ObserveResult
-from dagster._core.definitions.utils import DEFAULT_IO_MANAGER_KEY, check_valid_chars
+from dagster._core.definitions.utils import DEFAULT_IO_MANAGER_KEY
 from dagster._core.errors import (
     DagsterInvalidDefinitionError,
     DagsterInvalidInvocationError,
@@ -611,12 +612,19 @@ def _is_result_object_type(ttype):
     return ttype in (MaterializeResult, ObserveResult, AssetCheckResult)
 
 
+VALID_POOL_NAME_REGEX_STR = r"^[A-Za-z0-9_\/]+$"  # standard name regex with slashes
+VALID_POOL_NAME_REGEX = re.compile(VALID_POOL_NAME_REGEX_STR)
+
+
 def _validate_pool(pool, tags):
     check.opt_str_param(pool, "pool")
     if not pool:
         return None
 
-    check_valid_chars(pool)
+    if not VALID_POOL_NAME_REGEX.match(pool):
+        raise DagsterInvalidDefinitionError(
+            f'Pool "{pool}" is not a valid pool name. It must match the regex {VALID_POOL_NAME_REGEX_STR}.'
+        )
 
     tags = check.opt_mapping_param(tags, "tags")
     tag_concurrency_key = tags.get(GLOBAL_CONCURRENCY_TAG)

dagster/_core/definitions/reconstruct.py

@@ -154,9 +154,6 @@ class ReconstructableRepository(
             container_context=self.container_context,
         )
 
-    def get_python_origin_id(self) -> str:
-        return self.get_python_origin().get_id()
-
     # Allow this to be hashed for use in `lru_cache`. This is needed because:
     # - `ReconstructableJob` uses `lru_cache`
     # - `ReconstructableJob` has a `ReconstructableRepository` attribute
@@ -313,9 +310,6 @@ class ReconstructableJob(  # pyright: ignore[reportIncompatibleVariableOverride]
     def get_python_origin(self) -> JobPythonOrigin:
         return JobPythonOrigin(self.job_name, self.repository.get_python_origin())
 
-    def get_python_origin_id(self) -> str:
-        return self.get_python_origin().get_id()
-
     def get_module(self) -> Optional[str]:
         """Return the module the job is found in, the origin is a module code pointer."""
         pointer = self.get_python_origin().get_repo_pointer()

dagster/_core/definitions/run_status_sensor_definition.py

@@ -30,6 +30,7 @@ from dagster._core.definitions.sensor_definition import (
     SkipReason,
     get_context_param_name,
     get_or_create_sensor_context,
+    resolve_jobs_from_targets_for_with_attributes,
     validate_and_get_resource_dict,
 )
 from dagster._core.definitions.target import ExecutableDefinition
@@ -46,6 +47,7 @@ from dagster._core.instance import DagsterInstance
 from dagster._core.storage.dagster_run import DagsterRun, DagsterRunStatus, RunsFilter
 from dagster._serdes import serialize_value, whitelist_for_serdes
 from dagster._time import datetime_from_timestamp, parse_time_string
+from dagster._utils import IHasInternalInit
 from dagster._utils.error import serializable_error_info_from_exc_info
 from dagster._utils.warnings import normalize_renamed_param
 
@@ -583,7 +585,7 @@ def run_failure_sensor(
 
 
 @public
-class RunStatusSensorDefinition(SensorDefinition):
+class RunStatusSensorDefinition(SensorDefinition, IHasInternalInit):
     """Define a sensor that reacts to a given status of job execution, where the decorated
     function will be evaluated when a run is at the given status.
 
@@ -685,6 +687,10 @@ class RunStatusSensorDefinition(SensorDefinition):
         self._run_status_sensor_fn = check.callable_param(
             run_status_sensor_fn, "run_status_sensor_fn"
         )
+        self._run_status = run_status
+        self._monitored_jobs = monitored_jobs
+        self._monitor_all_code_locations = monitor_all_code_locations
+        self._raw_required_resource_keys = combined_required_resource_keys
         event_type = PIPELINE_RUN_STATUS_TO_EVENT_TYPE[run_status]
 
         # split monitored_jobs into external repos, external jobs, and jobs in the current repo
@@ -1024,6 +1030,78 @@ class RunStatusSensorDefinition(SensorDefinition):
     def sensor_type(self) -> SensorType:
         return SensorType.RUN_STATUS
 
+    @staticmethod
+    def dagster_internal_init(  # type: ignore
+        *,
+        name: str,
+        run_status: DagsterRunStatus,
+        run_status_sensor_fn: RunStatusSensorEvaluationFunction,
+        minimum_interval_seconds: Optional[int],
+        description: Optional[str],
+        monitored_jobs: Optional[
+            Sequence[
+                Union[
+                    JobDefinition,
+                    GraphDefinition,
+                    UnresolvedAssetJobDefinition,
+                    "RepositorySelector",
+                    "JobSelector",
+                    "CodeLocationSelector",
+                ]
+            ]
+        ],
+        monitor_all_code_locations: Optional[bool],
+        default_status: DefaultSensorStatus,
+        request_job: Optional[ExecutableDefinition],
+        request_jobs: Optional[Sequence[ExecutableDefinition]],
+        tags: Optional[Mapping[str, str]],
+        metadata: Optional[RawMetadataMapping],
+        required_resource_keys: Optional[set[str]],
+    ) -> "RunStatusSensorDefinition":
+        return RunStatusSensorDefinition(
+            name=name,
+            run_status=run_status,
+            run_status_sensor_fn=run_status_sensor_fn,
+            minimum_interval_seconds=minimum_interval_seconds,
+            description=description,
+            monitored_jobs=monitored_jobs,
+            monitor_all_code_locations=monitor_all_code_locations,
+            default_status=default_status,
+            request_job=request_job,
+            request_jobs=request_jobs,
+            tags=tags,
+            metadata=metadata,
+            required_resource_keys=required_resource_keys,
+        )
+
+    def with_attributes(
+        self,
+        *,
+        jobs: Optional[Sequence[ExecutableDefinition]] = None,
+        metadata: Optional[RawMetadataMapping] = None,
+    ) -> "RunStatusSensorDefinition":
+        """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)
+
+        # We need to store the run_status and monitored_jobs for reconstruction
+        # Extract monitored_jobs from the wrapped function's closure if possible
+        # For now, we'll need to access the stored attributes
+        return RunStatusSensorDefinition.dagster_internal_init(
+            name=self.name,
+            run_status=self._run_status,
+            run_status_sensor_fn=self._run_status_sensor_fn,
+            minimum_interval_seconds=self.minimum_interval_seconds,
+            description=self.description,
+            monitored_jobs=self._monitored_jobs,
+            monitor_all_code_locations=self._monitor_all_code_locations,
+            default_status=self.default_status,
+            request_job=new_job,
+            request_jobs=new_jobs,
+            tags=self._tags,
+            metadata=metadata if metadata is not None else self._metadata,
+            required_resource_keys=self._raw_required_resource_keys,
+        )
+
 
 @deprecated_param(
     param="job_selection",

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/definitions/sensor_definition.py

@@ -554,6 +554,37 @@ def split_run_requests(
     return run_requests_for_backfill_daemon, run_requests_for_single_runs
 
 
+def resolve_jobs_from_targets_for_with_attributes(
+    sensor_def: "SensorDefinition", new_jobs: Optional[Sequence[ExecutableDefinition]]
+) -> tuple[Optional[str], Optional[ExecutableDefinition], Optional[Sequence[ExecutableDefinition]]]:
+    """Utility function to resolve job/jobs/job_name parameters for with_attributes method.
+
+    Returns a tuple of (job_name, job, jobs) to pass to dagster_internal_init.
+    """
+    if new_jobs is not None:
+        new_jobs_seq = new_jobs if len(new_jobs) > 1 else None
+        new_job = new_jobs[0] if len(new_jobs) == 1 else None
+        job_name = None
+    elif sensor_def.has_jobs:
+        new_job = sensor_def.job if len(sensor_def.jobs) == 1 else None
+        new_jobs_seq = sensor_def.jobs if len(sensor_def.jobs) > 1 else None
+        job_name = None
+    elif sensor_def._targets:  # noqa: SLF001
+        check.invariant(
+            len(sensor_def._targets) == 1 and not sensor_def._targets[0].has_job_def,  # noqa: SLF001
+            "Expected only one target by job name string.",
+        )
+        job_name = sensor_def._targets[0].job_name  # noqa: SLF001
+        new_job = None
+        new_jobs_seq = None
+    else:
+        job_name = None
+        new_job = None
+        new_jobs_seq = None
+
+    return job_name, new_job, new_jobs_seq
+
+
 @public
 @beta_param(param="owners")
 class SensorDefinition(IHasInternalInit):
@@ -597,27 +628,7 @@ class SensorDefinition(IHasInternalInit):
         metadata: Optional[RawMetadataMapping] = None,
     ) -> "SensorDefinition":
         """Returns a copy of this sensor with the attributes replaced."""
-        # unfortunate re-derivation of how inputs map to _targets
-        if jobs is not None:
-            new_jobs = jobs if len(jobs) > 1 else None
-            new_job = jobs[0] if len(jobs) == 1 else None
-            job_name = None
-        elif self.has_jobs:
-            new_job = self.job if len(self.jobs) == 1 else None
-            new_jobs = self.jobs if len(self.jobs) > 1 else None
-            job_name = None
-        elif self._targets:
-            check.invariant(
-                len(self._targets) == 1 and not self._targets[0].has_job_def,
-                "Expected only one target by job name string.",
-            )
-            job_name = self._targets[0].job_name
-            new_job = None
-            new_jobs = None
-        else:
-            job_name = None
-            new_job = None
-            new_jobs = None
+        job_name, new_job, new_jobs = resolve_jobs_from_targets_for_with_attributes(self, jobs)
 
         return SensorDefinition.dagster_internal_init(
             name=self.name,

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/execution/plan/objects.py

@@ -128,7 +128,9 @@ class StepFailureData(
                 "User code error is missing cause. User code errors are expected to have a"
                 " causes, which are the errors thrown from user code.",
             )
-            return self.error.message.strip() + ":\n\n" + user_code_error.to_string()
+            return (
+                self.error.message.strip() + ":\n\n" + check.not_none(user_code_error).to_string()
+            )
         else:
             return self.error.to_string()
 

dagster/_core/remote_representation/code_location.py

@@ -18,11 +18,7 @@ from dagster._core.definitions.reconstruct import ReconstructableJob, Reconstruc
 from dagster._core.definitions.repository_definition import RepositoryDefinition
 from dagster._core.definitions.selector import JobSubsetSelector
 from dagster._core.definitions.timestamp import TimestampWithTimezone
-from dagster._core.errors import (
-    DagsterInvalidSubsetError,
-    DagsterInvariantViolationError,
-    DagsterUserCodeProcessError,
-)
+from dagster._core.errors import DagsterInvalidSubsetError, DagsterUserCodeProcessError
 from dagster._core.execution.api import create_execution_plan
 from dagster._core.execution.plan.state import KnownExecutionState
 from dagster._core.instance import DagsterInstance
@@ -318,14 +314,16 @@ class CodeLocation(AbstractContextManager):
 
     @property
     @abstractmethod
-    def repository_code_pointer_dict(self) -> Mapping[str, CodePointer]:
+    def repository_code_pointer_dict(self) -> Mapping[str, Optional[CodePointer]]:
         pass
 
-    def get_repository_python_origin(self, repository_name: str) -> "RepositoryPythonOrigin":
-        if repository_name not in self.repository_code_pointer_dict:
-            raise DagsterInvariantViolationError(f"Unable to find repository {repository_name}.")
+    def get_repository_python_origin(
+        self, repository_name: str
+    ) -> Optional["RepositoryPythonOrigin"]:
+        code_pointer = self.repository_code_pointer_dict.get(repository_name)
+        if not code_pointer:
+            return None
 
-        code_pointer = self.repository_code_pointer_dict[repository_name]
         return RepositoryPythonOrigin(
             executable_path=self.executable_path or sys.executable,
             code_pointer=code_pointer,
@@ -414,7 +412,7 @@ class InProcessCodeLocation(CodeLocation):
         return self._origin.entry_point
 
     @property
-    def repository_code_pointer_dict(self) -> Mapping[str, CodePointer]:
+    def repository_code_pointer_dict(self) -> Mapping[str, Optional[CodePointer]]:
         return self._repository_code_pointer_dict
 
     def _get_reconstructable_repository(self, repository_name: str) -> ReconstructableRepository:
@@ -801,8 +799,8 @@ class GrpcServerCodeLocation(CodeLocation):
         return self._container_context
 
     @property
-    def repository_code_pointer_dict(self) -> Mapping[str, CodePointer]:
-        return cast("Mapping[str, CodePointer]", self._repository_code_pointer_dict)
+    def repository_code_pointer_dict(self) -> Mapping[str, Optional[CodePointer]]:
+        return cast("Mapping[str, Optional[CodePointer]]", self._repository_code_pointer_dict)
 
     @property
     def executable_path(self) -> Optional[str]: