dagster 1.12.0__tar.gz → 1.12.1__tar.gz

{dagster-1.12.0/dagster.egg-info → dagster-1.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dagster
-Version: 1.12.0
+Version: 1.12.1
 Summary: Dagster is an orchestration platform for the development, production, and observation of data assets.
 Author: Dagster Labs
 Author-email: hello@dagsterlabs.com
@@ -60,8 +60,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.0
-Requires-Dist: dagster-shared==1.12.0
+Requires-Dist: dagster-pipes==1.12.1
+Requires-Dist: dagster-shared==1.12.1
 Requires-Dist: antlr4-python3-runtime
 Provides-Extra: docker
 Requires-Dist: docker; extra == "docker"

{dagster-1.12.0 → dagster-1.12.1}/dagster/__init__.py

@@ -244,6 +244,7 @@ from dagster._core.definitions.events import (
     DynamicOutput as DynamicOutput,
     ExpectationResult as ExpectationResult,
     Failure as Failure,
+    HookExecutionResult as HookExecutionResult,
     Output as Output,
     RetryRequested as RetryRequested,
     TypeCheck as TypeCheck,

{dagster-1.12.0 → dagster-1.12.1}/dagster/_core/asset_graph_view/asset_graph_view.py

@@ -18,6 +18,7 @@ from dagster._core.asset_graph_view.serializable_entity_subset import Serializab
 from dagster._core.definitions.asset_key import AssetCheckKey, AssetKey, EntityKey, T_EntityKey
 from dagster._core.definitions.assets.graph.asset_graph_subset import AssetGraphSubset
 from dagster._core.definitions.events import AssetKeyPartitionKey
+from dagster._core.definitions.freshness import FreshnessState
 from dagster._core.definitions.partitions.context import (
     PartitionLoadingContext,
     use_partition_loading_context,
@@ -561,6 +562,26 @@ class AssetGraphView(LoadingContext):
         else:
             return self.get_empty_subset(key=key)
 
+    async def compute_subset_with_freshness_state(
+        self, key: AssetKey, state: FreshnessState
+    ) -> EntitySubset[AssetKey]:
+        from dagster._core.definitions.asset_health.asset_freshness_health import (
+            AssetFreshnessHealthState,
+        )
+
+        if not self.asset_graph.has(key) or self.asset_graph.get(key).freshness_policy is None:
+            if state == FreshnessState.NOT_APPLICABLE:
+                return self.get_full_subset(key=key)
+            else:
+                return self.get_empty_subset(key=key)
+
+        asset_freshness_health_state = await AssetFreshnessHealthState.compute_for_asset(key, self)
+
+        if asset_freshness_health_state.freshness_state == state:
+            return self.get_full_subset(key=key)
+        else:
+            return self.get_empty_subset(key=key)
+
     async def _compute_run_in_progress_check_subset(
         self, key: AssetCheckKey
     ) -> EntitySubset[AssetCheckKey]:

{dagster-1.12.0 → dagster-1.12.1}/dagster/_core/definitions/assets/definition/assets_definition.py

@@ -511,9 +511,9 @@ class AssetsDefinition(ResourceAddable, IHasInternalInit):
                 tags to be associated with each of the output assets for this node. Keys are the names
                 of outputs, and values are dictionaries of tags to be associated with the related
                 asset.
-            legacy_freshness_policies_by_output_name (Optional[Mapping[str, Optional[FreshnessPolicy]]]): Defines a
-                FreshnessPolicy to be associated with some or all of the output assets for this node.
-                Keys are the names of the outputs, and values are the FreshnessPolicies to be attached
+            legacy_freshness_policies_by_output_name (Optional[Mapping[str, Optional[LegacyFreshnessPolicy]]]): Defines a
+                LegacyFreshnessPolicy to be associated with some or all of the output assets for this node.
+                Keys are the names of the outputs, and values are the LegacyFreshnessPolicies to be attached
                 to the associated asset.
             automation_conditions_by_output_name (Optional[Mapping[str, Optional[AutomationCondition]]]): Defines an
                 AutomationCondition to be associated with some or all of the output assets for this node.

{dagster-1.12.0 → dagster-1.12.1}/dagster/_core/definitions/declarative_automation/automation_condition.py

@@ -28,6 +28,7 @@ from dagster._core.definitions.declarative_automation.serialized_objects import
     get_serializable_candidate_subset,
     get_serializable_true_subset,
 )
+from dagster._core.definitions.freshness import FreshnessState
 from dagster._core.definitions.partitions.subset import (
     AllPartitionsSubset,
     TimeWindowPartitionsSubset,
@@ -649,6 +650,36 @@ class AutomationCondition(ABC, Generic[T_EntityKey]):
         )
         return CronTickPassedCondition(cron_schedule=cron_schedule, cron_timezone=cron_timezone)
 
+    @public
+    @staticmethod
+    def freshness_passed() -> "BuiltinAutomationCondition[AssetKey]":
+        """Returns an AutomationCondition that is true if the target's freshness is PASS."""
+        from dagster._core.definitions.declarative_automation.operands import (
+            FreshnessResultCondition,
+        )
+
+        return FreshnessResultCondition(state=FreshnessState.PASS).with_label("freshness_passed")
+
+    @public
+    @staticmethod
+    def freshness_warned() -> "BuiltinAutomationCondition[AssetKey]":
+        """Returns an AutomationCondition that is true if the target's freshness is WARN."""
+        from dagster._core.definitions.declarative_automation.operands import (
+            FreshnessResultCondition,
+        )
+
+        return FreshnessResultCondition(state=FreshnessState.WARN).with_label("freshness_warned")
+
+    @public
+    @staticmethod
+    def freshness_failed() -> "BuiltinAutomationCondition[AssetKey]":
+        """Returns an AutomationCondition that is true if the target's freshness is FAIL."""
+        from dagster._core.definitions.declarative_automation.operands import (
+            FreshnessResultCondition,
+        )
+
+        return FreshnessResultCondition(state=FreshnessState.FAIL).with_label("freshness_failed")
+
     @public
     @staticmethod
     def newly_missing() -> "BuiltinAutomationCondition":

{dagster-1.12.0 → dagster-1.12.1}/dagster/_core/definitions/declarative_automation/operands/__init__.py

@@ -4,6 +4,7 @@ from dagster._core.definitions.declarative_automation.operands.operands import (
     CodeVersionChangedCondition as CodeVersionChangedCondition,
     CronTickPassedCondition as CronTickPassedCondition,
     ExecutionFailedAutomationCondition as ExecutionFailedAutomationCondition,
+    FreshnessResultCondition as FreshnessResultCondition,
     InitialEvaluationCondition as InitialEvaluationCondition,
     InLatestTimeWindowCondition as InLatestTimeWindowCondition,
     MissingAutomationCondition as MissingAutomationCondition,

{dagster-1.12.0 → dagster-1.12.1}/dagster/_core/definitions/declarative_automation/operands/operands.py

@@ -14,6 +14,7 @@ from dagster._core.definitions.declarative_automation.automation_context import
 from dagster._core.definitions.declarative_automation.operands.subset_automation_condition import (
     SubsetAutomationCondition,
 )
+from dagster._core.definitions.freshness import FreshnessState
 from dagster._core.definitions.partitions.snap.snap import PartitionsSnap
 from dagster._core.definitions.partitions.subset.key_ranges import KeyRangesPartitionsSubset
 from dagster._record import record
@@ -193,6 +194,21 @@ class NewlyUpdatedCondition(SubsetAutomationCondition):
         )
 
 
+@whitelist_for_serdes
+@record
+class FreshnessResultCondition(SubsetAutomationCondition[AssetKey]):
+    state: FreshnessState
+
+    @property
+    def name(self) -> str:
+        return f"freshness_result(state={self.state})"
+
+    async def compute_subset(self, context: AutomationContext[AssetKey]) -> EntitySubset[AssetKey]:  # pyright: ignore[reportIncompatibleMethodOverride]
+        return await context.asset_graph_view.compute_subset_with_freshness_state(
+            key=context.key, state=self.state
+        )
+
+
 @whitelist_for_serdes
 @record
 class DataVersionChangedCondition(SubsetAutomationCondition):

{dagster-1.12.0 → dagster-1.12.1}/dagster/_core/definitions/freshness.py

@@ -10,6 +10,7 @@ from dagster._core.definitions.asset_key import AssetKey
 from dagster._core.loader import LoadableBy, LoadingContext
 from dagster._record import IHaveNew, record, record_custom
 from dagster._serdes import deserialize_value, whitelist_for_serdes
+from dagster._symbol_annotations.public import public
 from dagster._time import datetime_from_timestamp, get_timezone
 from dagster._utils import check
 from dagster._utils.schedules import get_smallest_cron_interval, is_valid_cron_string
@@ -48,12 +49,21 @@ class FreshnessStateChange:
 INTERNAL_FRESHNESS_POLICY_METADATA_KEY = "dagster/internal_freshness_policy"
 
 
+@public
 class FreshnessPolicy(ABC):
     """Base class for all freshness policies.
-    The "internal" prefix is a temporary measure to distinguish these policies from an existing, deprecated freshness policy model
-    which has since been renamed to `LegacyFreshnessPolicy`.
-    Expect the name of this class to change to `FreshnessPolicy` in a future release.
 
+    A freshness policy allows you to define expectations for the timing and frequency of asset materializations.
+
+    An asset with a defined freshness policy can take on different freshness states:
+    - ``PASS``: The asset is passing its freshness policy.
+    - ``WARN``: The asset is close to failing its freshness policy.
+    - ``FAIL``: The asset is failing its freshness policy.
+    - ``UNKNOWN``: The asset has no materialization events, and the freshness state cannot be determined.
+
+    If an asset does not have a freshness policy defined, it will have a freshness state of ``NOT_APPLICABLE``.
+
+    This class provides static constructors for each of the supported freshness policy types. It is preferred to use these constructors to instantiate freshness policies, instead of instantiating the policy subtypes directly.
     """
 
     @classmethod
@@ -71,12 +81,67 @@ class FreshnessPolicy(ABC):
     def time_window(
         fail_window: timedelta, warn_window: Optional[timedelta] = None
     ) -> "TimeWindowFreshnessPolicy":
+        """Defines freshness with reference to a time window.
+
+        Args:
+            fail_window: a timedelta that defines the failure window for the asset.
+            warn_window: an optional timedelta that defines the warning window for the asset.
+
+        Returns:
+            A ``TimeWindowFreshnessPolicy`` instance.
+
+        Examples:
+            .. code-block:: python
+
+                policy = FreshnessPolicy.time_window(
+                    fail_window=timedelta(hours=24), warn_window=timedelta(hours=12)
+                )
+
+            This policy expects the asset to materialize at least once every 24 hours, and warns if the latest materialization is older than 12 hours.
+
+            - If it has been less than 12 hours since the latest materialization, the asset is passing its freshness policy, and will have a freshness state of ``PASS``.
+            - If it has been between 12 and 24 hours since the latest materialization, the asset will have a freshness state of ``WARN``.
+            - If it has been more than 24 hours since the latest materialization, the asset is failing its freshness policy, and will have a freshness state of ``FAIL``.
+
+        """
         return TimeWindowFreshnessPolicy.from_timedeltas(fail_window, warn_window)
 
     @staticmethod
     def cron(
         deadline_cron: str, lower_bound_delta: timedelta, timezone: str = "UTC"
     ) -> "CronFreshnessPolicy":
+        """Defines freshness with reference to a predetermined cron schedule.
+
+        Args:
+            deadline_cron: a cron string that defines a deadline for the asset to be materialized.
+            lower_bound_delta: a timedelta that defines the lower bound for when the asset could have been materialized.
+                If a deadline cron tick has passed and the most recent materialization is older than (deadline cron tick timestamp - lower bound delta),
+                the asset is considered stale until it materializes again.
+            timezone: optionally provide a timezone for cron evaluation. IANA time zone strings are supported. If not provided, defaults to UTC.
+
+        Returns:
+            A ``CronFreshnessPolicy`` instance.
+
+        Examples:
+            .. code-block:: python
+
+                policy = FreshnessPolicy.cron(
+                    deadline_cron="0 10 * * *",  # 10am daily
+                    lower_bound_delta=timedelta(hours=1),
+                )
+
+            This policy expects the asset to materialize every day between 9:00 AM and 10:00 AM.
+
+            - If the asset is materialized at 9:30 AM, the asset is passing its freshness policy, and will have a freshness state of ``PASS``. The asset will continue to pass the freshness policy until at least the deadline next day (10AM).
+            - If the asset is materialized at 9:59 AM, the asset is passing its freshness policy, and will have a freshness state of ``PASS``. The asset will continue to pass the freshness policy until at least the deadline next day (10AM).
+            - If the asset is not materialized by 10:00 AM, the asset is failing its freshness policy, and will have a freshness state of ``FAIL``. The asset will continue to fail the freshness policy until it is materialized again.
+            - If the asset is then materialized at 10:30AM, it will pass the freshness policy again until at least the deadline the next day (10AM).
+
+            Keep in mind that the policy will always look at the last completed cron tick.
+            So in the example above, if asset freshness is evaluated at 9:59 AM, the policy will still consider the previous day's 9-10AM window.
+
+
+        """
         return CronFreshnessPolicy(
             deadline_cron=deadline_cron, lower_bound_delta=lower_bound_delta, timezone=timezone
         )
@@ -114,31 +179,6 @@ class TimeWindowFreshnessPolicy(FreshnessPolicy, IHaveNew):
     }
 )
 class CronFreshnessPolicy(FreshnessPolicy, IHaveNew):
