dagster 1.12.8__tar.gz → 1.12.9__tar.gz

{dagster-1.12.8/dagster.egg-info → dagster-1.12.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dagster
-Version: 1.12.8
+Version: 1.12.9
 Summary: Dagster is an orchestration platform for the development, production, and observation of data assets.
 Author: Dagster Labs
 Author-email: hello@dagsterlabs.com
@@ -24,11 +24,12 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Topic :: System :: Monitoring
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10,<3.14
+Requires-Python: >=3.10,<3.15
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: click<9.0,>=5.0
@@ -59,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.8
-Requires-Dist: dagster-shared==1.12.8
+Requires-Dist: dagster-pipes==1.12.9
+Requires-Dist: dagster-shared==1.12.9
 Requires-Dist: antlr4-python3-runtime
 Provides-Extra: docker
 Requires-Dist: docker; extra == "docker"

{dagster-1.12.8 → dagster-1.12.9}/dagster/_cli/definitions.py

@@ -139,7 +139,7 @@ def definitions_validate_command_impl(
                     logger.info(f"Validation successful for code location {code_location}.")
 
             try:
-                workspace.asset_graph.validate_partition_mappings()
+                workspace.asset_graph.validate_partitions()
             except Exception:
                 logger.error(
                     f"Asset graph contained an invalid partition mapping:\n{serializable_error_info_from_exc_info(sys.exc_info()).to_string()}"

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/asset_graph_view/asset_graph_view.py

@@ -238,9 +238,12 @@ class AssetGraphView(LoadingContext):
             self.asset_graph.has(key), f"Asset graph does not contain {key.to_user_string()}"
         )
 
-        serializable_subset = self._with_current_partitions_def(
-            asset_graph_subset.get_asset_subset(key, self.asset_graph)
-        )
+        serializable_subset = asset_graph_subset.get_asset_subset(key)
+
+        if not serializable_subset:
+            return self.get_empty_subset(key=key)
+
+        serializable_subset = self._with_current_partitions_def(serializable_subset)
 
         return EntitySubset(
             self, key=key, value=_ValidatedEntitySubsetValue(serializable_subset.value)
@@ -626,12 +629,8 @@ class AssetGraphView(LoadingContext):
     async def _compute_backfill_in_progress_asset_subset(
         self, key: AssetKey
     ) -> EntitySubset[AssetKey]:
-        value = (
-            self._queryer.get_active_backfill_in_progress_asset_graph_subset()
-            .get_asset_subset(asset_key=key, asset_graph=self.asset_graph)
-            .value
-        )
-        return EntitySubset(self, key=key, value=_ValidatedEntitySubsetValue(value))
+        asset_graph_subset = self._queryer.get_active_backfill_in_progress_asset_graph_subset()
+        return self.get_entity_subset_from_asset_graph_subset(asset_graph_subset, key)
 
     async def _compute_execution_failed_unpartitioned(self, key: AssetKey) -> bool:
         from dagster._core.event_api import AssetRecordsFilter

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/captured_log_api.py

@@ -1,11 +1,12 @@
 import base64
 from collections.abc import Sequence
-from typing import NamedTuple
 
+from dagster_shared.record import record
 from dagster_shared.seven import json
 
 
-class LogLineCursor(NamedTuple):
+@record
+class LogLineCursor:
     """Representation of a log line cursor, to keep track of the place in the logs.
     The captured logs are stored in multiple files in the same direcotry. The cursor keeps
     track of the file name and the number of lines read so far.
@@ -36,4 +37,6 @@ class LogLineCursor(NamedTuple):
     @staticmethod
     def parse(cursor_str: str) -> "LogLineCursor":
         raw = json.loads(base64.b64decode(cursor_str).decode("utf-8"))
-        return LogLineCursor(raw["log_key"], raw["line"], raw["has_more_now"])
+        return LogLineCursor(
+            log_key=raw["log_key"], line=raw["line"], has_more_now=raw["has_more_now"]
+        )

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/definitions/assets/graph/asset_graph_subset.py

@@ -67,9 +67,7 @@ class AssetGraphSubset(NamedTuple):
     def is_empty(self) -> bool:
         return len(self.asset_keys) == 0
 
-    def _get_serializable_entity_subset(
-        self, asset_key: AssetKey
-    ) -> SerializableEntitySubset[AssetKey]:
+    def get_asset_subset(self, asset_key: AssetKey) -> Optional[SerializableEntitySubset[AssetKey]]:
         if asset_key in self.non_partitioned_asset_keys:
             return SerializableEntitySubset(key=asset_key, value=True)
         elif asset_key in self.partitions_subsets_by_asset_key:
@@ -77,39 +75,10 @@ class AssetGraphSubset(NamedTuple):
                 key=asset_key, value=self.partitions_subsets_by_asset_key[asset_key]
             )
         else:
-            check.failed(f"Asset {asset_key} must be part of the AssetGraphSubset")
+            return None
 
-    def get_asset_subset(
-        self, asset_key: AssetKey, asset_graph: BaseAssetGraph
-    ) -> SerializableEntitySubset[AssetKey]:
-        """Returns an AssetSubset representing the subset of a specific asset that this
-        AssetGraphSubset contains.
-        """
-        if (
-            asset_key in self.non_partitioned_asset_keys
-            or asset_key in self.partitions_subsets_by_asset_key
-        ):
-            return self._get_serializable_entity_subset(asset_key)
-        else:
-            partitions_def = asset_graph.get(asset_key).partitions_def
-            return SerializableEntitySubset(
-                key=asset_key,
-                value=partitions_def.empty_subset() if partitions_def else False,
-            )
-
-    def get_partitions_subset(
-        self, asset_key: AssetKey, asset_graph: Optional[BaseAssetGraph] = None
-    ) -> PartitionsSubset:
-        if asset_graph:
-            partitions_def = asset_graph.get(asset_key).partitions_def
-            if partitions_def is None:
-                check.failed("Can only call get_partitions_subset on a partitioned asset")
-
-            return self.partitions_subsets_by_asset_key.get(
-                asset_key, partitions_def.empty_subset()
-            )
-        else:
-            return self.partitions_subsets_by_asset_key[asset_key]
+    def get_partitions_subset(self, asset_key: AssetKey) -> PartitionsSubset:
+        return self.partitions_subsets_by_asset_key[asset_key]
 
     def iterate_asset_partitions(self) -> Iterable[AssetKeyPartitionKey]:
         for (
@@ -127,7 +96,7 @@ class AssetGraphSubset(NamedTuple):
         AssetGraphSubset contains.
         """
         for asset_key in self.asset_keys:
-            yield self._get_serializable_entity_subset(asset_key)
+            yield check.not_none(self.get_asset_subset(asset_key))
 
     def __contains__(self, asset: Union[AssetKey, AssetKeyPartitionKey]) -> bool:  # pyright: ignore[reportIncompatibleMethodOverride]
         """If asset is an AssetKeyPartitionKey, check if the given AssetKeyPartitionKey is in the

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/definitions/assets/graph/base_asset_graph.py

@@ -638,11 +638,19 @@ class BaseAssetGraph(ABC, Generic[T_AssetNode]):
             and not self.has_materializable_parents(key)
         }
 
-    def validate_partition_mappings(self):
+    def validate_partitions(self):
         for node in self.asset_nodes:
             if node.is_external:
                 continue
 
+            if node.partitions_def:
+                try:
+                    node.partitions_def.validate_partition_definition()
+                except Exception as e:
+                    raise DagsterInvalidDefinitionError(
+                        f"Invalid partition definition for {node.key.to_user_string()}"
+                    ) from e
+
             parents = self.get_parents(node)
             for parent in parents:
                 if parent.partitions_def is None or parent.is_external:
@@ -738,7 +746,11 @@ class BaseAssetGraph(ABC, Generic[T_AssetNode]):
 
         queued_subsets_by_asset_key: dict[AssetKey, Optional[PartitionsSubset]] = {
             initial_asset_key: (
-                initial_subset.get_partitions_subset(initial_asset_key, self)
+                (
+                    initial_subset.get_partitions_subset(initial_asset_key)
+                    if initial_asset_key in initial_subset.partitions_subsets_by_asset_key
+                    else check.not_none(self.get(initial_asset_key).partitions_def).empty_subset()
+                )
                 if self.get(initial_asset_key).is_partitioned
                 else None
             ),

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/definitions/assets/graph/remote_asset_graph.py

@@ -514,6 +514,49 @@ class RemoteAssetGraph(BaseAssetGraph[TRemoteAssetNode], ABC, Generic[TRemoteAss
     def get_checks_for_asset(self, asset_key: AssetKey) -> Sequence[RemoteAssetCheckNode]:
         return self._asset_check_nodes_by_asset_key.get(asset_key, [])
 
+    @cached_property
+    def _asset_keys_by_normalized_table_name(self) -> Mapping[str, AbstractSet[AssetKey]]:
+        from dagster._core.definitions.metadata.metadata_set import TableMetadataSet
+
+        by_table_name = defaultdict(set)
+        for node in self.asset_nodes:
+            normalized_table_name = TableMetadataSet.extract(node.metadata).normalized_table_name
+            if normalized_table_name:
+                by_table_name[normalized_table_name.lower()].add(node.key)
+
+        return by_table_name
+
+    def get_assets_for_same_storage_address(
+        self, asset_key: AssetKey
+    ) -> AbstractSet[TRemoteAssetNode]:
+        """Returns all asset keys that have the same dagster/table_name metadata as the given asset key.
+
+        Comparison is case-insensitive, so 'DB.SCHEMA.TABLE' matches 'db.schema.table'.
+
+        Args:
+            asset_key: The asset key to find matching table assets for.
+
+        Returns:
+            A set of asset nodes (excluding the node for the input key) that share the same
+            table_name metadata.
+            Returns an empty set if the asset has no table_name metadata.
+        """
+        if not self.has(asset_key):
+            return set()
+
+        from dagster._core.definitions.metadata.metadata_set import TableMetadataSet
+
+        input_node = self.get(asset_key)
+        input_table_name = TableMetadataSet.extract(input_node.metadata).normalized_table_name
+
+        if not input_table_name:
+            return set()
+
+        return {
+            self.get(key)
+            for key in self._asset_keys_by_normalized_table_name[input_table_name] - {asset_key}
+        }
+
     def get_check_keys_for_assets(
         self, asset_keys: AbstractSet[AssetKey]
     ) -> AbstractSet[AssetCheckKey]:

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/definitions/auto_materialize_rule_impls.py

@@ -1056,14 +1056,19 @@ class SkipOnBackfillInProgressRule(
             AutomationResult,
         )
 
+        # this backfilling subset is aware of the current partitions definitions, and so will
+        # be valid
+        asset_subset = (
+            context.legacy_context.instance_queryer.get_active_backfill_target_asset_graph_subset().get_asset_subset(
+                context.legacy_context.asset_key
+            )
+            or context.asset_graph_view.get_empty_subset(
+                key=context.legacy_context.asset_key
+            ).convert_to_serializable_subset()
+        )
+
         backfilling_subset = ValidAssetSubset.coerce_from_subset(
-            # this backfilling subset is aware of the current partitions definitions, and so will
-            # be valid
-            (
-                context.legacy_context.instance_queryer.get_active_backfill_target_asset_graph_subset()
-            ).get_asset_subset(
-                context.legacy_context.asset_key, context.legacy_context.asset_graph
-            ),
+            asset_subset,
             context.legacy_context.partitions_def,
         )
 

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/definitions/job_definition.py

@@ -828,6 +828,10 @@ class JobDefinition(IHasInternalInit):
             asset_selection=frozenset(asset_selection) if asset_selection else None,
         )
 
+    @property
+    def is_asset_job(self) -> bool:
+        return bool(self.asset_layer and self.asset_layer.selected_asset_keys)
+
     def _get_partitions_def(
         self, selected_asset_keys: Optional[Iterable[AssetKey]]
     ) -> PartitionsDefinition:

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/definitions/metadata/metadata_set.py

@@ -197,6 +197,10 @@ class TableMetadataSet(NamespacedMetadataSet):
     def current_key_by_legacy_key(cls) -> Mapping[str, str]:
         return {"relation_identifier": "table_name"}
 
+    @property
+    def normalized_table_name(self) -> Optional[str]:
+        return self.table_name.lower() if self.table_name else None
+
 
 class UriMetadataSet(NamespacedMetadataSet):
     """Metadata entry which supplies a URI address for an asset.

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/definitions/partitions/definition/partitions_definition.py

@@ -39,6 +39,9 @@ class PartitionsDefinition(ABC, Generic[T_str]):
 
         return DefaultPartitionsSubset
 
+    def validate_partition_definition(self) -> None:
+        pass
+
     @abstractmethod
     @public
     def get_partition_keys(

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/definitions/partitions/definition/time_window.py

@@ -196,6 +196,21 @@ class TimeWindowPartitionsDefinition(PartitionsDefinition, IHaveNew):
             exclusions=cleaned_exclusions if cleaned_exclusions else None,
         )
 
+    def validate_partition_definition(self) -> None:
+        # Try to determine if there are multiple time ranges being mapped
+        # to the same partition key.
+        first_partition_key = self.get_first_partition_key()
+
+        if first_partition_key is None:
+            return
+
+        if self.get_next_partition_key(first_partition_key) == first_partition_key:
+            raise DagsterInvalidDefinitionError(
+                "This partition set contains multiple time ranges that map to the same partition key. "
+                f"This usually indicates that the partition set's format string ({self.fmt}) is "
+                f"not granular enough to produce a unique key for each time in the cron schedule ({self.cron_schedule})."
+            )
+
     @property
     def start_timestamp(self) -> float:
         return self.start_ts.timestamp

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/definitions/reconstruct.py

@@ -392,7 +392,7 @@ def reconstructable(target: Callable[..., "JobDefinition"]) -> ReconstructableJo
                 "``GraphDefinition.to_job``, you must wrap the ``to_job`` call in a function at "
                 "module scope, ie not within any other functions. "
                 "To learn more, check out the docs on ``reconstructable``: "
-                "https://docs.dagster.io/api/python-api/execution#dagster.reconstructable"
+                "https://docs.dagster.io/api/dagster/execution#dagster.reconstructable"
             )
         raise DagsterInvariantViolationError(
             "Reconstructable target should be a function or definition produced "

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/definitions/repository_definition/repository_definition.py

@@ -196,7 +196,7 @@ class RepositoryDefinition:
 
     def validate_loadable(self):
         self.load_all_definitions()
-        self.asset_graph.validate_partition_mappings()
+        self.asset_graph.validate_partitions()
 
     @public
     @property

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/execution/api.py

@@ -190,7 +190,7 @@ def execute_run(
             "execute_run requires a reconstructable job but received job definition directly"
             " instead. To support hand-off to other processes please wrap your definition in a call"
             " to reconstructable(). Learn more about reconstructable here:"
-            " https://docs.dagster.io/api/python-api/execution#dagster.reconstructable"
+            " https://docs.dagster.io/api/dagster/execution#dagster.reconstructable"
         )
 
     check.inst_param(job, "job", IJob)

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/execution/asset_backfill.py

@@ -331,12 +331,18 @@ class AssetBackfillData(NamedTuple):
 
         Orders keys in the same topological level alphabetically.
         """
-        nodes: list[BaseAssetNode] = [asset_graph.get(key) for key in self.target_subset.asset_keys]
+        nodes: list[BaseAssetNode] = [
+            asset_graph.get(key) for key in self.target_subset.asset_keys if asset_graph.has(key)
+        ]
         return [
             item
             for items_by_level in toposort({node.key: node.parent_keys for node in nodes})
             for item in sorted(items_by_level)
             if item in self.target_subset.asset_keys
+        ] + [
+            asset_key
+            for asset_key in self.target_subset.asset_keys
+            if not asset_graph.has(asset_key)
         ]
 
     def get_backfill_status_per_asset_key(
@@ -350,15 +356,23 @@ class AssetBackfillData(NamedTuple):
         def _get_status_for_asset_key(
             asset_key: AssetKey,
         ) -> Union[PartitionedAssetBackfillStatus, UnpartitionedAssetBackfillStatus]:
-            if asset_graph.get(asset_key).is_partitioned:
-                materialized_subset = self.materialized_subset.get_partitions_subset(
-                    asset_key, asset_graph
+            target_subset = check.not_none(self.target_subset.get_asset_subset(asset_key))
+
+            if target_subset.is_partitioned:
+                materialized_subset = (
+                    self.materialized_subset.get_partitions_subset(asset_key)
+                    if asset_key in self.materialized_subset.asset_keys
+                    else target_subset.subset_value.empty_subset()
                 )
-                failed_subset = self.failed_and_downstream_subset.get_partitions_subset(
-                    asset_key, asset_graph
+                failed_subset = (
+                    self.failed_and_downstream_subset.get_partitions_subset(asset_key)
+                    if asset_key in self.failed_and_downstream_subset.asset_keys
+                    else target_subset.subset_value.empty_subset()
                 )
-                requested_subset = self.requested_subset.get_partitions_subset(
-                    asset_key, asset_graph
+                requested_subset = (
+                    self.requested_subset.get_partitions_subset(asset_key)
+                    if asset_key in self.requested_subset.asset_keys
+                    else target_subset.subset_value.empty_subset()
                 )
 
                 # The failed subset includes partitions that failed and their downstream partitions.
@@ -371,7 +385,7 @@ class AssetBackfillData(NamedTuple):
 
                 return PartitionedAssetBackfillStatus(
                     asset_key,
-                    len(self.target_subset.get_partitions_subset(asset_key, asset_graph)),
+                    len(self.target_subset.get_partitions_subset(asset_key)),
                     {
                         AssetBackfillStatus.MATERIALIZED: len(materialized_subset),
                         AssetBackfillStatus.FAILED: len(failed_subset - materialized_subset),
@@ -1961,8 +1975,16 @@ def _get_cant_run_because_of_parent_reason(
     if parent_node.partitions_def != candidate_node.partitions_def:
         return f"parent {parent_node.key.to_user_string()} and {candidate_node.key.to_user_string()} have different partitions definitions so they cannot be materialized in the same run. {candidate_node.key.to_user_string()} can be materialized once {parent_node.key.to_user_string()} is materialized."
 
-    parent_target_subset = target_subset.get_asset_subset(parent_asset_key, asset_graph)
-    candidate_target_subset = target_subset.get_asset_subset(candidate_asset_key, asset_graph)
+    parent_target_subset = (
+        target_subset.get_asset_subset(parent_asset_key)
+        or asset_graph_view.get_empty_subset(key=parent_asset_key).convert_to_serializable_subset()
+    )
+    candidate_target_subset = (
+        target_subset.get_asset_subset(candidate_asset_key)
+        or asset_graph_view.get_empty_subset(
+            key=candidate_asset_key
+        ).convert_to_serializable_subset()
+    )
 
     num_parent_partitions_being_requested_this_tick = parent_being_requested_this_tick_subset.size
 

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/execution/context/op_execution_context.py

@@ -183,6 +183,20 @@ class OpExecutionContext(AbstractComputeExecutionContext):
         """str: The id of the current execution's run."""
         return self._step_execution_context.run_id
 
+    @public
+    @property
+    def location_name(self) -> Optional[str]:
+        """Optional[str]: The name of the code location for this run.
+
+        This is the name of the code location (repository location) from which
+        the job/pipeline was loaded. Returns None if the job was not loaded from
+        a remote code location (e.g., in tests or when running locally without
+        a code location).
+        """
+        if self.dagster_run and self.dagster_run.remote_job_origin:
+            return self.dagster_run.remote_job_origin.location_name
+        return None
+
     @public
     @property
     def run_config(self) -> Mapping[str, object]:

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/executor/base.py

@@ -79,12 +79,12 @@ class Executor(ABC):
         else:
             return original_event
 
-    def get_failure_or_retry_event_after_error(
+    def log_failure_or_retry_event_after_error(
         self,
         step_context: "IStepContext",
         err_info: SerializableErrorInfo,
         known_state: "KnownExecutionState",
-    ):
+    ) -> "DagsterEvent":
         from dagster._core.events import DagsterEvent
 
         # determine the retry policy for the step if needed

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/executor/multiprocess.py

@@ -285,7 +285,7 @@ class MultiprocessExecutor(Executor):
                                 )
 
                                 failure_or_retry_event = (
-                                    self.get_failure_or_retry_event_after_error(
+                                    self.log_failure_or_retry_event_after_error(
                                         step_context,
                                         event_or_none.engine_event_data.error,
                                         active_execution.get_known_state(),
@@ -309,7 +309,7 @@ class MultiprocessExecutor(Executor):
                                 ),
                                 EngineEventData.engine_error(serializable_error),
                             )
-                            failure_or_retry_event = self.get_failure_or_retry_event_after_error(
+                            failure_or_retry_event = self.log_failure_or_retry_event_after_error(
                                 step_context, serializable_error, active_execution.get_known_state()
                             )
 

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/executor/step_delegating/step_delegating_executor.py

@@ -13,7 +13,6 @@ from dagster._core.events import DagsterEvent, DagsterEventType, EngineEventData
 from dagster._core.execution.context.system import PlanOrchestrationContext
 from dagster._core.execution.plan.active import ActiveExecution
 from dagster._core.execution.plan.instance_concurrency_context import InstanceConcurrencyContext
-from dagster._core.execution.plan.objects import StepFailureData
 from dagster._core.execution.plan.plan import ExecutionPlan
 from dagster._core.execution.retries import RetryMode
 from dagster._core.execution.step_dependency_config import StepDependencyConfig
@@ -319,7 +318,7 @@ class StepDelegatingExecutor(Executor):
                                     assert isinstance(
                                         dagster_event.engine_event_data.error, SerializableErrorInfo
                                     )
-                                    self.get_failure_or_retry_event_after_error(
+                                    self.log_failure_or_retry_event_after_error(
                                         step_context,
                                         dagster_event.engine_event_data.error,
                                         active_execution.get_known_state(),
@@ -363,23 +362,20 @@ class StepDelegatingExecutor(Executor):
                                             cls_name=None,
                                         )
 
-                                        self.get_failure_or_retry_event_after_error(
+                                        self.log_failure_or_retry_event_after_error(
                                             step_context,
                                             health_check_error,
                                             active_execution.get_known_state(),
                                         )
 
                                 except Exception:
-                                    serializable_error = serializable_error_info_from_exc_info(
-                                        sys.exc_info()
-                                    )
-                                    # Log a step failure event if there was an error during the health
-                                    # check
-                                    DagsterEvent.step_failure_event(
-                                        step_context=plan_context.for_step(step),
-                                        step_failure_data=StepFailureData(
-                                            error=serializable_error,
-                                            user_failure_data=None,
+                                    DagsterEvent.engine_event(
+                                        step_context,
+                                        f"Error while checking health for step {step.key}",
+                                        EngineEventData(
+                                            error=serializable_error_info_from_exc_info(
+                                                sys.exc_info()
+                                            )
                                         ),
                                     )
 

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/instance/instance.py

@@ -89,7 +89,7 @@ class DagsterInstance(
     For example, to use Postgres for dagster storage, you can write a ``dagster.yaml`` such as the
     following:
 
-    .. literalinclude:: ../../../../../../examples/docs_snippets/docs_snippets/deploying/dagster-pg.yaml
+    .. literalinclude:: ../../../../../examples/docs_snippets/docs_snippets/deploying/dagster-pg.yaml
        :caption: dagster.yaml
        :language: YAML
 

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/instance/runs/run_domain.py

@@ -35,6 +35,7 @@ from dagster._core.storage.tags import (
     ASSET_RESUME_RETRY_TAG,
     BACKFILL_ID_TAG,
     BACKFILL_TAGS,
+    CODE_LOCATION_TAG,
     PARENT_RUN_ID_TAG,
     PARTITION_NAME_TAG,
     RESUME_RETRY_TAG,
@@ -222,6 +223,15 @@ class RunDomain:
                 "must include a remote job origin when creating a run using a remote asset graph",
             )
 
+        # Add the code location tag to the validated tags
+        # This is useful for filtering runs by code location in the web server
+        # or control concurrency by code location with tag concurrency limits.
+        if remote_job_origin:
+            validated_tags = {
+                **validated_tags,
+                CODE_LOCATION_TAG: remote_job_origin.repository_origin.code_location_origin.location_name,
+            }
+
         dagster_run = self.construct_run_with_snapshots(
             job_name=job_name,
             run_id=run_id,  # type: ignore  # (possible none)

{dagster-1.12.8 → dagster-1.12.9}/dagster/_core/selector/subset_selector.py

@@ -237,12 +237,12 @@ def fetch_sources(
     def has_upstream_within_selection(key: AssetKey) -> bool:
         if key not in dp:
             dp[key] = any(
-                parent_node in within_selection or has_upstream_within_selection(parent_node)
-                for parent_node in graph.get(key).parent_keys - {key}
+                parent_key in within_selection or has_upstream_within_selection(parent_key)
+                for parent_key in (graph.asset_dep_graph["upstream"][key] - {key})
             )
         return dp[key]
 
-    return {node for node in within_selection if not has_upstream_within_selection(node)}
+    return {key for key in within_selection if not has_upstream_within_selection(key)}
 
 
 def fetch_connected_assets_definitions(