dagster 1.12.3__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/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/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/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/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]:

dagster/_core/remote_representation/handle.py

@@ -25,7 +25,7 @@ if TYPE_CHECKING:
 class RepositoryHandle:
     repository_name: str
     code_location_origin: CodeLocationOrigin
-    repository_python_origin: RepositoryPythonOrigin
+    repository_python_origin: Optional[RepositoryPythonOrigin]
     display_metadata: Mapping[str, str]
 
     @classmethod
@@ -51,7 +51,9 @@ class RepositoryHandle:
         )
 
     def get_python_origin(self) -> RepositoryPythonOrigin:
-        return self.repository_python_origin
+        return check.not_none(
+            self.repository_python_origin, "Repository does not have a RepositoryPythonOrigin"
+        )
 
     def to_selector(self) -> RepositorySelector:
         return RepositorySelector(

dagster/_core/workspace/context.py

@@ -85,6 +85,7 @@ from dagster._core.workspace.workspace import (
     CodeLocationLoadStatus,
     CodeLocationStatusEntry,
     CurrentWorkspace,
+    DefinitionsSource,
     location_status_from_location_entry,
 )
 from dagster._grpc.constants import INCREASE_TIMEOUT_DAGSTER_YAML_MSG, GrpcServerCommand
@@ -1121,6 +1122,7 @@ class WorkspaceProcessContext(IWorkspaceProcessContext[WorkspaceRequestContext])
             ),
             update_timestamp=load_time,
             version_key=version_key,
+            definitions_source=DefinitionsSource.CODE_SERVER,
         )
 
     def get_current_workspace(self) -> CurrentWorkspace:

dagster/_core/workspace/workspace.py

@@ -18,6 +18,11 @@ class CodeLocationLoadStatus(Enum):
     LOADED = "LOADED"  # Finished loading (may be an error)
 
 
+class DefinitionsSource(Enum):
+    CODE_SERVER = "CODE_SERVER"
+    CONNECTION = "CONNECTION"
+
+
 @record
 class CodeLocationEntry:
     origin: Annotated[
@@ -35,6 +40,7 @@ class CodeLocationEntry:
     display_metadata: Mapping[str, str]
     update_timestamp: float
     version_key: str
+    definitions_source: DefinitionsSource
 
 
 @record

dagster/_daemon/asset_daemon.py

@@ -991,6 +991,27 @@ class AssetDaemon(DagsterDaemon):
                 log_message="Automation condition daemon caught an error",
             )
 
+    def _add_auto_materialize_asset_evaluations_in_chunks(
+        self,
+        instance: DagsterInstance,
+        evaluation_id: int,
+        evaluations: list[AutomationConditionEvaluationWithRunIds],
+        logger: logging.Logger,
+        print_group_name: str,
+    ):
+        schedule_storage = check.not_none(instance.schedule_storage)
+        if schedule_storage.supports_auto_materialize_asset_evaluations:
+            chunk_size = int(os.getenv("DAGSTER_ASSET_DAEMON_ASSET_EVALUATIONS_CHUNK_SIZE", "500"))
+            for i in range(0, len(evaluations), chunk_size):
+                chunk = evaluations[i : i + chunk_size]
+                self._logger.info(
+                    f"Adding {len(chunk)} asset evaluations for evaluation {evaluation_id}{print_group_name}"
+                )
+                schedule_storage.add_auto_materialize_asset_evaluations(
+                    evaluation_id,
+                    chunk,
+                )
+
     async def _evaluate_auto_materialize_tick(
         self,
         tick_context: AutoMaterializeLaunchContext,
@@ -1083,11 +1104,22 @@ class AssetDaemon(DagsterDaemon):
                 evaluation.key: evaluation.with_run_ids(set()) for evaluation in evaluations
             }
 
+            self._logger.info(
+                "Tick produced"
+                f" {len(run_requests)} run{'s' if len(run_requests) != 1 else ''} and"
+                f" {len(evaluations_by_key)} asset"
+                f" evaluation{'s' if len(evaluations_by_key) != 1 else ''} for evaluation ID"
+                f" {evaluation_id}{print_group_name}"
+            )
+
             # Write the asset evaluations without run IDs first
             if schedule_storage.supports_auto_materialize_asset_evaluations:
-                schedule_storage.add_auto_materialize_asset_evaluations(
+                self._add_auto_materialize_asset_evaluations_in_chunks(
+                    instance,
                     evaluation_id,
                     list(evaluations_by_key.values()),
+                    self._logger,
+                    print_group_name,
                 )
                 check_for_debug_crash(debug_crash_flags, "ASSET_EVALUATIONS_ADDED")
 
@@ -1097,11 +1129,7 @@ class AssetDaemon(DagsterDaemon):
             ]
 
             self._logger.info(
-                "Tick produced"
-                f" {len(run_requests)} run{'s' if len(run_requests) != 1 else ''} and"
-                f" {len(evaluations_by_key)} asset"
-                f" evaluation{'s' if len(evaluations_by_key) != 1 else ''} for evaluation ID"
-                f" {evaluation_id}{print_group_name}"
+                f"Submitting {len(run_requests)} run{'s' if len(run_requests) != 1 else ''} for evaluation {evaluation_id}{print_group_name}"
             )
 
             # Fetch all data that requires the code server before writing the cursor, to minimize