-    """Defines freshness with reference to a predetermined cron schedule.
-
-    Args:
-        deadline_cron: a cron string that defines a deadline for the asset to be materialized.
-        lower_bound_delta: a timedelta that defines the lower bound for when the asset could have been materialized.
-        If a deadline cron tick has passed and the most recent materialization is older than (deadline cron tick timestamp - lower bound delta), the asset is considered stale until it materializes again.
-        timezone: optionally provide a timezone for cron evaluation. IANA time zone strings are supported. If not provided, defaults to UTC.
-
-    Example:
-    policy = FreshnessPolicy.cron(
-        deadline_cron="0 10 * * *", # 10am daily
-        lower_bound_delta=timedelta(hours=1),
-    )
-
-    This policy expects the asset to materialize every day between 9:00 AM and 10:00 AM.
-
-    If the asset is materialized at 9:30 AM, the asset is fresh, and will continue to be fresh until at least the deadline next day (10AM)
-    If the asset is materialized at 9:59 AM, the asset is fresh, and will continue to be fresh until at least the deadline next day (10AM)
-    If the asset is not materialized by 10:00 AM, the asset is stale, and will continue to be stale until it is materialized.
-    If the asset is then materialized at 10:30AM, it becomes fresh again until at least the deadline the next day (10AM).
-
-    Keep in mind that the policy will always look at the last completed cron tick.
-    So in the example above, if asset freshness is evaluated at 9:59 AM, the policy will still consider the previous day's 9-10AM window.
-    """
-
     deadline_cron: str
     serializable_lower_bound_delta: SerializableTimeDelta
     timezone: str

{dagster-1.12.0 → dagster-1.12.1}/dagster/_core/definitions/job_definition.py

@@ -4,7 +4,7 @@ import warnings
 from collections.abc import Iterable, Mapping, Sequence
 from datetime import datetime
 from functools import cached_property, update_wrapper
-from typing import TYPE_CHECKING, AbstractSet, Any, Optional, Union, cast  # noqa: UP035
+from typing import TYPE_CHECKING, AbstractSet, Any, Optional, Union, cast  # noqa: UP035,
 
 import dagster._check as check
 from dagster._annotations import beta_param, deprecated, public
@@ -210,9 +210,6 @@ class JobDefinition(IHasInternalInit):
             self._was_provided_resources
         )
 
-        self._config_mapping = None
-        self._partitioned_config = None
-        self._run_config = None
         self._run_config_schema = None
         self._original_config_argument = config
 
@@ -396,9 +393,7 @@ class JobDefinition(IHasInternalInit):
 
         A partitioned config defines a way to map partition keys to run config for the job.
         """
-        if self.has_unresolved_configs:
-            self._resolve_configs()
-        return self._partitioned_config
+        return self._resolve_configs()[0]
 
     @public
     @property
@@ -407,9 +402,7 @@ class JobDefinition(IHasInternalInit):
 
         A config mapping defines a way to map a top-level config schema to run config for the job.
         """
-        if self.has_unresolved_configs:
-            self._resolve_configs()
-        return self._config_mapping
+        return self._resolve_configs()[1]
 
     @public
     @property
@@ -439,9 +432,7 @@ class JobDefinition(IHasInternalInit):
 
     @property
     def run_config(self) -> Optional[Mapping[str, Any]]:
-        if self.has_unresolved_configs:
-            self._resolve_configs()
-        return self._run_config
+        return self._resolve_configs()[2]
 
     @property
     def run_config_schema(self) -> "RunConfigSchema":
@@ -486,25 +477,24 @@ class JobDefinition(IHasInternalInit):
     def op_retry_policy(self) -> Optional[RetryPolicy]:
         return self._op_retry_policy
 
-    @property
-    def has_unresolved_configs(self) -> bool:
-        return (
-            self._partitioned_config is None
-            and self._run_config is None
-            and self._config_mapping is None
-        )
-
     @cached_method
-    def _resolve_configs(self) -> None:
+    def _resolve_configs(
+        self,
+    ) -> tuple[Optional[PartitionedConfig], Optional[ConfigMapping], Optional[Mapping[str, Any]]]:
         config = self._original_config_argument
         partition_def = self._original_partitions_def_argument
+
+        partitioned_config = None
+        config_mapping = None
+        run_config = None
+
         if partition_def:
