dagster 1.11.13__tar.gz → 1.11.15__tar.gz

{dagster-1.11.13/dagster.egg-info → dagster-1.11.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dagster
-Version: 1.11.13
+Version: 1.11.15
 Summary: Dagster is an orchestration platform for the development, production, and observation of data assets.
 Author: Dagster Labs
 Author-email: hello@dagsterlabs.com
@@ -32,7 +32,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9,<3.14
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: click<8.2,>=5.0
+Requires-Dist: click<9.0,>=5.0
 Requires-Dist: coloredlogs<=14.0,>=6.1
 Requires-Dist: Jinja2
 Requires-Dist: alembic!=1.11.0,!=1.6.3,!=1.7.0,>=1.2.1
@@ -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.11.13
-Requires-Dist: dagster-shared==1.11.13
+Requires-Dist: dagster-pipes==1.11.15
+Requires-Dist: dagster-shared==1.11.15
 Requires-Dist: antlr4-python3-runtime
 Provides-Extra: docker
 Requires-Dist: docker; extra == "docker"
@@ -164,24 +164,25 @@ With Dagster, you declare—as Python functions—the data assets that you want
 Here is an example of a graph of three assets defined in Python:
 
 ```python
-from dagster import asset
-from pandas import DataFrame, read_html, get_dummies
+import dagster as dg
+import pandas as pd
+
 from sklearn.linear_model import LinearRegression
 
-@asset
-def country_populations() -> DataFrame:
-    df = read_html("https://tinyurl.com/mry64ebh")[0]
+@dg.asset
+def country_populations() -> pd.DataFrame:
+    df = pd.read_html("https://tinyurl.com/mry64ebh")[0]
     df.columns = ["country", "pop2022", "pop2023", "change", "continent", "region"]
-    df["change"] = df["change"].str.rstrip("%").str.replace("−", "-").astype("float")
+    df["change"] = df["change"].str.rstrip("%").astype("float")
     return df
 
-@asset
-def continent_change_model(country_populations: DataFrame) -> LinearRegression:
+@dg.asset
+def continent_change_model(country_populations: pd.DataFrame) -> LinearRegression:
     data = country_populations.dropna(subset=["change"])
-    return LinearRegression().fit(get_dummies(data[["continent"]]), data["change"])
+    return LinearRegression().fit(pd.get_dummies(data[["continent"]]), data["change"])
 
-@asset
-def continent_stats(country_populations: DataFrame, continent_change_model: LinearRegression) -> DataFrame:
+@dg.asset
+def continent_stats(country_populations: pd.DataFrame, continent_change_model: LinearRegression) -> pd.DataFrame:
     result = country_populations.groupby("continent").sum()
     result["pop_change_factor"] = continent_change_model.coef_
     return result
@@ -258,7 +259,7 @@ Join our community here:
 - 🌟 [Star us on GitHub](https://github.com/dagster-io/dagster)
 - 📥 [Subscribe to our Newsletter](https://dagster.io/newsletter-signup)
 - 🐦 [Follow us on Twitter](https://twitter.com/dagster)
-- 🕴️ [Follow us on LinkedIn](https://linkedin.com/showcase/dagster)
+- 🕴️ [Follow us on LinkedIn](https://www.linkedin.com/company/dagsterlabs/)
 - 📺 [Subscribe to our YouTube channel](https://www.youtube.com/@dagsterio)
 - 📚 [Read our blog posts](https://dagster.io/blog)
 - 👋 [Join us on Slack](https://dagster.io/slack)

{dagster-1.11.13 → dagster-1.11.15}/README.md

@@ -35,24 +35,25 @@ With Dagster, you declare—as Python functions—the data assets that you want
 Here is an example of a graph of three assets defined in Python:
 
 ```python
-from dagster import asset
-from pandas import DataFrame, read_html, get_dummies
+import dagster as dg
+import pandas as pd
+
 from sklearn.linear_model import LinearRegression
 
-@asset
-def country_populations() -> DataFrame:
-    df = read_html("https://tinyurl.com/mry64ebh")[0]
+@dg.asset
+def country_populations() -> pd.DataFrame:
+    df = pd.read_html("https://tinyurl.com/mry64ebh")[0]
     df.columns = ["country", "pop2022", "pop2023", "change", "continent", "region"]
-    df["change"] = df["change"].str.rstrip("%").str.replace("−", "-").astype("float")
+    df["change"] = df["change"].str.rstrip("%").astype("float")
     return df
 
-@asset
-def continent_change_model(country_populations: DataFrame) -> LinearRegression:
+@dg.asset
+def continent_change_model(country_populations: pd.DataFrame) -> LinearRegression:
     data = country_populations.dropna(subset=["change"])
-    return LinearRegression().fit(get_dummies(data[["continent"]]), data["change"])
+    return LinearRegression().fit(pd.get_dummies(data[["continent"]]), data["change"])
 
-@asset
-def continent_stats(country_populations: DataFrame, continent_change_model: LinearRegression) -> DataFrame:
+@dg.asset
+def continent_stats(country_populations: pd.DataFrame, continent_change_model: LinearRegression) -> pd.DataFrame:
     result = country_populations.groupby("continent").sum()
     result["pop_change_factor"] = continent_change_model.coef_
     return result
@@ -129,7 +130,7 @@ Join our community here:
 - 🌟 [Star us on GitHub](https://github.com/dagster-io/dagster)
 - 📥 [Subscribe to our Newsletter](https://dagster.io/newsletter-signup)
 - 🐦 [Follow us on Twitter](https://twitter.com/dagster)
-- 🕴️ [Follow us on LinkedIn](https://linkedin.com/showcase/dagster)
+- 🕴️ [Follow us on LinkedIn](https://www.linkedin.com/company/dagsterlabs/)
 - 📺 [Subscribe to our YouTube channel](https://www.youtube.com/@dagsterio)
 - 📚 [Read our blog posts](https://dagster.io/blog)
 - 👋 [Join us on Slack](https://dagster.io/slack)

{dagster-1.11.13 → dagster-1.11.15}/dagster/_api/snapshot_repository.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
     from dagster._grpc.client import DagsterGrpcClient
 
 
-def sync_get_streaming_external_repositories_data_grpc(
+def sync_get_external_repositories_data_grpc(
     api_client: "DagsterGrpcClient", code_location: "CodeLocation"
 ) -> Mapping[str, RepositorySnap]:
     from dagster._core.remote_origin import RemoteRepositoryOrigin
@@ -21,21 +21,12 @@ def sync_get_streaming_external_repositories_data_grpc(
 
     repo_datas = {}
     for repository_name in code_location.repository_names:  # type: ignore
-        external_repository_chunks = list(
-            api_client.streaming_external_repository(
+        result = deserialize_value(
+            api_client.external_repository(
                 remote_repository_origin=RemoteRepositoryOrigin(
                     code_location.origin,
                     repository_name,
                 )
-            )
-        )
-
-        result = deserialize_value(
-            "".join(
-                [
-                    chunk["serialized_external_repository_chunk"]
-                    for chunk in external_repository_chunks
-                ]
             ),
             (RepositorySnap, RepositoryErrorSnap),
         )
@@ -47,7 +38,7 @@ def sync_get_streaming_external_repositories_data_grpc(
     return repo_datas
 
 
-async def gen_streaming_external_repositories_data_grpc(
+async def gen_external_repositories_data_grpc(
     api_client: "DagsterGrpcClient", code_location: "CodeLocation"
 ) -> Mapping[str, RepositorySnap]:
     from dagster._core.remote_origin import RemoteRepositoryOrigin
@@ -57,22 +48,12 @@ async def gen_streaming_external_repositories_data_grpc(
 
     repo_datas = {}
     for repository_name in code_location.repository_names:  # type: ignore
-        external_repository_chunks = [
-            chunk
-            async for chunk in api_client.gen_streaming_external_repository(
+        result = deserialize_value(
+            await api_client.gen_external_repository(
                 remote_repository_origin=RemoteRepositoryOrigin(
                     code_location.origin,
                     repository_name,
                 )
-            )
-        ]
-
-        result = deserialize_value(
-            "".join(
-                [
-                    chunk["serialized_external_repository_chunk"]
-                    for chunk in external_repository_chunks
-                ]
             ),
             (RepositorySnap, RepositoryErrorSnap),
         )

{dagster-1.11.13 → dagster-1.11.15}/dagster/_cli/workspace/cli_target.py

@@ -466,6 +466,7 @@ def _get_code_pointer_dict_from_python_pointer_opts(
         working_directory=working_directory,
         attribute=params.attribute,
         autoload_defs_module_name=params.autoload_defs_module_name,
+        resolve_lazy_defs=True,
     )
 
     # repository_name -> code_pointer

{dagster-1.11.13 → dagster-1.11.15}/dagster/_config/pythonic_config/conversion_utils.py

@@ -1,4 +1,5 @@
 import inspect
+import sys
 from collections.abc import Mapping
 from enum import Enum
 from typing import Annotated, Any, Literal, Optional, TypeVar, Union
@@ -35,6 +36,15 @@ from dagster._core.errors import (
 )
 from dagster._utils.typing_api import is_closed_python_optional_type
 
+if sys.version_info >= (3, 10):
+    # Support models being built with the `Foo | Bar` syntax,
+    # not just `Union[Foo, Bar]`
+    from types import UnionType
+
+    _UNION_TYPES = [Union, UnionType]
+else:
+    _UNION_TYPES = [Union]
+
 
 # This is from https://github.com/dagster-io/dagster/pull/11470
 def _apply_defaults_to_schema_field(field: Field, additional_default_values: Any) -> Field:
@@ -250,7 +260,7 @@ def _convert_pydantic_discriminated_union_field(pydantic_field: ModelFieldCompat
     field_type = pydantic_field.annotation
     discriminator = pydantic_field.discriminator if pydantic_field.discriminator else None
 
-    if not get_origin(field_type) == Union:
+    if get_origin(field_type) not in _UNION_TYPES:
         raise DagsterInvalidDefinitionError("Discriminated union must be a Union type.")
 
     sub_fields = get_args(field_type)

{dagster-1.11.13 → dagster-1.11.15}/dagster/_core/asset_graph_view/asset_graph_view.py

@@ -612,6 +612,54 @@ class AssetGraphView(LoadingContext):
         )
         return EntitySubset(self, key=key, value=_ValidatedEntitySubsetValue(value))
 
+    async def _compute_execution_failed_unpartitioned(self, key: AssetKey) -> bool:
+        from dagster._core.event_api import AssetRecordsFilter
+        from dagster._core.storage.dagster_run import DagsterRunStatus, RunRecord
+        from dagster._core.storage.event_log.base import AssetRecord
+        from dagster._utils.storage import get_materialization_chunk_size
+
+        planned_materialization_info = (
+            self.instance.event_log_storage.get_latest_planned_materialization_info(key)
+        )
+        if not planned_materialization_info:
+            # has never been planned
+            return False
+
+        planned_storage_id = planned_materialization_info.storage_id
+        planned_run_id = planned_materialization_info.run_id
+        run = await RunRecord.gen(self, planned_run_id)
+
+        # note that if the run did fail, it's still possible that the materialization was successful,
+        # hence the extra code below this conditional
+        if not run or run.dagster_run.status != DagsterRunStatus.FAILURE:
+            # latest run did not fail
+            return False
+
+        # performance optimization: we will generally have this record cached, and in most cases
+        # the most recent materialization will map to the most recent planned run
+        asset_record = await AssetRecord.gen(self, key)
+        asset_entry = asset_record.asset_entry if asset_record else None
+        latest_materialization = asset_entry.last_materialization_record if asset_entry else None
+        if latest_materialization and latest_materialization.run_id == planned_run_id:
+            return False
+
+        # look for any materializations for the latest planned run for cases where
+        # the run failed but the materialization was successful
+        has_more = True
+        cursor = None
+        while has_more:
+            result = self.instance.fetch_materializations(
+                AssetRecordsFilter(asset_key=key, after_storage_id=planned_storage_id),
+                limit=get_materialization_chunk_size(),
+                cursor=cursor,
+            )
+            has_more, cursor = result.has_more, result.cursor
+            if any(record.run_id == planned_run_id for record in result.records):
+                return False
+
+        # could not find any materializations for the latest planned run
+        return True
+
     async def _compute_execution_failed_asset_subset(self, key: AssetKey) -> EntitySubset[AssetKey]:
         from dagster._core.storage.partition_status_cache import AssetStatusCacheValue
 
@@ -623,8 +671,9 @@ class AssetGraphView(LoadingContext):
                 if cache_value
                 else self.get_empty_subset(key=key)
             )
-        value = self._queryer.get_failed_asset_subset(asset_key=key).value
-        return EntitySubset(self, key=key, value=_ValidatedEntitySubsetValue(value))
+        else:
+            value = await self._compute_execution_failed_unpartitioned(key)
+            return EntitySubset(self, key=key, value=_ValidatedEntitySubsetValue(value))
 
     async def _compute_missing_asset_subset(
         self, key: AssetKey, from_subset: EntitySubset

{dagster-1.11.13 → dagster-1.11.15}/dagster/_core/definitions/asset_health/asset_check_health.py

@@ -25,6 +25,9 @@ class AssetCheckHealthState(LoadableBy[AssetKey]):
     failing_checks: set[AssetCheckKey]
     warning_checks: set[AssetCheckKey]
     all_checks: set[AssetCheckKey]
+    latest_passing_check_timestamp: Optional[float] = None
+    latest_failing_check_timestamp: Optional[float] = None
+    latest_warning_check_timestamp: Optional[float] = None
 
     @classmethod
     def default(cls) -> "AssetCheckHealthState":
@@ -33,6 +36,9 @@ class AssetCheckHealthState(LoadableBy[AssetKey]):
             failing_checks=set(),
             warning_checks=set(),
             all_checks=set(),
+            latest_passing_check_timestamp=None,
+            latest_failing_check_timestamp=None,
+            latest_warning_check_timestamp=None,
         )
 
     @property
@@ -77,6 +83,10 @@ class AssetCheckHealthState(LoadableBy[AssetKey]):
         warning_checks = set()
         failing_checks = set()
 
+        latest_passing_check_timestamp = None
+        latest_failing_check_timestamp = None
+        latest_warning_check_timestamp = None
+
         check_records = await AssetCheckSummaryRecord.gen_many(
             loading_context,
             check_keys,
@@ -125,20 +135,55 @@ class AssetCheckHealthState(LoadableBy[AssetKey]):
                     and last_check_evaluation.severity == AssetCheckSeverity.WARN
                 ):
                     warning_checks.add(check_key)
+                    if check_record.last_completed_check_execution_record is not None and (
+                        latest_warning_check_timestamp is None
+                        or latest_warning_check_timestamp
+                        < check_record.last_completed_check_execution_record.create_timestamp
+                    ):
+                        latest_warning_check_timestamp = (
+                            check_record.last_completed_check_execution_record.create_timestamp
+                        )
                 else:
                     failing_checks.add(check_key)
+                    if check_record.last_completed_check_execution_record is not None and (
+                        latest_failing_check_timestamp is None
+                        or latest_failing_check_timestamp
+                        < check_record.last_completed_check_execution_record.create_timestamp
+                    ):
+                        latest_failing_check_timestamp = (
+                            check_record.last_completed_check_execution_record.create_timestamp
+                        )
             elif last_check_execution_status == AssetCheckExecutionResolvedStatus.EXECUTION_FAILED:
                 # EXECUTION_FAILED checks don't have an evaluation and we want to report them as failures
                 failing_checks.add(check_key)
+                if check_record.last_completed_check_execution_record is not None and (
+                    latest_failing_check_timestamp is None
+                    or latest_failing_check_timestamp
+                    < check_record.last_completed_check_execution_record.create_timestamp
+                ):
+                    latest_failing_check_timestamp = (
+                        check_record.last_completed_check_execution_record.create_timestamp
+                    )
             else:
                 # asset check passed
                 passing_checks.add(check_key)
+                if check_record.last_completed_check_execution_record is not None and (
+                    latest_passing_check_timestamp is None
+                    or latest_passing_check_timestamp
+                    < check_record.last_completed_check_execution_record.create_timestamp
+                ):
+                    latest_passing_check_timestamp = (
+                        check_record.last_completed_check_execution_record.create_timestamp
+                    )
 
         return AssetCheckHealthState(
             passing_checks=passing_checks,
             failing_checks=failing_checks,
             warning_checks=warning_checks,
             all_checks=check_keys,
+            latest_passing_check_timestamp=latest_passing_check_timestamp,
+            latest_failing_check_timestamp=latest_failing_check_timestamp,
+            latest_warning_check_timestamp=latest_warning_check_timestamp,
         )
 
     @classmethod

{dagster-1.11.13 → dagster-1.11.15}/dagster/_core/definitions/asset_health/asset_freshness_health.py

@@ -24,6 +24,7 @@ class AssetFreshnessHealthState(LoadableBy[AssetKey]):
     """Maintains the latest freshness state for the asset."""
 
     freshness_state: FreshnessState
+    updated_timestamp: Optional[float] = None
 
     @property
     def health_status(self) -> AssetHealthStatus:
@@ -49,9 +50,11 @@ class AssetFreshnessHealthState(LoadableBy[AssetKey]):
             # freshness policy has no evaluations yet
             return cls(
                 freshness_state=FreshnessState.UNKNOWN,
+                updated_timestamp=None,
             )
         return cls(
             freshness_state=freshness_state_record.freshness_state,
+            updated_timestamp=freshness_state_record.updated_at.timestamp(),
         )
 
     @classmethod

{dagster-1.11.13 → dagster-1.11.15}/dagster/_core/definitions/asset_health/asset_materialization_health.py

@@ -35,6 +35,7 @@ class MinimalAssetMaterializationHealthState(LoadableBy[AssetKey]):
     num_failed_partitions: int
     num_currently_materialized_partitions: int
     partitions_snap: Optional[PartitionsSnap]
+    latest_failed_to_materialize_timestamp: Optional[float] = None
 
     @property
     def health_status(self) -> AssetHealthStatus:
@@ -62,6 +63,7 @@ class MinimalAssetMaterializationHealthState(LoadableBy[AssetKey]):
             num_failed_partitions=asset_materialization_health_state.failed_subset.size,
             num_currently_materialized_partitions=asset_materialization_health_state.currently_materialized_subset.size,
             partitions_snap=asset_materialization_health_state.partitions_snap,
+            latest_failed_to_materialize_timestamp=asset_materialization_health_state.latest_failed_to_materialize_timestamp,
         )
 
     @classmethod
@@ -101,6 +103,7 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
     partitions_snap: Optional[PartitionsSnap]
     latest_terminal_run_id: Optional[str]
     latest_materialization_timestamp: Optional[float] = None
+    latest_failed_to_materialize_timestamp: Optional[float] = None
 
     @property
     def partitions_def(self) -> Optional[PartitionsDefinition]:
@@ -152,6 +155,7 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
 
             last_run_id = None
             latest_materialization_timestamp = None
+            latest_failed_to_materialize_timestamp = None
             if asset_record is not None:
                 entry = asset_record.asset_entry
                 latest_record = max(
@@ -167,6 +171,11 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
                     if entry.last_materialization_record
                     else None
                 )
+                latest_failed_to_materialize_timestamp = (
+                    entry.last_failed_to_materialize_record.timestamp
+                    if entry.last_failed_to_materialize_record
+                    else None
+                )
 
             return cls(
                 materialized_subset=SerializableEntitySubset(
@@ -178,6 +187,7 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
                 partitions_snap=PartitionsSnap.from_def(partitions_def),
                 latest_terminal_run_id=last_run_id,
                 latest_materialization_timestamp=latest_materialization_timestamp,
+                latest_failed_to_materialize_timestamp=latest_failed_to_materialize_timestamp,
             )
 
         if asset_record is None:
@@ -187,6 +197,7 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
                 partitions_snap=None,
                 latest_terminal_run_id=None,
                 latest_materialization_timestamp=None,
+                latest_failed_to_materialize_timestamp=None,
             )
 
         asset_entry = asset_record.asset_entry
@@ -195,6 +206,11 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
             if asset_entry.last_materialization_record
             else None
         )
+        latest_failed_to_materialize_timestamp = (
+            asset_entry.last_failed_to_materialize_record.timestamp
+            if asset_entry.last_failed_to_materialize_record
+            else None
+        )
         if asset_entry.last_run_id is None:
             return AssetMaterializationHealthState(
                 materialized_subset=SerializableEntitySubset(key=asset_key, value=False),
@@ -202,6 +218,7 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
                 partitions_snap=None,
                 latest_terminal_run_id=None,
                 latest_materialization_timestamp=latest_materialization_timestamp,
+                latest_failed_to_materialize_timestamp=latest_failed_to_materialize_timestamp,
             )
 
         has_ever_materialized = asset_entry.last_materialization is not None
@@ -218,6 +235,7 @@ class AssetMaterializationHealthState(LoadableBy[AssetKey]):
             partitions_snap=None,
             latest_terminal_run_id=latest_terminal_run_id,
             latest_materialization_timestamp=latest_materialization_timestamp,
+            latest_failed_to_materialize_timestamp=latest_failed_to_materialize_timestamp,
         )
 
     @classmethod

{dagster-1.11.13 → dagster-1.11.15}/dagster/_core/definitions/asset_key.py

@@ -195,7 +195,7 @@ def check_opt_coercible_to_asset_key_prefix_param(
 def key_prefix_from_coercible(key_prefix: CoercibleToAssetKeyPrefix) -> Sequence[str]:
     if isinstance(key_prefix, str):
         return [key_prefix]
-    elif isinstance(key_prefix, list):
+    elif isinstance(key_prefix, Sequence):
         return key_prefix
     else:
         check.failed(f"Unexpected type for key_prefix: {type(key_prefix)}")

{dagster-1.11.13 → dagster-1.11.15}/dagster/_core/definitions/asset_selection.py

@@ -22,7 +22,7 @@ from dagster._core.definitions.asset_key import (
 )
 from dagster._core.definitions.assets.definition.assets_definition import AssetsDefinition
 from dagster._core.definitions.assets.graph.asset_graph import AssetGraph
-from dagster._core.definitions.assets.graph.base_asset_graph import BaseAssetGraph, BaseAssetNode
+from dagster._core.definitions.assets.graph.base_asset_graph import BaseAssetGraph
 from dagster._core.definitions.resolved_asset_deps import resolve_similar_asset_names
 from dagster._core.definitions.source_asset import SourceAsset
 from dagster._core.errors import DagsterInvalidSubsetError
@@ -894,7 +894,7 @@ class MaterializableAssetSelection(ChainedAssetSelection):
         return {
             asset_key
             for asset_key in self.child.resolve_inner(asset_graph, allow_missing=allow_missing)
-            if cast("BaseAssetNode", asset_graph.get(asset_key)).is_materializable
+            if asset_key in asset_graph.materializable_asset_keys
         }
 
 
@@ -972,28 +972,23 @@ class KindAssetSelection(AssetSelection):
         asset_graph: BaseAssetGraph,
         allow_missing: bool,
     ) -> AbstractSet[AssetKey]:
-        base_set = (
-            asset_graph.get_all_asset_keys()
-            if self.include_sources
-            else asset_graph.materializable_asset_keys
-        )
+        base_nodes = {
+            node.key: node
+            for node in asset_graph.asset_nodes
+            if self.include_sources or node.is_materializable
+        }
 
         if self.kind_str is None:
             return {
-                key
-                for key in base_set
-                if (
-                    not any(
-                        tag_key.startswith(KIND_PREFIX)
-                        for tag_key in (asset_graph.get(key).tags or {})
-                    )
-                )
+                node.key
+                for key, node in base_nodes.items()
+                if (not any(tag_key.startswith(KIND_PREFIX) for tag_key in (node.tags or {})))
             }
         else:
             return {
                 key
-                for key in base_set
-                if asset_graph.get(key).tags.get(f"{KIND_PREFIX}{self.kind_str}") is not None
+                for key, node in base_nodes.items()
+                if node.tags.get(f"{KIND_PREFIX}{self.kind_str}") is not None
             }
 
     def to_selection_str(self) -> str:
@@ -1012,13 +1007,13 @@ class TagAssetSelection(AssetSelection):
     def resolve_inner(
         self, asset_graph: BaseAssetGraph, allow_missing: bool
     ) -> AbstractSet[AssetKey]:
-        base_set = (
-            asset_graph.get_all_asset_keys()
-            if self.include_sources
-            else asset_graph.materializable_asset_keys
-        )
+        base_nodes = {
+            node.key: node
+            for node in asset_graph.asset_nodes
+            if self.include_sources or node.is_materializable
+        }
 
-        return {key for key in base_set if asset_graph.get(key).tags.get(self.key) == self.value}
+        return {key for key, node in base_nodes.items() if node.tags.get(self.key) == self.value}
 
     def to_selection_str(self) -> str:
         if self.value:
@@ -1035,11 +1030,7 @@ class OwnerAssetSelection(AssetSelection):
     def resolve_inner(
         self, asset_graph: BaseAssetGraph, allow_missing: bool
     ) -> AbstractSet[AssetKey]:
-        return {
-            key
-            for key in asset_graph.get_all_asset_keys()
-            if self.selected_owner in asset_graph.get(key).owners
-        }
+        return {node.key for node in asset_graph.asset_nodes if self.selected_owner in node.owners}
 
     def to_selection_str(self) -> str:
         if self.selected_owner is None:
@@ -1076,12 +1067,8 @@ class CodeLocationAssetSelection(AssetSelection):
             asset_keys = set()
             location = location_name.split("@")[1]
             name = location_name.split("@")[0]
-            for asset_key in asset_graph.remote_asset_nodes_by_key:
-                repo_handle = (
-                    asset_graph.get(asset_key)
-                    .resolve_to_singular_repo_scoped_node()
-                    .repository_handle
-                )
+            for asset_key, node in asset_graph.remote_asset_nodes_by_key.items():
+                repo_handle = node.resolve_to_singular_repo_scoped_node().repository_handle
                 if repo_handle.location_name == location and repo_handle.repository_name == name:
                     asset_keys.add(asset_key)
             return asset_keys
@@ -1089,13 +1076,11 @@ class CodeLocationAssetSelection(AssetSelection):
         # Otherwise, filter only by location name
         return {
             key
-            for key in asset_graph.remote_asset_nodes_by_key
+            for key, node in asset_graph.remote_asset_nodes_by_key.items()
             if (
-                asset_graph.get(key)
-                .resolve_to_singular_repo_scoped_node()
-                .repository_handle.location_name
+                node.resolve_to_singular_repo_scoped_node().repository_handle.location_name
+                == self.selected_code_location
             )
-            == self.selected_code_location
         }
 
     def to_selection_str(self) -> str: