dagster 1.12.3__tar.gz → 1.12.5__tar.gz

{dagster-1.12.3/dagster.egg-info → dagster-1.12.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dagster
-Version: 1.12.3
+Version: 1.12.5
 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.5
+Requires-Dist: dagster-shared==1.12.5
 Requires-Dist: antlr4-python3-runtime
 Provides-Extra: docker
 Requires-Dist: docker; extra == "docker"

{dagster-1.12.3 → dagster-1.12.5}/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-1.12.3 → dagster-1.12.5}/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-1.12.3 → dagster-1.12.5}/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-1.12.3 → dagster-1.12.5}/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-1.12.3 → dagster-1.12.5}/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-1.12.3 → dagster-1.12.5}/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-1.12.3 → dagster-1.12.5}/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-1.12.3 → dagster-1.12.5}/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-1.12.3 → dagster-1.12.5}/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-1.12.3 → dagster-1.12.5}/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-1.12.3 → dagster-1.12.5}/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-1.12.3 → dagster-1.12.5}/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-1.12.3 → dagster-1.12.5}/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()