-            self._partitioned_config = PartitionedConfig.from_flexible_config(config, partition_def)
+            partitioned_config = PartitionedConfig.from_flexible_config(config, partition_def)
         else:
             if isinstance(config, ConfigMapping):
-                self._config_mapping = config
+                config_mapping = config
             elif isinstance(config, PartitionedConfig):
-                self._partitioned_config = config
+                partitioned_config = config
                 if self.asset_layer:
                     for asset_key in self._asset_layer.selected_asset_keys:
                         asset_partitions_def = self._asset_layer.get(asset_key).partitions_def
@@ -516,10 +506,10 @@ class JobDefinition(IHasInternalInit):
                         )
 
             elif isinstance(config, dict):
-                self._run_config = config
+                run_config = config
                 # Using config mapping here is a trick to make it so that the preset will be used even
                 # when no config is supplied for the job.
-                self._config_mapping = _config_mapping_with_default_value(
+                config_mapping = _config_mapping_with_default_value(
                     get_run_config_schema_for_job(
                         self._graph_def,
                         self.resource_defs,
@@ -537,6 +527,8 @@ class JobDefinition(IHasInternalInit):
                     f" but is an object of type {type(config)}"
                 )
 
+        return partitioned_config, config_mapping, run_config
+
     def node_def_named(self, name: str) -> NodeDefinition:
         check.str_param(name, "name")
 
@@ -885,15 +877,15 @@ class JobDefinition(IHasInternalInit):
         self, partition_key: str, selected_asset_keys: Optional[Iterable[AssetKey]]
     ) -> Mapping[str, str]:
         """Gets tags for the given partition key."""
-        if self._partitioned_config is not None:
-            return self._partitioned_config.get_tags_for_partition_key(partition_key, self.name)
+        if self.partitioned_config is not None:
+            return self.partitioned_config.get_tags_for_partition_key(partition_key, self.name)
 
         partitions_def = self._get_partitions_def(selected_asset_keys)
         return partitions_def.get_tags_for_partition_key(partition_key)
 
     def get_run_config_for_partition_key(self, partition_key: str) -> Mapping[str, Any]:
-        if self._partitioned_config:
-            return self._partitioned_config.get_run_config_for_partition_key(partition_key)
+        if self.partitioned_config:
+            return self.partitioned_config.get_run_config_for_partition_key(partition_key)
         else:
             return {}
 

{dagster-1.12.0 → dagster-1.12.1}/dagster/_core/definitions/partitions/subset/time_window.py

@@ -457,15 +457,26 @@ class TimeWindowPartitionsSubset(
             [*self.included_time_windows, *other.included_time_windows],
             key=lambda tw: tw.start_timestamp,
         )
+
         result_windows = [input_time_windows[0]] if len(input_time_windows) > 0 else []
+
         for window in input_time_windows[1:]:
             latest_window = result_windows[-1]
             if window.start_timestamp <= latest_window.end_timestamp:
                 # merge this window with the latest window
-                result_windows[-1] = PersistedTimeWindow.from_public_time_window(
-                    TimeWindow(latest_window.start, max(latest_window.end, window.end)),
-                    self.partitions_def.timezone,
+                merged_window_end = (
+                    latest_window.end_timestamp_with_timezone
+                    if latest_window.end_timestamp >= window.end_timestamp
+                    else window.end_timestamp_with_timezone
                 )
+
+                merged_window = PersistedTimeWindow(
+                    latest_window.start_timestamp_with_timezone,
+                    merged_window_end,
+                )
+
+                # merge this window with the latest window
+                result_windows[-1] = merged_window
             else:
                 result_windows.append(window)
 

{dagster-1.12.0 → dagster-1.12.1}/dagster/_core/definitions/partitions/utils/time_window.py

@@ -96,6 +96,14 @@ class PersistedTimeWindow(
     def start_timestamp(self) -> float:
         return self._asdict()["start"].timestamp
 
+    @property
+    def start_timestamp_with_timezone(self) -> TimestampWithTimezone:
+        return self._asdict()["start"]
+
+    @property
+    def end_timestamp_with_timezone(self) -> TimestampWithTimezone:
+        return self._asdict()["end"]
+
     @property
     def end_timestamp(self) -> float:
         return self._asdict()["end"].timestamp

{dagster-1.12.0 → dagster-1.12.1}/dagster/_core/remote_representation/code_location.py

@@ -1,9 +1,10 @@
 import sys
 import threading
 from abc import abstractmethod
+from collections import defaultdict
 from collections.abc import Mapping, Sequence
 from contextlib import AbstractContextManager
-from functools import cached_property
+from functools import cached_property, partial
 from typing import TYPE_CHECKING, Any, Callable, Optional, Union, cast
 
 from dagster_shared.libraries import DagsterLibraryRegistry
@@ -739,7 +740,8 @@ class GrpcServerCodeLocation(CodeLocation):
 
             self._container_context = list_repositories_response.container_context
 
-            self._job_snaps = {}
+            self._job_snaps_by_name = defaultdict(dict)
+            self._job_snaps_by_snapshot_id = {}
 
             self.remote_repositories = {}
 
@@ -755,21 +757,25 @@ class GrpcServerCodeLocation(CodeLocation):
                         code_location=self,
                     ),
                     auto_materialize_use_sensors=instance.auto_materialize_use_sensors,
-                    ref_to_data_fn=self._job_ref_to_snap,
+                    ref_to_data_fn=partial(self._job_ref_to_snap, repo_name),
                 )
                 for job_snap in job_snaps.values():
-                    self._job_snaps[job_snap.snapshot_id] = job_snap
+                    self._job_snaps_by_name[repo_name][job_snap.name] = job_snap
+                    self._job_snaps_by_snapshot_id[job_snap.snapshot_id] = job_snap
 
         except:
             self.cleanup()
             raise
 
-    def _job_ref_to_snap(self, job_ref: "JobRefSnap") -> "JobDataSnap":
+    def _job_ref_to_snap(self, repository_name: str, job_ref: "JobRefSnap") -> "JobDataSnap":
         from dagster._core.remote_representation.external_data import JobDataSnap
 
-        snapshot = self._job_snaps[job_ref.snapshot_id]
+        # key by name to ensure that we are resilient to snapshot ID instability
+        snapshot = self._job_snaps_by_name[repository_name][job_ref.name]
         parent_snapshot = (
-            self._job_snaps[job_ref.parent_snapshot_id] if job_ref.parent_snapshot_id else None
+            self._job_snaps_by_snapshot_id.get(job_ref.parent_snapshot_id)
+            if job_ref.parent_snapshot_id
+            else None
         )
         return JobDataSnap(
             name=job_ref.name,

{dagster-1.12.0 → dagster-1.12.1}/dagster/_core/storage/dagster_run.py

@@ -119,8 +119,6 @@ NOT_FINISHED_STATUSES = [
 # creating the run and launching or enqueueing it.
 CANCELABLE_RUN_STATUSES = [DagsterRunStatus.STARTED, DagsterRunStatus.QUEUED]
 
-DAGSTER_EXECUTION_METADATA_TAG_PREFIX = "DAGSTER_EXECUTION_"
-
 
 @whitelist_for_serdes(storage_name="PipelineRunStatsSnapshot")
 @record
@@ -422,13 +420,6 @@ class DagsterRun(
             if value := os.getenv(env_var):
                 tags[f"dagster/{tag}"] = value
 
-        # find any `DAGSTER_EXECUTION_METADATA_*` environment variables and add them as tags
-        for key, value in os.environ.items():
-            if key.startswith(DAGSTER_EXECUTION_METADATA_TAG_PREFIX):
-                tag_key = key[len(DAGSTER_EXECUTION_METADATA_TAG_PREFIX) :]
-                tag_key = tag_key.lower().replace("_", "-")
-                tags[f"dagster/{tag_key}"] = value
-
         return tags
 
     def tags_for_storage(self) -> Mapping[str, str]:

{dagster-1.12.0 → dagster-1.12.1}/dagster/_core/workspace/context.py

@@ -8,7 +8,7 @@ from collections.abc import Mapping, Sequence
 from contextlib import ExitStack
 from functools import cached_property
 from itertools import count
-from typing import TYPE_CHECKING, AbstractSet, Any, Optional, TypeVar, Union  # noqa: UP035
+from typing import TYPE_CHECKING, AbstractSet, Any, Generic, Optional, TypeVar, Union  # noqa: UP035
 
 from typing_extensions import Self
 
@@ -135,8 +135,10 @@ class BaseWorkspaceRequestContext(LoadingContext):
     def get_current_workspace(self) -> CurrentWorkspace: ...
 
     # abstracted since they may be calculated without the full CurrentWorkspace
+    @abstractmethod
     def get_location_entry(self, name: str) -> Optional[CodeLocationEntry]: ...
 
+    @abstractmethod
     def get_code_location_statuses(self) -> Sequence[CodeLocationStatusEntry]: ...
 
     # implemented here since they require the full CurrentWorkspace
@@ -833,14 +835,17 @@ class WorkspaceRequestContext(BaseWorkspaceRequestContext):
         return int(os.getenv("DAGSTER_UI_EVENT_LOAD_CHUNK_SIZE", "1000"))
 
 
-class IWorkspaceProcessContext(ABC):
+TRequestContext = TypeVar("TRequestContext", bound="BaseWorkspaceRequestContext")
+
+
+class IWorkspaceProcessContext(ABC, Generic[TRequestContext]):
     """Class that stores process-scoped information about a webserver session.
     In most cases, you will want to create a `BaseWorkspaceRequestContext` to create a request-scoped
     object.
     """
 
     @abstractmethod
-    def create_request_context(self, source: Optional[Any] = None) -> BaseWorkspaceRequestContext:
+    def create_request_context(self, source: Optional[Any] = None) -> TRequestContext:
         """Create a usable fixed context for the scope of a request.
 
         Args:
@@ -883,7 +888,7 @@ class IWorkspaceProcessContext(ABC):
         pass
 
 
-class WorkspaceProcessContext(IWorkspaceProcessContext):
+class WorkspaceProcessContext(IWorkspaceProcessContext[WorkspaceRequestContext]):
     """Process-scoped object that tracks the state of a workspace.
 
     1. Maintains an update-to-date dictionary of repository locations

{dagster-1.12.0 → dagster-1.12.1}/dagster/components/lib/sql_component/sql_component.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from typing import Annotated, Any, Optional, Union
 
 from dagster_shared import check
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 from dagster._annotations import preview, public
 from dagster._core.definitions.result import MaterializeResult
@@ -24,9 +24,8 @@ class SqlComponent(ExecutableComponent, ABC):
     implement instructions on where to load the SQL content from.
     """
 
-    class Config:
-        # Necessary to allow connection to be a SQLClient, which is an ABC
-        arbitrary_types_allowed = True
+    # Necessary to allow connection to be a SQLClient, which is an ABC
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
     connection: Annotated[
         Annotated[