dagster-dbt 0.23.3__py3-none-any.whl → 0.28.4__py3-none-any.whl

dagster_dbt/cloud/asset_defs.py

@@ -1,58 +1,45 @@
 import json
 import shlex
-from argparse import Namespace
+from argparse import ArgumentParser, Namespace
+from collections.abc import Callable, Mapping, Sequence
 from contextlib import suppress
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    FrozenSet,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Union,
-    cast,
-)
+from typing import Any, Optional, Union, cast
 
 import dagster._check as check
 from dagster import (
     AssetExecutionContext,
     AssetKey,
-    AssetOut,
     AssetsDefinition,
     AutoMaterializePolicy,
-    FreshnessPolicy,
+    LegacyFreshnessPolicy,
     MetadataValue,
     PartitionsDefinition,
     ResourceDefinition,
     multi_asset,
     with_resources,
 )
-from dagster._annotations import experimental, experimental_param
-from dagster._core.definitions.cacheable_assets import (
+from dagster._annotations import beta, beta_param
+from dagster._core.definitions.assets.definition.asset_spec import AssetSpec
+from dagster._core.definitions.assets.definition.cacheable_assets_definition import (
     AssetsDefinitionCacheableData,
     CacheableAssetsDefinition,
 )
 from dagster._core.definitions.metadata import RawMetadataMapping
 from dagster._core.execution.context.init import build_init_resource_context
 
+from dagster_dbt.asset_specs import build_dbt_asset_specs
 from dagster_dbt.asset_utils import (
+    DAGSTER_DBT_UNIQUE_ID_METADATA_KEY,
     default_asset_key_fn,
     default_auto_materialize_policy_fn,
     default_description_fn,
-    default_freshness_policy_fn,
     default_group_from_dbt_resource_props,
-    get_asset_deps,
-    get_deps,
+    get_node,
 )
+from dagster_dbt.cloud.resources import DbtCloudClient, DbtCloudClientResource, DbtCloudRunStatus
+from dagster_dbt.cloud.utils import result_to_events
 from dagster_dbt.dagster_dbt_translator import DagsterDbtTranslator
-
-from ..errors import DagsterDbtCloudJobInvariantViolationError
-from ..utils import ASSET_RESOURCE_TYPES, result_to_events
-from .resources import DbtCloudClient, DbtCloudClientResource, DbtCloudRunStatus
+from dagster_dbt.errors import DagsterDbtCloudJobInvariantViolationError
 
 DAGSTER_DBT_COMPILE_RUN_ID_ENV_VAR = "DBT_DAGSTER_COMPILE_RUN_ID"
 
@@ -64,7 +51,9 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
         job_id: int,
         node_info_to_asset_key: Callable[[Mapping[str, Any]], AssetKey],
         node_info_to_group_fn: Callable[[Mapping[str, Any]], Optional[str]],
-        node_info_to_freshness_policy_fn: Callable[[Mapping[str, Any]], Optional[FreshnessPolicy]],
+        node_info_to_freshness_policy_fn: Callable[
+            [Mapping[str, Any]], Optional[LegacyFreshnessPolicy]
+        ],
         node_info_to_auto_materialize_policy_fn: Callable[
             [Mapping[str, Any]], Optional[AutoMaterializePolicy]
         ],
@@ -85,7 +74,7 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
         self._job_id = job_id
         self._project_id: int
         self._has_generate_docs: bool
-        self._job_commands: List[str]
+        self._job_commands: list[str]
         self._job_materialization_command_step: int
         self._node_info_to_asset_key = node_info_to_asset_key
         self._node_info_to_group_fn = node_info_to_group_fn
@@ -97,8 +86,8 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
         super().__init__(unique_id=f"dbt-cloud-{job_id}")
 
     def compute_cacheable_data(self) -> Sequence[AssetsDefinitionCacheableData]:
-        dbt_nodes, dbt_dependencies = self._get_dbt_nodes_and_dependencies()
-        return [self._build_dbt_cloud_assets_cacheable_data(dbt_nodes, dbt_dependencies)]
+        manifest_json, executed_unique_ids = self._get_manifest_json_and_executed_unique_ids()
+        return [self._build_dbt_cloud_assets_cacheable_data(manifest_json, executed_unique_ids)]
 
     def build_definitions(
         self, data: Sequence[AssetsDefinitionCacheableData]
@@ -113,10 +102,7 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
 
     @staticmethod
     def parse_dbt_command(dbt_command: str) -> Namespace:
-        from dbt.cli.flags import (
-            Flags,
-            args_to_context,
-        )
+        from dbt.cli.flags import Flags, args_to_context
 
         args = shlex.split(dbt_command)[1:]
 
@@ -124,7 +110,7 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
         return Namespace(**vars(Flags(args_to_context(args + ["--profiles-dir", "."]))))
 
     @staticmethod
-    def get_job_materialization_command_step(execute_steps: List[str]) -> int:
+    def get_job_materialization_command_step(execute_steps: list[str]) -> int:
         materialization_command_filter = [
             DbtCloudCacheableAssetsDefinition.parse_dbt_command(command).which in ["run", "build"]
             for command in execute_steps
@@ -139,8 +125,8 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
         return materialization_command_filter.index(True)
 
     @staticmethod
-    def get_compile_filters(parsed_args: Namespace) -> List[str]:
-        dbt_compile_options: List[str] = []
+    def get_compile_filters(parsed_args: Namespace) -> list[str]:
+        dbt_compile_options: list[str] = []
 
         selected_models = parsed_args.select or []
         if selected_models:
@@ -158,7 +144,7 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
 
         return dbt_compile_options
 
-    def _get_cached_compile_dbt_cloud_job_run(self, compile_run_id: int) -> Tuple[int, int]:
+    def _get_cached_compile_dbt_cloud_job_run(self, compile_run_id: int) -> tuple[int, int]:
         # If the compile run is ongoing, allow it a grace period of 10 minutes to finish.
         with suppress(Exception):
             self._dbt_cloud.poll_run(run_id=compile_run_id, poll_timeout=600)
@@ -186,7 +172,7 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
 
         return compile_run_id, compile_job_materialization_command_step
 
-    def _compile_dbt_cloud_job(self, dbt_cloud_job: Mapping[str, Any]) -> Tuple[int, int]:
+    def _compile_dbt_cloud_job(self, dbt_cloud_job: Mapping[str, Any]) -> tuple[int, int]:
         # Retrieve the filters options from the dbt Cloud job's materialization command.
         #
         # There are three filters: `--select`, `--exclude`, and `--selector`.
@@ -246,9 +232,9 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
 
         return compile_run_dbt_output.run_id, compile_job_materialization_command_step
 
-    def _get_dbt_nodes_and_dependencies(
+    def _get_manifest_json_and_executed_unique_ids(
         self,
-    ) -> Tuple[Mapping[str, Any], Mapping[str, FrozenSet[str]]]:
+    ) -> tuple[Mapping[str, Any], frozenset[str]]:
         """For a given dbt Cloud job, fetch the latest run's dependency structure of executed nodes."""
         # Fetch information about the job.
         job = self._dbt_cloud.get_job(job_id=self._job_id)
@@ -300,12 +286,7 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
         )
 
         # Filter the manifest to only include the nodes that were executed.
-        dbt_nodes: Dict[str, Any] = {
-            **manifest_json.get("nodes", {}),
-            **manifest_json.get("sources", {}),
-            **manifest_json.get("metrics", {}),
-        }
-        executed_node_ids: Set[str] = set(
+        executed_node_ids: set[str] = set(
             result["unique_id"] for result in run_results_json["results"]
         )
 
@@ -319,17 +300,11 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
                 f"options applied. Received commands: {self._job_commands}."
             )
 
-        # Generate the dependency structure for the executed nodes.
-        dbt_dependencies = get_deps(
-            dbt_nodes=dbt_nodes,
-            selected_unique_ids=executed_node_ids,
-            asset_resource_types=ASSET_RESOURCE_TYPES,
-        )
-
-        return dbt_nodes, dbt_dependencies
+        # sort to stabilize job snapshots
+        return manifest_json, frozenset(sorted(executed_node_ids))
 
     def _build_dbt_cloud_assets_cacheable_data(
-        self, dbt_nodes: Mapping[str, Any], dbt_dependencies: Mapping[str, FrozenSet[str]]
+        self, manifest_json: Mapping[str, Any], executed_unique_ids: frozenset[str]
     ) -> AssetsDefinitionCacheableData:
         """Given all of the nodes and dependencies for a dbt Cloud job, build the cacheable
         representation that generate the asset definition for the job.
@@ -337,88 +312,74 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
 
         class CustomDagsterDbtTranslator(DagsterDbtTranslator):
             @classmethod
-            def get_asset_key(cls, dbt_resource_props):
+            def get_asset_key(cls, dbt_resource_props):  # pyright: ignore[reportIncompatibleMethodOverride]
                 return self._node_info_to_asset_key(dbt_resource_props)
 
             @classmethod
-            def get_description(cls, dbt_resource_props):
+            def get_description(cls, dbt_resource_props):  # pyright: ignore[reportIncompatibleMethodOverride]
                 # We shouldn't display the raw sql. Instead, inspect if dbt docs were generated,
                 # and attach metadata to link to the docs.
                 return default_description_fn(dbt_resource_props, display_raw_sql=False)
 
             @classmethod
-            def get_group_name(cls, dbt_resource_props):
+            def get_group_name(cls, dbt_resource_props):  # pyright: ignore[reportIncompatibleMethodOverride]
                 return self._node_info_to_group_fn(dbt_resource_props)
 
             @classmethod
-            def get_freshness_policy(cls, dbt_resource_props):
-                return self._node_info_to_freshness_policy_fn(dbt_resource_props)
-
-            @classmethod
-            def get_auto_materialize_policy(cls, dbt_resource_props):
+            def get_auto_materialize_policy(cls, dbt_resource_props):  # pyright: ignore[reportIncompatibleMethodOverride]
                 return self._node_info_to_auto_materialize_policy_fn(dbt_resource_props)
 
-        (
-            asset_deps,
-            asset_ins,
-            asset_outs,
-            group_names_by_key,
-            freshness_policies_by_key,
-            auto_materialize_policies_by_key,
-            _,
-            fqns_by_output_name,
-            metadata_by_output_name,
-        ) = get_asset_deps(
-            dbt_nodes=dbt_nodes,
-            deps=dbt_dependencies,
-            # TODO: In the future, allow the IO manager to be specified.
-            io_manager_key=None,
+        # generate specs for each executed node
+        specs = build_dbt_asset_specs(
+            manifest=manifest_json,
             dagster_dbt_translator=CustomDagsterDbtTranslator(),
-            manifest=None,
+            select=" ".join(
+                f"fqn:{'.'.join(get_node(manifest_json, unique_id)['fqn'])}"
+                for unique_id in executed_unique_ids
+            ),
         )
 
         return AssetsDefinitionCacheableData(
             # TODO: In the future, we should allow additional upstream assets to be specified.
-            keys_by_input_name={
-                input_name: asset_key for asset_key, (input_name, _) in asset_ins.items()
-            },
-            keys_by_output_name={
-                output_name: asset_key for asset_key, (output_name, _) in asset_outs.items()
-            },
+            keys_by_output_name={spec.key.to_python_identifier(): spec.key for spec in specs},
             internal_asset_deps={
-                asset_outs[asset_key][0]: asset_deps for asset_key, asset_deps in asset_deps.items()
+                spec.key.to_python_identifier(): {dep.asset_key for dep in spec.deps}
+                for spec in specs
             },
-            # We don't rely on a static group name. Instead, we map over the dbt metadata to
-            # determine the group name for each asset.
-            group_name=None,
             metadata_by_output_name={
-                output_name: self._build_dbt_cloud_assets_metadata(dbt_metadata)
-                for output_name, dbt_metadata in metadata_by_output_name.items()
+                spec.key.to_python_identifier(): self._build_dbt_cloud_assets_metadata(
+                    get_node(
+                        manifest_json,
+                        spec.metadata[DAGSTER_DBT_UNIQUE_ID_METADATA_KEY],
+                    )
+                )
+                for spec in specs
             },
-            # TODO: In the future, we should allow the key prefix to be specified.
-            key_prefix=None,
-            can_subset=True,
             extra_metadata={
                 "job_id": self._job_id,
                 "job_commands": self._job_commands,
                 "job_materialization_command_step": self._job_materialization_command_step,
                 "group_names_by_output_name": {
-                    asset_outs[asset_key][0]: group_name
-                    for asset_key, group_name in group_names_by_key.items()
+                    spec.key.to_python_identifier(): spec.group_name for spec in specs
+                },
+                "fqns_by_output_name": {
+                    spec.key.to_python_identifier(): get_node(
+                        manifest_json,
+                        spec.metadata[DAGSTER_DBT_UNIQUE_ID_METADATA_KEY],
+                    )["fqn"]
+                    for spec in specs
                 },
-                "fqns_by_output_name": fqns_by_output_name,
-            },
-            freshness_policies_by_output_name={
-                asset_outs[asset_key][0]: freshness_policy
-                for asset_key, freshness_policy in freshness_policies_by_key.items()
             },
             auto_materialize_policies_by_output_name={
-                asset_outs[asset_key][0]: auto_materialize_policy
-                for asset_key, auto_materialize_policy in auto_materialize_policies_by_key.items()
+                spec.key.to_python_identifier(): spec.auto_materialize_policy
+                for spec in specs
+                if spec.auto_materialize_policy
             },
         )
 
-    def _build_dbt_cloud_assets_metadata(self, dbt_metadata: Dict[str, Any]) -> RawMetadataMapping:
+    def _build_dbt_cloud_assets_metadata(
+        self, resource_props: Mapping[str, Any]
+    ) -> RawMetadataMapping:
         metadata = {
             "dbt Cloud Job": MetadataValue.url(
                 self._dbt_cloud.build_url_for_job(
@@ -432,66 +393,57 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
             metadata["dbt Cloud Documentation"] = MetadataValue.url(
                 self._dbt_cloud.build_url_for_cloud_docs(
                     job_id=self._job_id,
-                    resource_type=dbt_metadata["resource_type"],
-                    unique_id=dbt_metadata["unique_id"],
+                    resource_type=resource_props["resource_type"],
+                    unique_id=resource_props["unique_id"],
                 )
             )
 
         return metadata
 
+    def _rebuild_specs(self, cacheable_data: AssetsDefinitionCacheableData) -> Sequence[AssetSpec]:
+        specs = []
+        for id, key in (cacheable_data.keys_by_output_name or {}).items():
+            specs.append(
+                AssetSpec(
+                    key=key,
+                    group_name=(cacheable_data.extra_metadata or {})[
+                        "group_names_by_output_name"
+                    ].get(id),
+                    deps=(cacheable_data.internal_asset_deps or {}).get(id),
+                    metadata=(cacheable_data.metadata_by_output_name or {}).get(id),
+                    legacy_freshness_policy=(
+                        cacheable_data.legacy_freshness_policies_by_output_name or {}
+                    ).get(id),
+                    auto_materialize_policy=(
+                        cacheable_data.auto_materialize_policies_by_output_name or {}
+                    ).get(id),
+                    skippable=False,
+                )
+            )
+        return specs
+
     def _build_dbt_cloud_assets_from_cacheable_data(
         self, assets_definition_cacheable_data: AssetsDefinitionCacheableData
     ) -> AssetsDefinition:
-        metadata = cast(Mapping[str, Any], assets_definition_cacheable_data.extra_metadata)
-        job_id = cast(int, metadata["job_id"])
-        job_commands = cast(List[str], list(metadata["job_commands"]))
-        job_materialization_command_step = cast(int, metadata["job_materialization_command_step"])
-        group_names_by_output_name = cast(Mapping[str, str], metadata["group_names_by_output_name"])
-        fqns_by_output_name = cast(Mapping[str, List[str]], metadata["fqns_by_output_name"])
+        metadata = cast("Mapping[str, Any]", assets_definition_cacheable_data.extra_metadata)
+        job_id = cast("int", metadata["job_id"])
+        job_commands = cast("list[str]", list(metadata["job_commands"]))
+        job_materialization_command_step = cast("int", metadata["job_materialization_command_step"])
+        fqns_by_output_name = cast("Mapping[str, list[str]]", metadata["fqns_by_output_name"])
 
         @multi_asset(
             name=f"dbt_cloud_job_{job_id}",
-            deps=list((assets_definition_cacheable_data.keys_by_input_name or {}).values()),
-            outs={
-                output_name: AssetOut(
-                    key=asset_key,
-                    group_name=group_names_by_output_name.get(output_name),
-                    freshness_policy=(
-                        assets_definition_cacheable_data.freshness_policies_by_output_name or {}
-                    ).get(
-                        output_name,
-                    ),
-                    auto_materialize_policy=(
-                        assets_definition_cacheable_data.auto_materialize_policies_by_output_name
-                        or {}
-                    ).get(
-                        output_name,
-                    ),
-                    metadata=(assets_definition_cacheable_data.metadata_by_output_name or {}).get(
-                        output_name
-                    ),
-                    is_required=False,
-                )
-                for output_name, asset_key in (
-                    assets_definition_cacheable_data.keys_by_output_name or {}
-                ).items()
-            },
-            internal_asset_deps={
-                output_name: set(asset_deps)
-                for output_name, asset_deps in (
-                    assets_definition_cacheable_data.internal_asset_deps or {}
-                ).items()
-            },
+            specs=self._rebuild_specs(assets_definition_cacheable_data),
             partitions_def=self._partitions_def,
-            can_subset=assets_definition_cacheable_data.can_subset,
+            can_subset=True,
             required_resource_keys={"dbt_cloud"},
             compute_kind="dbt",
         )
         def _assets(context: AssetExecutionContext):
-            dbt_cloud = cast(DbtCloudClient, context.resources.dbt_cloud)
+            dbt_cloud = cast("DbtCloudClient", context.resources.dbt_cloud)
 
             # Add the partition variable as a variable to the dbt Cloud job command.
-            dbt_options: List[str] = []
+            dbt_options: list[str] = []
             if context.has_partition_key and self._partition_key_to_vars_fn:
                 partition_var = self._partition_key_to_vars_fn(context.partition_key)
 
@@ -502,32 +454,32 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
 
             # Map the selected outputs to dbt models that should be materialized.
             #
-            # HACK: This selection filter works even if an existing `--select` is specified in the
-            # dbt Cloud job. We take advantage of the fact that the last `--select` will be used.
+            # From version 1.5.0 dbt allows multiple select args to be used in command,
+            # so we cannot just add our arg as last one to be used and need to remove
+            # both command-native --select args and --selector arg to run dagster-generated
+            # subset of models
             #
-            # This is not ideal, as the triggered run for the dbt Cloud job will still have both
-            # `--select` options when displayed in the UI, but parsing the command line argument
-            # to remove the initial select using argparse.
+            # See https://docs.getdbt.com/reference/node-selection/syntax for details.
             if context.is_subset:
                 selected_models = [
                     ".".join(fqns_by_output_name[output_name])
                     for output_name in context.op_execution_context.selected_output_names
+                    # outputs corresponding to asset checks from dbt tests won't be in this dict
+                    if output_name in fqns_by_output_name
                 ]
 
                 dbt_options.append(f"--select {' '.join(sorted(selected_models))}")
 
-                # If the `--selector` option is used, we need to remove it from the command, since
-                # it disables other selection options from being functional.
-                #
-                # See https://docs.getdbt.com/reference/node-selection/syntax for details.
-                split_materialization_command = shlex.split(materialization_command)
-                if "--selector" in split_materialization_command:
-                    idx = split_materialization_command.index("--selector")
+                parser = ArgumentParser(description="Parse selection args from dbt command")
+                # Select arg should have nargs="+", but we probably want dbt itself to deal with it
+                parser.add_argument("-s", "--select", nargs="*", action="append")
+                parser.add_argument("--selector", nargs="*")
 
-                    materialization_command = " ".join(
-                        split_materialization_command[:idx]
-                        + split_materialization_command[idx + 2 :]
-                    )
+                split_materialization_command = shlex.split(materialization_command)
+                _, non_selection_command_parts = parser.parse_known_args(
+                    split_materialization_command
+                )
+                materialization_command = " ".join(non_selection_command_parts)
 
             job_commands[job_materialization_command_step] = (
                 f"{materialization_command} {' '.join(dbt_options)}".strip()
@@ -574,9 +526,9 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
         return _assets
 
 
-@experimental
-@experimental_param(param="partitions_def")
-@experimental_param(param="partition_key_to_vars_fn")
+@beta
+@beta_param(param="partitions_def")
+@beta_param(param="partition_key_to_vars_fn")
 def load_assets_from_dbt_cloud_job(
     dbt_cloud: Union[DbtCloudClientResource, ResourceDefinition],
     job_id: int,
@@ -584,9 +536,6 @@ def load_assets_from_dbt_cloud_job(
     node_info_to_group_fn: Callable[
         [Mapping[str, Any]], Optional[str]
     ] = default_group_from_dbt_resource_props,
-    node_info_to_freshness_policy_fn: Callable[
-        [Mapping[str, Any]], Optional[FreshnessPolicy]
-    ] = default_freshness_policy_fn,
     node_info_to_auto_materialize_policy_fn: Callable[
         [Mapping[str, Any]], Optional[AutoMaterializePolicy]
     ] = default_auto_materialize_policy_fn,
@@ -608,13 +557,6 @@ def load_assets_from_dbt_cloud_job(
             dbt source -> AssetKey([source_name, table_name])
         node_info_to_group_fn (Dict[str, Any] -> Optional[str]): A function that takes a
             dictionary of dbt node info and returns the group that this node should be assigned to.
-        node_info_to_freshness_policy_fn (Dict[str, Any] -> Optional[FreshnessPolicy]): A function
-            that takes a dictionary of dbt node info and optionally returns a FreshnessPolicy that
-            should be applied to this node. By default, freshness policies will be created from
-            config applied to dbt models, i.e.:
-            `dagster_freshness_policy={"maximum_lag_minutes": 60, "cron_schedule": "0 9 * * *"}`
-            will result in that model being assigned
-            `FreshnessPolicy(maximum_lag_minutes=60, cron_schedule="0 9 * * *")`
         node_info_to_auto_materialize_policy_fn (Dict[str, Any] -> Optional[AutoMaterializePolicy]):
             A function that takes a dictionary of dbt node info and optionally returns a AutoMaterializePolicy
             that should be applied to this node. By default, AutoMaterializePolicies will be created from
@@ -669,7 +611,7 @@ def load_assets_from_dbt_cloud_job(
         job_id=job_id,
         node_info_to_asset_key=node_info_to_asset_key,
         node_info_to_group_fn=node_info_to_group_fn,
-        node_info_to_freshness_policy_fn=node_info_to_freshness_policy_fn,
+        node_info_to_freshness_policy_fn=lambda _: None,
         node_info_to_auto_materialize_policy_fn=node_info_to_auto_materialize_policy_fn,
         partitions_def=partitions_def,
         partition_key_to_vars_fn=partition_key_to_vars_fn,

dagster_dbt/cloud/cli.py

@@ -1,7 +1,6 @@
-from typing import List
+from typing import Annotated
 
 import typer
-from typing_extensions import Annotated
 
 from dagster_dbt.cloud.asset_defs import (
     DAGSTER_DBT_COMPILE_RUN_ID_ENV_VAR,
@@ -77,7 +76,7 @@ def cache_compile_references(
             continue
 
         # Retrieve the filters for the compile override step
-        job_commands: List[str] = dbt_cloud_job["execute_steps"]
+        job_commands: list[str] = dbt_cloud_job["execute_steps"]
         job_materialization_command_step = (
             DbtCloudCacheableAssetsDefinition.get_job_materialization_command_step(
                 execute_steps=job_commands
@@ -87,7 +86,7 @@ def cache_compile_references(
         parsed_args = DbtCloudCacheableAssetsDefinition.parse_dbt_command(
             dbt_materialization_command
         )
-        dbt_compile_options: List[str] = DbtCloudCacheableAssetsDefinition.get_compile_filters(
+        dbt_compile_options: list[str] = DbtCloudCacheableAssetsDefinition.get_compile_filters(
             parsed_args=parsed_args
         )
         dbt_compile_command = f"dbt compile {' '.join(dbt_compile_options)}"

dagster_dbt/cloud/ops.py

@@ -1,11 +1,13 @@
-from typing import List, Optional
+from typing import Optional
 
 from dagster import Config, In, Nothing, Out, Output, op
+from dagster._annotations import beta
+from dagster._core.storage.tags import COMPUTE_KIND_TAG
 from pydantic import Field
 
-from ..utils import generate_materializations
-from .resources import DEFAULT_POLL_INTERVAL
-from .types import DbtCloudOutput
+from dagster_dbt.cloud.resources import DEFAULT_POLL_INTERVAL
+from dagster_dbt.cloud.types import DbtCloudOutput
+from dagster_dbt.cloud.utils import generate_materializations
 
 
 class DbtCloudRunOpConfig(Config):
@@ -36,7 +38,7 @@ class DbtCloudRunOpConfig(Config):
         ),
     )
 
-    asset_key_prefix: List[str] = Field(
+    asset_key_prefix: list[str] = Field(
         default=["dbt"],
         description=(
             "If provided and yield_materializations is True, these components will be used to "
@@ -49,8 +51,9 @@ class DbtCloudRunOpConfig(Config):
     required_resource_keys={"dbt_cloud"},
     ins={"start_after": In(Nothing)},
     out=Out(DbtCloudOutput, description="Parsed output from running the dbt Cloud job."),
-    tags={"kind": "dbt_cloud"},
+    tags={COMPUTE_KIND_TAG: "dbt_cloud"},
 )
+@beta
 def dbt_cloud_run_op(context, config: DbtCloudRunOpConfig):
     """Initiates a run for a dbt Cloud job, then polls until the run completes. If the job
     fails or is otherwised stopped before succeeding, a `dagster.Failure` exception will be raised,

dagster_dbt/cloud/resources.py

@@ -2,8 +2,9 @@ import datetime
 import json
 import logging
 import time
+from collections.abc import Mapping, Sequence
 from enum import Enum
-from typing import Any, Mapping, Optional, Sequence, cast
+from typing import Any, Optional, cast
 from urllib.parse import urlencode, urljoin
 
 import requests
@@ -17,12 +18,13 @@ from dagster import (
     get_dagster_logger,
     resource,
 )
+from dagster._annotations import beta
 from dagster._core.definitions.resource_definition import dagster_maintained_resource
 from dagster._utils.merger import deep_merge_dicts
 from pydantic import Field
 from requests.exceptions import RequestException
 
-from .types import DbtCloudOutput
+from dagster_dbt.cloud.types import DbtCloudOutput
 
 DBT_DEFAULT_HOST = "https://cloud.getdbt.com/"
 DBT_API_V2_PATH = "api/v2/accounts/"
@@ -352,7 +354,7 @@ class DbtCloudClient:
         """
         query_params = f"?step={step}" if step else ""
         return cast(
-            list,
+            "list",
             self.make_request(
                 "GET",
                 f"{self._account_id}/runs/{run_id}/artifacts/{query_params}",
@@ -586,10 +588,12 @@ class DbtCloudClient:
         )
 
 
+@beta
 class DbtCloudResource(DbtCloudClient):
     pass
 
 
+@beta
 class DbtCloudClientResource(ConfigurableResource, IAttachDifferentObjectToOpContext):
     """This resource helps interact with dbt Cloud connectors."""
 
@@ -655,6 +659,7 @@ class DbtCloudClientResource(ConfigurableResource, IAttachDifferentObjectToOpCon
         return self.get_dbt_client()
 
 
+@beta
 @dagster_maintained_resource
 @resource(
     config_schema=DbtCloudClientResource.to_config_schema(),
@@ -669,7 +674,7 @@ def dbt_cloud_resource(context) -> DbtCloudResource:
     response JSON schemae, see the `dbt Cloud API Docs <https://docs.getdbt.com/dbt-cloud/api-v2>`_.
 
     To configure this resource, we recommend using the `configured
-    <https://docs.dagster.io/concepts/configuration/configured>`_ method.
+    <https://legacy-docs.dagster.io/concepts/configuration/configured>`_ method.
 
     **Examples:**