@@ -1179,6 +1207,7 @@ class AssetDaemon(DagsterDaemon):
             debug_crash_flags=debug_crash_flags,
             remote_sensor=sensor,
             run_request_execution_data_cache=run_request_execution_data_cache,
+            print_group_name=print_group_name,
         )
 
         if schedule_storage.supports_auto_materialize_asset_evaluations:
@@ -1267,6 +1296,7 @@ class AssetDaemon(DagsterDaemon):
         debug_crash_flags: SingleInstigatorDebugCrashFlags,
         remote_sensor: Optional[RemoteSensor],
         run_request_execution_data_cache: dict[JobSubsetSelector, RunRequestExecutionData],
+        print_group_name: str,
     ):
         updated_evaluation_keys = set()
         check_after_runs_num = instance.get_tick_termination_check_interval()
@@ -1325,9 +1355,12 @@ class AssetDaemon(DagsterDaemon):
             evaluations_by_key[asset_key] for asset_key in updated_evaluation_keys
         ]
         if evaluations_to_update:
-            schedule_storage = check.not_none(instance.schedule_storage)
-            schedule_storage.add_auto_materialize_asset_evaluations(
-                evaluation_id, evaluations_to_update
+            self._add_auto_materialize_asset_evaluations_in_chunks(
+                instance,
+                evaluation_id,
+                evaluations_to_update,
+                self._logger,
+                print_group_name,
             )
 
         check_for_debug_crash(debug_crash_flags, "RUN_IDS_ADDED_TO_EVALUATIONS")

dagster/_utils/error.py

@@ -177,7 +177,7 @@ def serializable_error_info_from_exc_info(
 def unwrap_user_code_error(error_info: SerializableErrorInfo) -> SerializableErrorInfo:
     """Extracts the underlying error from the passed error, if it is a DagsterUserCodeLoadError."""
     if error_info.cls_name == "DagsterUserCodeLoadError":
-        return unwrap_user_code_error(error_info.cause)
+        return unwrap_user_code_error(check.not_none(error_info.cause))
     return error_info
 
 

dagster/components/component/component.py

@@ -227,11 +227,16 @@ class Component(ABC):
                 pass
 
     See Also:
-        - :py:class:`dagster.Definitions`: The object returned by ``build_defs()``
-        - :py:class:`dagster.ComponentLoadContext`: Context provided to ``build_defs()``
-        - :py:class:`dagster.components.resolved.base.Resolvable`: Base for configurable components
-        - :py:class:`dagster.Model`: Recommended base class for component schemas
-        - :py:func:`dagster.scaffold_with`: Decorator for custom scaffolding
+        * :py:class:`dagster.Definitions`
+            The object returned by ``build_defs()``
+        * :py:class:`dagster.ComponentLoadContext`
+            Context provided to ``build_defs()``
+        * :py:class:`dagster.components.resolved.base.Resolvable`
+            Base for configurable components
+        * :py:class:`dagster.Model`
+            Recommended base class for component schemas
+        * :py:func:`dagster.scaffold_with`
+            Decorator for custom scaffolding
 
     """
 

dagster/components/testing/__init__.py

@@ -5,6 +5,7 @@ from dagster.components.testing.deprecated.utils import (
     scaffold_defs_sandbox as scaffold_defs_sandbox,
 )
 from dagster.components.testing.utils import (
+    DefsFolderSandbox as DefsFolderSandbox,
     copy_code_to_file as copy_code_to_file,
     create_defs_folder_sandbox as create_defs_folder_sandbox,
     get_original_module_name as get_original_module_name,

dagster/components/testing/utils.py

@@ -26,6 +26,7 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import Any, Optional, Union
 
+from dagster._annotations import public
 from dagster._core.definitions.definitions_class import Definitions
 from dagster._utils import alter_sys_path
 from dagster.components.component.component import Component
@@ -120,6 +121,7 @@ def random_importable_name(length: int = 8) -> str:
     return "sandbox_module_" + first_char + remaining
 
 
+@public
 @dataclass
 class DefsFolderSandbox:
     """A sandbox for testing components.
@@ -158,6 +160,7 @@ class DefsFolderSandbox:
         with self.build_component_tree() as tree:
             yield tree.build_defs()
 
+    @public
     @contextmanager
     def load_component_and_build_defs(
         self, defs_path: Path
@@ -188,6 +191,7 @@ class DefsFolderSandbox:
             defs = tree.build_defs(defs_path)
             yield component, defs
 
+    @public
     def scaffold_component(
         self,
         component_cls: Any,
@@ -281,35 +285,32 @@ class DefsFolderSandbox:
             sys.path.remove(injected_path)
 
 
+@public
 @contextmanager
 def create_defs_folder_sandbox(
     *,
     project_name: Optional[str] = None,
 ) -> Iterator[DefsFolderSandbox]:
     """Create a lightweight sandbox to scaffold and instantiate components. Useful
-    for those authoring component types.
+    for those authoring custom components.
 
-    Scaffold defs sandbox creates a temporary project that mimics the defs folder portion
-    of a real dagster project. It then yields a DefsFolderSandbox object which can be used to
+    This function creates a temporary project that mimics the ``defs`` folder portion
+    of a real Dagster project. It then yields a :py:class:`DefsFolderSandbox` object which can be used to
     scaffold and load components.
 
-    DefsFolderSandbox has a few properties useful for different types of tests:
+    :py:class:`DefsFolderSandbox` has a few properties useful for different types of tests:
 
-    * defs_folder_path: The absolute path to the defs folder. The user can inspect and
-    load files from scaffolded components.
-      e.g. (defs_folder_path / "my_component" / "defs.yaml").exists()
+    * ``defs_folder_path``: The absolute path to the ``defs`` folder. The user can inspect and load files from scaffolded components, e.g. ``(defs_folder_path / "my_component" / "defs.yaml").exists()``
+    * ``project_name``: If not provided, a random name is generated.
 
-    * project_name: If not provided, a random name is generated.
-
-    Once the sandbox is created the user has the option to load all definitions using the `load`
-    method on DefsFolderSandbox, or the `load_component_at_path` mathod.
+    Once the sandbox is created, you can load all definitions using the ``load`` method on :py:class:`DefsFolderSandbox`, or with the ``load_component_at_path`` method.
 
     This sandbox does not provide complete environmental isolation, but does provide some isolation guarantees
     to do its best to isolate the test from and restore the environment after the test.
 
-    * A file structure like this is created: <<temp folder>> / src / <<project_name>> / defs
-    * <<temp folder>> / src is placed in sys.path during the loading process
-    * Any modules loaded during the process that descend from defs module are evicted from sys.modules on cleanup.
+    * A file structure like this is created: ``<<temp folder>> / src / <<project_name>> / defs``
+    * ``<<temp folder>> / src`` is placed in ``sys.path`` during the loading process
+    * Any modules loaded during the process that descend from defs module are evicted from ``sys.modules`` on cleanup.
 
     Args:
         project_name: Optional name for the project (default: random name).
@@ -321,12 +322,12 @@ def create_defs_folder_sandbox(
 
     .. code-block:: python
 
-        with scaffold_defs_sandbox() as sandbox:
+        with create_defs_folder_sandbox() as sandbox:
             defs_path = sandbox.scaffold_component(component_cls=MyComponent)
             assert (defs_path / "defs.yaml").exists()
             assert (defs_path / "my_component_config_file.yaml").exists()  # produced by MyComponentScaffolder
 
-        with scaffold_defs_sandbox() as sandbox:
+        with create_defs_folder_sandbox() as sandbox:
             defs_path = sandbox.scaffold_component(
                 component_cls=MyComponent,
                 defs_yaml_contents={"type": "MyComponent", "attributes": {"asset_key": "my_asset"}},

dagster/version.py

@@ -1 +1 @@
-__version__ = "1.12.3"
+__version__ = "1.12.4"

{dagster-1.12.3.dist-info → dagster-1.12.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dagster
-Version: 1.12.3
+Version: 1.12.4
 Summary: Dagster is an orchestration platform for the development, production, and observation of data assets.
 Author: Dagster Labs
 Author-email: hello@dagsterlabs.com
@@ -59,8 +59,8 @@ Requires-Dist: universal_pathlib; python_version < "3.12"
 Requires-Dist: universal_pathlib>=0.2.0; python_version >= "3.12"
 Requires-Dist: rich
 Requires-Dist: filelock
-Requires-Dist: dagster-pipes==1.12.3
-Requires-Dist: dagster-shared==1.12.3
+Requires-Dist: dagster-pipes==1.12.4
+Requires-Dist: dagster-shared==1.12.4
 Requires-Dist: antlr4-python3-runtime
 Provides-Extra: docker
 Requires-Dist: docker; extra == "docker"

{dagster-1.12.3.dist-info → dagster-1.12.4.dist-info}/RECORD

@@ -4,7 +4,7 @@ dagster/_annotations.py,sha256=GC7Rc8ZJZS9EpUuiCMyrtLZ5lsGGjPPkVtlmaClkt2o,1610
 dagster/_builtins.py,sha256=J6A1CE28JV0itz73hCaHIKoUknb1j5B3QO5Frx_hQuU,471
 dagster/_module_alias_map.py,sha256=KsLPXRga52UbPcEjFpOie8tvb7sGdNnikl3MUelYtVA,3349
 dagster/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-dagster/version.py,sha256=XbPSLe2HETXFi6X6FeVlWRaW_ieblpExrYLZ0L8ULkU,23
+dagster/version.py,sha256=ECTpCDnMmYt-JTZQ4h1vRvo71Pv0brM8s8fcdkN0PoM,23
 dagster/_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dagster/_api/get_server_id.py,sha256=sBjhjcHgB__iIN567QCJmTtBK6-v31VfjDsYNZIohVw,731
 dagster/_api/list_repositories.py,sha256=fbjMobgFKzwoMN825GEgDeCx1jzUlW2vPhPDuYIg93g,3905
@@ -44,7 +44,7 @@ dagster/_config/field_utils.py,sha256=9PA0ln6yD63I5HBzPTWSfWnyD8okfUYWa98BsFib0g
 dagster/_config/post_process.py,sha256=YWa3GicUfY5bQ5goVWLUTvmgJySgjbCuOQPC1N4l1EE,9549
 dagster/_config/primitive_mapping.py,sha256=0YAVfLyklI8xmdeca-U4h5CGSlsiCRWaSPddh21txp8,899
 dagster/_config/snap.py,sha256=eAKWsXN0B5mZosiu0WRGzXAgFx92m8UwcKim7lG8Po4,10673
-dagster/_config/source.py,sha256=yT61LldMM-g5T8ObHLDQYEmarSqVcd6bg8M7LMkXvNk,3147
+dagster/_config/source.py,sha256=wRrhb6OIBCNSnOQv1zUUNUKMrylA5FjvOsvJhHu9j6Y,3526
 dagster/_config/stack.py,sha256=5w0ITGNFhwGXugONa-CjcjQBvE-dDjT4FmOIjlTAaZc,3056
 dagster/_config/traversal_context.py,sha256=WMagAF-R3zF3u5XM0lqz5-Gwc4L9WUI56TFwxMZR6kk,5737
 dagster/_config/type_printer.py,sha256=VVN4pdVlFT7kpOEl8g0RiABxpa0TZ-2r9gISX0Ggpc8,4205
@@ -52,9 +52,9 @@ dagster/_config/validate.py,sha256=CZqj_hMx8fxoIAZhMaWNygFLygIckS2QJo2p6GDcm6w,1
 dagster/_config/pythonic_config/__init__.py,sha256=v7g8bWH6Og9T3iooklNakK1Qog6Bv1BTodExeF-yhu0,1388
 dagster/_config/pythonic_config/attach_other_object_to_context.py,sha256=0BVfuIHFXhkvsaLTemHPpO3wi2ocwYQGfTp_gNyrMnQ,1632
 dagster/_config/pythonic_config/config.py,sha256=92tN7cgIfAm_AbXqloj0TM_tVN4jr4OYUubpYTo0ZuM,20135
-dagster/_config/pythonic_config/conversion_utils.py,sha256=1WEjixrTefN7RpNW2A87aO7SnQym_izwhG247jkowYU,13481
+dagster/_config/pythonic_config/conversion_utils.py,sha256=lZbTuEx9vMKkX30WHtawZuvzAp4hgpdwOWaIDUEg7vU,13542
 dagster/_config/pythonic_config/io_manager.py,sha256=BSAK5dN7Z8doMVbNNMmpC53LrEapd2zl1Dhj8zlaK0Y,10748
-dagster/_config/pythonic_config/resource.py,sha256=VwhzD99_wUir43Q6JZTbT8Trrvfm9k585ewrWV5Z2YY,42778
+dagster/_config/pythonic_config/resource.py,sha256=5M14g3sg7NYZ7C_Q0OXCczrC2vFQupjESbLwfaqXkkY,42842
 dagster/_config/pythonic_config/type_check_utils.py,sha256=K75S_1CGFf5KFAoxDbChNlvSFkGs1ru-nh1rPpSUGRc,775
 dagster/_config/pythonic_config/typing_utils.py,sha256=DF9eFBkRaGKWVnhfiAmSHwPGji_Ti9_CK0lVEXtZI0s,9147
 dagster/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -86,15 +86,15 @@ dagster/_core/asset_graph_view/serializable_entity_subset.py,sha256=kV9InWpbXsEA
 dagster/_core/container_context/__init__.py,sha256=YxylRIFRSQ5yYetyE6C09MyDBtk19QtUsUUkJd4mRas,215
 dagster/_core/container_context/config.py,sha256=wtFTDLs1OMMqiOx4CbUEg7gP7XPzDdAB-P-7dp64PG0,1301
 dagster/_core/definitions/__init__.py,sha256=fzykPDhZ3mnUtmCEVQBp7di1kD5LHHj_D3bZqdNMpPo,9265
-dagster/_core/definitions/asset_daemon_cursor.py,sha256=FIeiQH2BtVjb4V0Pfw605yL4s8ouHxKZTJvfS_l3gmE,7743
+dagster/_core/definitions/asset_daemon_cursor.py,sha256=VIux8TZECFmfgF6sCOozTFVV2_5Bze3C0vjYxt0sewg,7768
 dagster/_core/definitions/asset_key.py,sha256=39gyLd_7BR7Clr9vbD9ZkiohShn-p6mkkrMld2D0NTM,9822
 dagster/_core/definitions/asset_selection.py,sha256=rQQfETcwhm8e16-tjdMSVfy2WLepVsUS0F3EVyQs0nY,51306
-dagster/_core/definitions/asset_sensor_definition.py,sha256=AzXFbahA3vuUSk5U5o-DzlM3QHNm0D8-2S9guTQdeB4,7937
+dagster/_core/definitions/asset_sensor_definition.py,sha256=SN3iWp2G5ASosZ6jLHoezkr4gaAqpy7CRVn_nuHT7k4,10356
 dagster/_core/definitions/auto_materialize_policy.py,sha256=lezqPrjE8o8RbVIW8HrHEpXvIUTywOAIAZejxJ8OGjY,14363
 dagster/_core/definitions/auto_materialize_rule.py,sha256=evG-F_vuwrHnFx-eYFFXhEgLA35JCUZtauN_K0--6Gw,11763
 dagster/_core/definitions/auto_materialize_rule_evaluation.py,sha256=0INxDvF-skuAkqmtf-NTU0SCGrC6r0fmMOef_wD4XoA,5079
 dagster/_core/definitions/auto_materialize_rule_impls.py,sha256=b-Lk9OsgMhd2VpRrIYNDa-rZ85pI1u0y1b7hgUqog48,51872
-dagster/_core/definitions/automation_condition_sensor_definition.py,sha256=LGDX7HI3jjipb0TljLig9_QyFnG4AE9xQZDQxlZFPQk,9197
+dagster/_core/definitions/automation_condition_sensor_definition.py,sha256=lBeOBZ0eLXxHi47rrcfhU4VaANxiVQ0wEk5Vb-oV3x8,11505
 dagster/_core/definitions/automation_tick_evaluation_context.py,sha256=5PpiUBNSnTy2IA6mNx6tPr-jXnkTqHEzdDduo3iczrw,22824
 dagster/_core/definitions/backfill_policy.py,sha256=Ii9HasVaXWv5HKAR7d4uIJfwPqUJQApqCSBNHJfkclw,3987
 dagster/_core/definitions/composition.py,sha256=ZQTX3YW7sLMCs9NbBywvglWexjCkNsarpMob55qIgKg,41500
@@ -125,17 +125,17 @@ dagster/_core/definitions/job_definition.py,sha256=27n29A9RJHjxlf0bqJwnrpXr4o6CW
 dagster/_core/definitions/logger_definition.py,sha256=eBb-9xOOMRKJY43wv7rnQgb8pJG_W4lYKdE77nQvZNQ,7332
 dagster/_core/definitions/logger_invocation.py,sha256=0kAkCu-oSa4hGqlPrjJFW9kXLpZWKO6wi-1L0txl5II,698
 dagster/_core/definitions/materialize.py,sha256=1bls6kLDvUsWlJ_8lXjFlJiyljC4x7Y44YhmdsBAeT0,9430
-dagster/_core/definitions/multi_asset_sensor_definition.py,sha256=fnktEgtV28denxIdBVa1ch84OGaxYMWBCWi5xRY6Vdc,60248
+dagster/_core/definitions/multi_asset_sensor_definition.py,sha256=dI6RmRaxEuVaqkl4mVUfdjWjCzJrimvmDQ9mew1M21M,62855
 dagster/_core/definitions/no_step_launcher.py,sha256=PXIbsPOV9F49dGWAl-ZYlz6w8PFs-ZesNsQpi8llGqk,197
 dagster/_core/definitions/node_container.py,sha256=wKTwRd-svjhNnESn8t2o7G0WykZya2-RaTobw2WM3LA,12007
 dagster/_core/definitions/node_definition.py,sha256=R4cE1bGfhxv-jzQ26Oirqdd_gOj200ymbqNB7zipe2o,8729
 dagster/_core/definitions/observe.py,sha256=kDFlEhTxxmbXRImaJFxbyM_aCDp5EQkG-hZLdNnTwO4,3000
-dagster/_core/definitions/op_definition.py,sha256=d3RVDAFAILeNIkaV3q621nh7RNqrZmr2J538lzn9xwo,24580
+dagster/_core/definitions/op_definition.py,sha256=B5tzxRqM0n81ZN4v-toAO_P8536ltcp7Zy_DY6BBZ1k,24901
 dagster/_core/definitions/op_invocation.py,sha256=5YdGsAo8tfhCYXeatPzvgZ-Uo6h05Yr1p_C3BjNv0iI,23494
 dagster/_core/definitions/op_selection.py,sha256=Q8cqYHny9BVLP_TgeRUBUA_ItwpMNa43u2bA0RgJQ30,8699
 dagster/_core/definitions/output.py,sha256=6kXTThBhHqX3OZvQ-BjogxUkYbYv372-OmlbTbeJho8,19290
 dagster/_core/definitions/policy.py,sha256=3Y-4ARYjNulq2ycCCg2z1flOAAInsD8IERQaZiMyT1s,3811
-dagster/_core/definitions/reconstruct.py,sha256=hMb8rTf7CesiwoasAfqusLnnEqFc3JS-4rB_Ct-wMyI,32063
+dagster/_core/definitions/reconstruct.py,sha256=hz2otYlYG0FJOIejxuU9obyvHRxXOX_GY6rxa5LLQMY,31877
 dagster/_core/definitions/resolved_asset_deps.py,sha256=4SeCft35KJHeoblnoSOW_XocS23iE_0fCWg7aHXBltI,9321
 dagster/_core/definitions/resource_annotation.py,sha256=gdQW4v0hnKUFi6LXm2vgrZ3TXOJA2HJYXkLRu9B5-zc,1619
 dagster/_core/definitions/resource_definition.py,sha256=AOOoltR3Jxgbns-V_LfYfmqgkC1YbFf3snwvGxlahLs,18048
@@ -145,11 +145,11 @@ dagster/_core/definitions/result.py,sha256=wqUoc8V0JWkNKLUq35AhwpsHNojP4qUXyccrm
 dagster/_core/definitions/run_config.py,sha256=ybNO2dDoh7OE7qeOSoQ5bGeVBDgBY5upXrazCONAfdU,24480
 dagster/_core/definitions/run_config_schema.py,sha256=g7fdXwYu9RKEMglB0j4M1uPj6n8XW3tKOwaOPz7wGHs,1521
 dagster/_core/definitions/run_request.py,sha256=h2H4z2yFrwYQQtCsP0RB4frh_aJ0SD_700N-Iu5pT-s,16425
-dagster/_core/definitions/run_status_sensor_definition.py,sha256=hHaCmMP_npL6eANPIu4L2U6XWeCwazSNsyHiAaNgDSA,50448
+dagster/_core/definitions/run_status_sensor_definition.py,sha256=ylVwNMgFW7VG8dNPUH0i99D-FeOMYmnBdwbJfWXiQZA,53767
 dagster/_core/definitions/schedule_definition.py,sha256=w9KxAbilnp6OXz1pscbknDHikTUIzDxY6Gd94NOhw6k,45312
 dagster/_core/definitions/scoped_resources_builder.py,sha256=PDE3ADpVKr4LzeLyya-2u7AyzjeK7IBzf-6lD5fYVSs,5149
 dagster/_core/definitions/selector.py,sha256=9xNpEfwCAJPS4Qmz1AS4Z9EVqsVnhkSeI9m7x_OL_zo,12961
-dagster/_core/definitions/sensor_definition.py,sha256=41umSF-CXyHuIUxnkfvN22D0lQNPI5JxZRZUUDCrdzk,61910
+dagster/_core/definitions/sensor_definition.py,sha256=3Vlsqb3XCvs6Zjm126NKoZSKttSsdjyWL4tb474IfQo,62463
 dagster/_core/definitions/source_asset.py,sha256=5B3phODyhGiyVv2nshkCprCgPR6MmfclEDu3yW95pJw,22718
 dagster/_core/definitions/step_launcher.py,sha256=ZNxb18qRMG0HNVExYwrSvx4pma1uzq9Hj2AKZv7l3DQ,2855
 dagster/_core/definitions/target.py,sha256=JfxKVzeXUWDFEiiyp1UiAPALRv3uVPbRxWuk3Yci_k4,5751
@@ -242,7 +242,7 @@ dagster/_core/definitions/decorators/source_asset_decorator.py,sha256=KE9oCVlzaR
 dagster/_core/definitions/metadata/__init__.py,sha256=3udptTJSppffelN6ehwrArbfpS-LFwHa9MqYArTJqiA,10784
 dagster/_core/definitions/metadata/external_metadata.py,sha256=DphSm10HGxHACurNFhegFcAM8lOx67QePUsOyek6Yac,5040
 dagster/_core/definitions/metadata/metadata_set.py,sha256=8npbUlJwSg0pXrvAM7xP213Ii0y3ySNmsru470_SU98,7664
-dagster/_core/definitions/metadata/metadata_value.py,sha256=A53q_fz8gfFy7j7FQqJRwGDm1H5_NzBnJZhhbDROXN0,33290
+dagster/_core/definitions/metadata/metadata_value.py,sha256=vQdvYxfqWUWk7xe3sdNWmErTcyOx3iSJ7OSwuv-MJk8,33394
 dagster/_core/definitions/metadata/source_code.py,sha256=sc21_k_eH7ZaUeTQMWF3XYrBtCa3-yGSy9_gTiE149s,16350
 dagster/_core/definitions/metadata/table.py,sha256=PwXMIyKMn-eotPThhX6OPkyQqrealjs5KExo8WkTWU8,11097
 dagster/_core/definitions/module_loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -357,7 +357,7 @@ dagster/_core/execution/plan/handle.py,sha256=1716C0GK5bsSupHReaYxbAxrUf-zc9cDka
 dagster/_core/execution/plan/inputs.py,sha256=PzD0qqEtvyw9OQMXVPtHf3QWu4ZYU0AtXKaWgtHnPSw,30542
 dagster/_core/execution/plan/instance_concurrency_context.py,sha256=8xbNUHN3jfggeWPnmLVZ2mR9OH4vSI-SxT2rwDlbRVA,7161
 dagster/_core/execution/plan/local_external_step_main.py,sha256=M185NvpCEiC38yt6SRYMqZmaZu157IUcG_PirzzzNcE,1191
-dagster/_core/execution/plan/objects.py,sha256=8quUNm6x_7O3lqoXHfyoKiw-G5ie-SHxhr38UC6idi8,5788
+dagster/_core/execution/plan/objects.py,sha256=bMFauRqKwOtg05_-_qGhS0TlvEFefZQXOx1-GKHL2HU,5836
 dagster/_core/execution/plan/outputs.py,sha256=kjNheUhNRRnJL_4zkOowaeKAddTQ19URxghkREbVsZk,7632
 dagster/_core/execution/plan/plan.py,sha256=urPcPsBWHJxs6RmteAqyO2vh8InBaeSoaTPCpMVT-qA,56778
 dagster/_core/execution/plan/resume_retry.py,sha256=Ea8FgqWGFI7kI1WFEuPmgq9vfp9ppkGOXZJhgPPYVNw,160
@@ -408,13 +408,13 @@ dagster/_core/pipes/merge_streams.py,sha256=fOagYT2-ILjoO_WcPpqiXDGCsLbkiLZXUjjx
 dagster/_core/pipes/subprocess.py,sha256=IzrKVG39YOzu6D0C2GHjJzsNFQgQH9X51RbkGDZAQGQ,6238
 dagster/_core/pipes/utils.py,sha256=LworRlg5CL-EJvAYYwgIux1r-e8DknxXJeKV-O5rMu0,33656
 dagster/_core/remote_representation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dagster/_core/remote_representation/code_location.py,sha256=kJ8o65kx007hf4SIhMJe9aofiuMgP8crEfbbOb6iRyI,43129
+dagster/_core/remote_representation/code_location.py,sha256=espz1rAuPpHMb7VcRbDF-9q15b9bVDsp7f06oQI7jH4,43034
 dagster/_core/remote_representation/external.py,sha256=5KBxAxSWlEGkTNeABdYxG172DfvXtDLH904pxIX81js,45098
 dagster/_core/remote_representation/external_data.py,sha256=z1OXOvE0OGLtpRfiTkL_c7oo0dwAeYY_XayGDEfRDnQ,67672
 dagster/_core/remote_representation/feature_flags.py,sha256=_yd6o_4X79OyLCeA2bBR8lUsHZliJEkym57ld3aCW1g,1477
 dagster/_core/remote_representation/grpc_server_registry.py,sha256=XLig5YVETxBykKQcOXAKZmCBTL3tKq-nvzBR7OeOluE,12048
 dagster/_core/remote_representation/grpc_server_state_subscriber.py,sha256=YaQOXlTScEv-YAz99Bf4FWkp85TO5W6L7TdEs87M2j4,1485
-dagster/_core/remote_representation/handle.py,sha256=X-rhevgN5XH1la5pDyKK0UlqGOG2CcNga60zn3BBO5s,5661
+dagster/_core/remote_representation/handle.py,sha256=YO7Kan9wppbX3NnvuB0xkqNhqAalVd2g8KXFS4lrum8,5762
 dagster/_core/remote_representation/historical.py,sha256=RbMRpWVwQUpM7dTVwk83OS2nyxZcJeKMA9qhc2WhLEM,1836
 dagster/_core/remote_representation/job_index.py,sha256=5-km178Fpm0b0WNoFIM3wndgz-7J-XTaK_jG9QWipJs,4391
 dagster/_core/remote_representation/represented.py,sha256=exlAFG3jkmhHyEleXAsZW83ac2-xTPbTUi6flOKUhVk,3879
@@ -614,14 +614,14 @@ dagster/_core/types/transform_typing.py,sha256=sRsaoDC2zJlVQk9Gn5Ra2so58dOA2xOGd
 dagster/_core/workspace/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dagster/_core/workspace/autodiscovery.py,sha256=GbzLD8RsGd4P5XFK-kP_cLkRKp2GQokjKMknw04CUD8,5309
 dagster/_core/workspace/config_schema.py,sha256=0doh9IepHQy-qBQmnTB18S7op3E-HQQdY3NbD4u9J6A,3989
-dagster/_core/workspace/context.py,sha256=SI6eM6t1qDXjepHhNZ1WoAIeY_yPelhqp7JrIQrc9Mg,49044
+dagster/_core/workspace/context.py,sha256=5n6bAL5KFLVG69lZR3RarGaIf2y7Vbs03OxiIhbwl4A,49129
 dagster/_core/workspace/load.py,sha256=NCH-JthAXwYi4XVW5kXs9oISKNeBHGqdSAstzFHsIPM,13652
 dagster/_core/workspace/load_target.py,sha256=48w49s13kXEEJ_sMYhEhmvyCTXckLoGV_njfzY8ADZM,9497
 dagster/_core/workspace/permissions.py,sha256=tUD3PYIs5aZoV9IiR8oD2tmeq8ptM4BjNnTaXPVGqx0,4361
-dagster/_core/workspace/workspace.py,sha256=Wmr984ximqr7fKOPiJGN8hTWKEKEtT49TLrkd6VbOGY,2401
+dagster/_core/workspace/workspace.py,sha256=m26z1PlJrVd3Y_5o6I1R7rwkMRQ62_AAxskx_crnfoA,2538
 dagster/_daemon/__init__.py,sha256=2X3MJ45zmvO8LqfdFYN1zoQcvMw4WCc0pPJg50o8EAE,2106
 dagster/_daemon/__main__.py,sha256=tNNSaUs_mo4vndbdpUMxpBWU8Fy21sqLOuXUM1zpmY0,45
-dagster/_daemon/asset_daemon.py,sha256=MOOUQUo09B1Ccza3O5PGiAjyiInZSQQtoGHAU6sKDAQ,58282
+dagster/_daemon/asset_daemon.py,sha256=fIsCGLmRPi7bZyTQ44FkzsIsk5XJiZdxTZwjiE5rogw,59632
 dagster/_daemon/backfill.py,sha256=TrXoAG0CinrgSARcFX11l5EYWlXrr-e3l7Fh34ZDsTQ,12612
 dagster/_daemon/controller.py,sha256=3O4C5VJYXZ_To6H3TnYpIxzlBQT58z5aDAcOqDlmbK8,19877
 dagster/_daemon/daemon.py,sha256=PqQs3sAWGyGjDhR01OqmagIWN5Xzw0nHy6MhG-xyCwg,15134
@@ -699,7 +699,7 @@ dagster/_utils/container.py,sha256=7ryY8iQMYj2-SpOUB7avtQb9zFhvnWwVtrNpKv5LTmA,1
 dagster/_utils/cronstring.py,sha256=ArDL3RX9903iOsNljgOvH7PB6NQA5jA7V6E_XIxx9fM,1587
 dagster/_utils/dagster_type.py,sha256=cf9Ee2kCacMqzeVb1bkSUBSE0GofaVgXPg4X2qp1IAE,2473
 dagster/_utils/env.py,sha256=OztL1_lBhIzYxuLC8_bTIdxBIDZoNQICSVrQINEZ8Ec,227
-dagster/_utils/error.py,sha256=SHTy8W_i7LPjqyLv5oVpfX4ykMR0Ef_gc7HFxnsyLXM,10777
+dagster/_utils/error.py,sha256=FBe5s4QytwhSNqAnRR96kT2iAK1PP9DbNHogPb_InBc,10793
 dagster/_utils/forked_pdb.py,sha256=zIsedsYyC_RaNCIT1EhC2RMOFHSs7YB16TcU9fRJU1o,1070
 dagster/_utils/hosted_user_process.py,sha256=7pmsUFzf7d9js3K47YYZl3LxxijEp_ybjRowwc38JvY,2200
 dagster/_utils/indenting_printer.py,sha256=cG722h_d06myrN65UG4-qErJLpGUESo24wxc6RiqOug,2975
@@ -763,7 +763,7 @@ dagster/components/definitions.py,sha256=d6O3ZSXD9YJXx_03r5WFMLSIFP2fRqYktMgorm_
 dagster/components/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dagster/components/version.py,sha256=zJqpDCTjOK_8UUTArYG8Z1_m1MefgAGZk1YNGY1V3U0,24
 dagster/components/component/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dagster/components/component/component.py,sha256=2WJfI6WQE10HHq4gEGIVr-3lqcG99Lgych72MaAYvWk,15332
+dagster/components/component/component.py,sha256=FerFC99YX0iaVIV4X_FKTGbEzRYsn2MNn1pGxEd4g18,15387
 dagster/components/component/component_loader.py,sha256=sJzc7fh6eRNHpIzDlm8KpqmmHKbF92QtZkIgPohQdM8,1802
 dagster/components/component/component_scaffolder.py,sha256=FY9juAchYcPJorsrfCAu0ieQrNkgYZvJyfLW1iOkXlI,404
 dagster/components/component/state_backed_component.py,sha256=1TjwMAk4gdQjHeeo96kpfm6g6GWM6dqt6PT5tcTZ0WQ,10715
@@ -810,9 +810,9 @@ dagster/components/resolved/model.py,sha256=-MOFSYVgZ8CvNfcw-4Q-6sS4vsxDSkIcSUGx
 dagster/components/resolved/scopes.py,sha256=uF_kpirZLKc5FNEUMyp_vci-EI1Lxv_2pe42Zkpdbj4,5451
 dagster/components/scaffold/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dagster/components/scaffold/scaffold.py,sha256=K6KYZNdB6E6qHG9BP8mk9TnLxJXPeD0GIZUK_mHSGTk,4339
-dagster/components/testing/__init__.py,sha256=tYUhKu8v5Ohic1VOIP-6U8iWMByxSFMfoCSTZ_eh_Tc,581
+dagster/components/testing/__init__.py,sha256=FjDbV2QyslmxItlmVysH-TGWCTysaeR5MnBv1jvhE4A,625
 dagster/components/testing/test_cases.py,sha256=UKyv7y-3Oda8fyloqB-q3nS34uEsMFzkTmYGZNw5MZQ,6908
-dagster/components/testing/utils.py,sha256=v-6scnVw7YORH9d6DwLcLe0IhqfRkvBbsmW2BnJKa08,14165
+dagster/components/testing/utils.py,sha256=0GgotW5EuP_0p6V12RH7cz0Rcclm2eD9kx7CxxjnEeg,14297
 dagster/components/testing/deprecated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dagster/components/testing/deprecated/utils.py,sha256=KvxyMlHsblHKhcwIwG18VDiDuVcDLrlW81RyeI_IaT0,12346
 dagster/components/utils/__init__.py,sha256=OEaovCFfS6Vd5hl_aFLC8aFLMmSlBEdyIy4TrJvhuQM,2626
@@ -822,9 +822,9 @@ dagster/components/utils/translation.py,sha256=gKal6ZdMbYImiBLZVa9E2pz4690j8Hukf
 dagster/deprecated/__init__.py,sha256=fkuCwd_79EmS-Voox0YlWEHWxZwQ0ZM_V0viwxw5isw,127
 dagster/preview/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dagster/preview/freshness/__init__.py,sha256=zq0UU-3mnxycgJDtAZ9DFWiBh4eXxKCaKbeuRmUl3_Y,276
-dagster-1.12.3.dist-info/licenses/LICENSE,sha256=4lsMW-RCvfVD4_F57wrmpe3vX1xwUk_OAKKmV_XT7Z0,11348
-dagster-1.12.3.dist-info/METADATA,sha256=2OlxMe4n6tVlgxSj82IEmmt7yHONOErf-xOi6KiuTY8,12221
-dagster-1.12.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dagster-1.12.3.dist-info/entry_points.txt,sha256=D4W0jf1lM8zq82j3DJd9JkZEmHdFz5gkz8ddRzOEzpc,139
-dagster-1.12.3.dist-info/top_level.txt,sha256=Gx3NqlMQh6AsfIZaJJXEfep5yh-e9pUxkzOlUV3s6CM,8
-dagster-1.12.3.dist-info/RECORD,,
+dagster-1.12.4.dist-info/licenses/LICENSE,sha256=4lsMW-RCvfVD4_F57wrmpe3vX1xwUk_OAKKmV_XT7Z0,11348
+dagster-1.12.4.dist-info/METADATA,sha256=7E0AUSxQ13gPTATcl_bNco3O6PPpcoAzMlsy9AZ9rs0,12221
+dagster-1.12.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dagster-1.12.4.dist-info/entry_points.txt,sha256=D4W0jf1lM8zq82j3DJd9JkZEmHdFz5gkz8ddRzOEzpc,139
+dagster-1.12.4.dist-info/top_level.txt,sha256=Gx3NqlMQh6AsfIZaJJXEfep5yh-e9pUxkzOlUV3s6CM,8
+dagster-1.12.4.dist-info/RECORD,,