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

dagster_dbt/cloud_v2/resources.py

@@ -0,0 +1,462 @@
+import logging
+from collections.abc import Sequence
+from functools import cached_property
+from typing import NamedTuple, Optional, Union
+
+from dagster import (
+    AssetCheckSpec,
+    AssetExecutionContext,
+    AssetSpec,
+    ConfigurableResource,
+    Definitions,
+    _check as check,
+    get_dagster_logger,
+    multi_asset_check,
+)
+from dagster._annotations import public
+from dagster._config.pythonic_config.resource import ResourceDependency
+from dagster._core.definitions.definitions_load_context import StateBackedDefinitionsLoader
+from dagster._record import record
+from dagster._utils.cached_method import cached_method
+from pydantic import Field
+
+from dagster_dbt.asset_utils import (
+    DBT_DEFAULT_EXCLUDE,
+    DBT_DEFAULT_SELECT,
+    DBT_DEFAULT_SELECTOR,
+    build_dbt_specs,
+    get_updated_cli_invocation_params_for_context,
+)
+from dagster_dbt.cloud_v2.cli_invocation import DbtCloudCliInvocation
+from dagster_dbt.cloud_v2.client import DbtCloudWorkspaceClient
+from dagster_dbt.cloud_v2.run_handler import DbtCloudJobRunHandler
+from dagster_dbt.cloud_v2.types import (
+    DbtCloudAccount,
+    DbtCloudEnvironment,
+    DbtCloudJob,
+    DbtCloudProject,
+    DbtCloudWorkspaceData,
+)
+from dagster_dbt.dagster_dbt_translator import DagsterDbtTranslator, validate_opt_translator
+from dagster_dbt.utils import clean_name
+
+DAGSTER_ADHOC_PREFIX = "DAGSTER_ADHOC_JOB__"
+DBT_CLOUD_RECONSTRUCTION_METADATA_KEY_PREFIX = "__dbt_cloud"
+
+
+def get_dagster_adhoc_job_name(
+    project_id: int,
+    project_name: Optional[str],
+    environment_id: int,
+    environment_name: Optional[str],
+) -> str:
+    name = (
+        f"{DAGSTER_ADHOC_PREFIX}{project_name or project_id}__{environment_name or environment_id}"
+    )
+    # Clean the name and convert it to uppercase
+    return clean_name(name).upper()
+
+
+@public
+class DbtCloudCredentials(NamedTuple):
+    """The DbtCloudCredentials to access your dbt Cloud workspace.
+
+    Args:
+        account_id (int): The ID of your dbt Cloud account.
+        token (str): Your dbt Cloud API token.
+        access_url (str): Your dbt Cloud workspace URL.
+    """
+
+    account_id: int
+    token: str
+    access_url: str
+
+
+@public
+class DbtCloudWorkspace(ConfigurableResource):
+    """This class represents a dbt Cloud workspace and provides utilities
+    to interact with dbt Cloud APIs.
+
+    Args:
+        credentials (DbtCloudCredentials): An instance of DbtCloudCredentials class.
+        project_id (int): The ID of the dbt cloud project to use for this resource.
+        environment_id (int): The ID of the environment to use for the dbt Cloud
+            project used in this resource.
+        adhoc_job_name (Optional[str]): The name of the ad hoc job that will be
+            created by Dagster in your dbt Cloud workspace. This ad hoc job is
+            used to parse your project and materialize your dbt Cloud assets.
+            If not provided, this job name will be generated using your project
+            ID and environment ID.
+        request_max_retries (int): The maximum number of times requests to the
+            dbt Cloud API should be retried before failing.
+        request_retry_delay (float): Time (in seconds) to wait between each
+            request retry.
+        request_timeout: Time (in seconds) after which the requests to dbt Cloud
+            are declared timed out.
+    """
+
+    credentials: ResourceDependency[DbtCloudCredentials]
+    project_id: int = Field(description="The ID of the dbt Cloud project to use for this resource.")
+    environment_id: int = Field(
+        description="The ID of environment to use for the dbt Cloud project used in this resource."
+    )
+    adhoc_job_name: Optional[str] = Field(
+        default=None,
+        description=(
+            "The name of the ad hoc job that will be created by Dagster in your dbt Cloud workspace. "
+            "This ad hoc job is used to parse your project and materialize your dbt Cloud assets. "
+            "If not provided, this job name will be generated using your project ID and environment ID."
+        ),
+    )
+    request_max_retries: int = Field(
+        default=3,
+        description=(
+            "The maximum number of times requests to the dbt Cloud API should be retried "
+            "before failing."
+        ),
+    )
+    request_retry_delay: float = Field(
+        default=0.25,
+        description="Time (in seconds) to wait between each request retry.",
+    )
+    request_timeout: int = Field(
+        default=15,
+        description="Time (in seconds) after which the requests to dbt Cloud are declared timed out.",
+    )
+
+    @property
+    @cached_method
+    def _log(self) -> logging.Logger:
+        return get_dagster_logger()
+
+    @property
+    def unique_id(self) -> str:
+        """Unique ID for this dbt Cloud workspace, which is composed of the project ID and environment ID.
+
+        Returns:
+            str: the unique ID for this dbt Cloud workspace.
+        """
+        return f"{self.project_id}-{self.environment_id}"
+
+    @cached_property
+    def account_name(self) -> Optional[str]:
+        """The name of the account for this dbt Cloud workspace.
+
+        Returns:
+            Optional[str]: the name of the account for this dbt Cloud workspace.
+        """
+        account = DbtCloudAccount.from_account_details(
+            account_details=self.get_client().get_account_details()
+        )
+        if not account.name:
+            self._log.warning(
+                f"Account name was not returned by the dbt Cloud API for account ID `{account.id}`. "
+                f"Make sure to set a name for this account in dbt Cloud."
+            )
+        return account.name
+
+    @cached_property
+    def project_name(self) -> Optional[str]:
+        """The name of the project for this dbt Cloud workspace.
+
+        Returns:
+            str: the name of the project for this dbt Cloud workspace.
+        """
+        project = DbtCloudProject.from_project_details(
+            project_details=self.get_client().get_project_details(project_id=self.project_id)
+        )
+        if not project.name:
+            self._log.warning(
+                f"Project name was not returned by the dbt Cloud API for project ID `{project.id}`. "
+                f"Make sure to set a name for this project in dbt Cloud."
+            )
+        return project.name
+
+    @cached_property
+    def environment_name(self) -> Optional[str]:
+        """The name of the environment for this dbt Cloud workspace.
+
+        Returns:
+            str: the name of the environment for this dbt Cloud workspace.
+        """
+        environment = DbtCloudEnvironment.from_environment_details(
+            environment_details=self.get_client().get_environment_details(
+                environment_id=self.environment_id
+            )
+        )
+        if not environment.name:
+            self._log.warning(
+                f"Environment name was not returned by the dbt Cloud API for environment ID `{environment.id}`. "
+                f"Make sure to set a name for this environment in dbt Cloud."
+            )
+        return environment.name
+
+    @cached_method
+    def get_client(self) -> DbtCloudWorkspaceClient:
+        """Get the dbt Cloud client to interact with this dbt Cloud workspace.
+
+        Returns:
+            DbtCloudWorkspaceClient: The dbt Cloud client to interact with the dbt Cloud workspace.
+        """
+        return DbtCloudWorkspaceClient(
+            account_id=self.credentials.account_id,
+            token=self.credentials.token,
+            access_url=self.credentials.access_url,
+            request_max_retries=self.request_max_retries,
+            request_retry_delay=self.request_retry_delay,
+            request_timeout=self.request_timeout,
+        )
+
+    def _get_or_create_dagster_adhoc_job(self) -> DbtCloudJob:
+        """Get or create an ad hoc dbt Cloud job for the given project and environment in this dbt Cloud Workspace.
+
+        Returns:
+            DbtCloudJob: Internal representation of the dbt Cloud job.
+        """
+        client = self.get_client()
+        expected_job_name = self.adhoc_job_name or get_dagster_adhoc_job_name(
+            project_id=self.project_id,
+            project_name=self.project_name,
+            environment_id=self.environment_id,
+            environment_name=self.environment_name,
+        )
+        jobs = [
+            DbtCloudJob.from_job_details(job_details)
+            for job_details in client.list_jobs(
+                project_id=self.project_id,
+                environment_id=self.environment_id,
+            )
+        ]
+
+        if expected_job_name in {job.name for job in jobs}:
+            return next(job for job in jobs if job.name == expected_job_name)
+        return DbtCloudJob.from_job_details(
+            client.create_job(
+                project_id=self.project_id,
+                environment_id=self.environment_id,
+                job_name=expected_job_name,
+                description=(
+                    "This job is used by Dagster to parse your dbt Cloud workspace "
+                    "and to kick off runs of dbt Cloud models."
+                ),
+            )
+        )
+
+    @cached_method
+    def fetch_workspace_data(self) -> DbtCloudWorkspaceData:
+        adhoc_job = self._get_or_create_dagster_adhoc_job()
+        run_handler = DbtCloudJobRunHandler.run(
+            job_id=adhoc_job.id,
+            args=["parse"],
+            client=self.get_client(),
+        )
+        run = run_handler.wait()
+        run.raise_for_status()
+        return DbtCloudWorkspaceData(
+            project_id=self.project_id,
+            environment_id=self.environment_id,
+            adhoc_job_id=adhoc_job.id,
+            manifest=run_handler.get_manifest(),
+            jobs=self.get_client().list_jobs(
+                project_id=self.project_id,
+                environment_id=self.environment_id,
+            ),
+        )
+
+    def get_or_fetch_workspace_data(self) -> DbtCloudWorkspaceData:
+        return DbtCloudWorkspaceDefsLoader(
+            workspace=self,
+            translator=DagsterDbtTranslator(),
+            select=DBT_DEFAULT_SELECT,
+            exclude=DBT_DEFAULT_EXCLUDE,
+            selector=DBT_DEFAULT_SELECTOR,
+        ).get_or_fetch_state()
+
+    # Cache spec retrieval for a specific translator class and dbt selection args.
+    @cached_method
+    def load_specs(
+        self,
+        select: str,
+        exclude: str,
+        selector: str,
+        dagster_dbt_translator: Optional[DagsterDbtTranslator] = None,
+    ) -> Sequence[Union[AssetSpec, AssetCheckSpec]]:
+        dagster_dbt_translator = dagster_dbt_translator or DagsterDbtTranslator()
+
+        with self.process_config_and_initialize_cm() as initialized_workspace:
+            defs = DbtCloudWorkspaceDefsLoader(
+                workspace=initialized_workspace,
+                translator=dagster_dbt_translator,
+                select=select,
+                exclude=exclude,
+                selector=selector,
+            ).build_defs()
+            asset_specs = check.is_list(
+                defs.assets,
+                AssetSpec,
+            )
+            asset_check_specs = check.is_list(
+                [
+                    check_spec
+                    for asset_def in defs.asset_checks or []
+                    for check_spec in asset_def.check_specs
+                ],
+                AssetCheckSpec,
+            )
+            return [*asset_specs, *asset_check_specs]
+
+    def load_asset_specs(
+        self,
+        select: str,
+        exclude: str,
+        selector: str,
+        dagster_dbt_translator: Optional[DagsterDbtTranslator] = None,
+    ) -> Sequence[AssetSpec]:
+        return [
+            spec
+            for spec in self.load_specs(
+                dagster_dbt_translator=dagster_dbt_translator,
+                select=select,
+                exclude=exclude,
+                selector=selector,
+            )
+            if isinstance(spec, AssetSpec)
+        ]
+
+    def load_check_specs(
+        self,
+        select: str,
+        exclude: str,
+        selector: str,
+        dagster_dbt_translator: Optional[DagsterDbtTranslator] = None,
+    ) -> Sequence[AssetCheckSpec]:
+        return [
+            spec
+            for spec in self.load_specs(
+                dagster_dbt_translator=dagster_dbt_translator,
+                select=select,
+                exclude=exclude,
+                selector=selector,
+            )
+            if isinstance(spec, AssetCheckSpec)
+        ]
+
+    @public
+    def cli(
+        self,
+        args: Sequence[str],
+        dagster_dbt_translator: Optional[DagsterDbtTranslator] = None,
+        context: Optional[AssetExecutionContext] = None,
+    ) -> DbtCloudCliInvocation:
+        """Creates a dbt CLI invocation with the dbt Cloud client.
+
+        Args:
+            args: (Sequence[str]): The dbt CLI command to execute.
+            dagster_dbt_translator (Optional[DagsterDbtTranslator]): Allows customizing how to map
+                dbt models, seeds, etc. to asset keys and asset metadata.
+            context (Optional[AssetExecutionContext]): The execution context.
+        """
+        dagster_dbt_translator = validate_opt_translator(dagster_dbt_translator)
+        dagster_dbt_translator = dagster_dbt_translator or DagsterDbtTranslator()
+
+        client = self.get_client()
+        workspace_data = self.get_or_fetch_workspace_data()
+        job_id = workspace_data.adhoc_job_id
+        manifest = workspace_data.manifest
+
+        updated_params = get_updated_cli_invocation_params_for_context(
+            context=context, manifest=manifest, dagster_dbt_translator=dagster_dbt_translator
+        )
+        manifest = updated_params.manifest
+        dagster_dbt_translator = updated_params.dagster_dbt_translator
+        selection_args = updated_params.selection_args
+        indirect_selection = updated_params.indirect_selection
+
+        # set dbt indirect selection if needed to execute specific dbt tests due to asset check
+        # selection
+        indirect_selection_args = (
+            [f"--indirect-selection {indirect_selection}"] if indirect_selection else []
+        )
+
+        full_dbt_args = [*args, *selection_args, *indirect_selection_args]
+
+        # We pass the manifest instead of the workspace data
+        # because we use the manifest included in the asset definitions
+        # when this method is called inside a function decorated with `@dbt_cloud_assets`
+        return DbtCloudCliInvocation.run(
+            job_id=job_id,
+            args=full_dbt_args,
+            client=client,
+            manifest=manifest,
+            dagster_dbt_translator=dagster_dbt_translator,
+            context=context,
+        )
+
+
+def load_dbt_cloud_asset_specs(
+    workspace: DbtCloudWorkspace,
+    dagster_dbt_translator: Optional[DagsterDbtTranslator] = None,
+    select: str = DBT_DEFAULT_SELECT,
+    exclude: str = DBT_DEFAULT_EXCLUDE,
+    selector: str = DBT_DEFAULT_SELECTOR,
+) -> Sequence[AssetSpec]:
+    return workspace.load_asset_specs(
+        dagster_dbt_translator=dagster_dbt_translator,
+        select=select,
+        exclude=exclude,
+        selector=selector,
+    )
+
+
+def load_dbt_cloud_check_specs(
+    workspace: DbtCloudWorkspace,
+    dagster_dbt_translator: Optional[DagsterDbtTranslator] = None,
+    select: str = DBT_DEFAULT_SELECT,
+    exclude: str = DBT_DEFAULT_EXCLUDE,
+    selector: str = DBT_DEFAULT_SELECTOR,
+) -> Sequence[AssetCheckSpec]:
+    return workspace.load_check_specs(
+        dagster_dbt_translator=dagster_dbt_translator,
+        select=select,
+        exclude=exclude,
+        selector=selector,
+    )
+
+
+@record
+class DbtCloudWorkspaceDefsLoader(StateBackedDefinitionsLoader[DbtCloudWorkspaceData]):
+    workspace: DbtCloudWorkspace
+    translator: DagsterDbtTranslator
+    select: str
+    exclude: str
+    selector: str
+
+    @property
+    def defs_key(self) -> str:
+        return f"{DBT_CLOUD_RECONSTRUCTION_METADATA_KEY_PREFIX}.{self.workspace.unique_id}"
+
+    def fetch_state(self) -> DbtCloudWorkspaceData:
+        return self.workspace.fetch_workspace_data()
+
+    def defs_from_state(self, state: DbtCloudWorkspaceData) -> Definitions:
+        all_asset_specs, all_check_specs = build_dbt_specs(
+            manifest=state.manifest,
+            translator=self.translator,
+            select=self.select,
+            exclude=self.exclude,
+            selector=self.selector,
+            io_manager_key=None,
+            project=None,
+        )
+
+        all_asset_specs = [
+            spec.replace_attributes(kinds={"dbtcloud"} | spec.kinds - {"dbt"})
+            for spec in all_asset_specs
+        ]
+
+        # External facing checks are not supported yet
+        # https://linear.app/dagster-labs/issue/AD-915/support-external-asset-checks-in-dbt-cloud-v2
+        @multi_asset_check(specs=all_check_specs)
+        def _all_asset_checks(): ...
+
+        return Definitions(assets=all_asset_specs, asset_checks=[_all_asset_checks])

dagster_dbt/cloud_v2/run_handler.py

@@ -0,0 +1,229 @@
+from collections.abc import Iterator, Mapping, Sequence
+from typing import Any, Optional, Union
+
+from dagster import (
+    AssetCheckEvaluation,
+    AssetCheckResult,
+    AssetCheckSeverity,
+    AssetExecutionContext,
+    AssetMaterialization,
+    MetadataValue,
+    Output,
+    get_dagster_logger,
+)
+from dagster._record import record
+from dateutil import parser
+
+from dagster_dbt.asset_utils import build_dbt_specs, get_asset_check_key_for_test
+from dagster_dbt.cloud_v2.client import DbtCloudWorkspaceClient
+from dagster_dbt.cloud_v2.types import DbtCloudRun
+from dagster_dbt.compat import REFABLE_NODE_TYPES, NodeStatus, NodeType, TestStatus
+from dagster_dbt.dagster_dbt_translator import DagsterDbtTranslator
+
+COMPLETED_AT_TIMESTAMP_METADATA_KEY = "dagster_dbt/completed_at_timestamp"
+
+logger = get_dagster_logger()
+
+
+@record
+class DbtCloudJobRunHandler:
+    """Handles the process of a dbt Cloud job run."""
+
+    job_id: int
+    run_id: int
+    args: Sequence[str]
+    client: DbtCloudWorkspaceClient
+
+    @classmethod
+    def run(
+        cls, job_id: int, args: Sequence[str], client: DbtCloudWorkspaceClient
+    ) -> "DbtCloudJobRunHandler":
+        run_details = client.trigger_job_run(job_id, steps_override=[" ".join(["dbt", *args])])
+        dbt_cloud_run = DbtCloudRun.from_run_details(run_details=run_details)
+        return DbtCloudJobRunHandler(
+            job_id=job_id,
+            run_id=dbt_cloud_run.id,
+            args=args,
+            client=client,
+        )
+
+    def wait(self, timeout: Optional[float] = None) -> DbtCloudRun:
+        run_details = self.client.poll_run(run_id=self.run_id, poll_timeout=timeout)
+        dbt_cloud_run = DbtCloudRun.from_run_details(run_details=run_details)
+        return dbt_cloud_run
+
+    def get_run_results(self) -> Mapping[str, Any]:
+        return self.client.get_run_results_json(run_id=self.run_id)
+
+    def get_manifest(self) -> Mapping[str, Any]:
+        return self.client.get_run_manifest_json(run_id=self.run_id)
+
+    def list_run_artifacts(self) -> Sequence[str]:
+        return self.client.list_run_artifacts(run_id=self.run_id)
+
+
+def get_completed_at_timestamp(result: Mapping[str, Any]) -> float:
+    # result["timing"] is a list of events in run_results.json
+    # For successful models and passing tests,
+    # the last item of that list includes the timing details of the execution.
+    return parser.parse(result["timing"][-1]["completed_at"]).timestamp()
+
+
+@record
+class DbtCloudJobRunResults:
+    """Represents the run results of a dbt Cloud job run."""
+
+    run_id: int
+    run_results: Mapping[str, Any]
+
+    @classmethod
+    def from_run_results_json(cls, run_results_json: Mapping[str, Any]) -> "DbtCloudJobRunResults":
+        return cls(
+            run_id=int(run_results_json["metadata"]["env"]["DBT_CLOUD_RUN_ID"]),
+            run_results=run_results_json,
+        )
+
+    def to_default_asset_events(
+        self,
+        client: DbtCloudWorkspaceClient,
+        manifest: Mapping[str, Any],
+        dagster_dbt_translator: Optional[DagsterDbtTranslator] = None,
+        context: Optional[AssetExecutionContext] = None,
+    ) -> Iterator[Union[AssetCheckEvaluation, AssetCheckResult, AssetMaterialization, Output]]:
+        """Convert the run results of a dbt Cloud job run to a set of corresponding Dagster events.
+
+        Args:
+            client (DbtCloudWorkspaceClient): The client for the dbt Cloud workspace.
+            manifest (Mapping[str, Any]): The dbt manifest blob.
+            dagster_dbt_translator (DagsterDbtTranslator): Optionally, a custom translator for
+                linking dbt nodes to Dagster assets.
+            context (Optional[AssetExecutionContext]): The execution context.
+
+        Returns:
+            Iterator[Union[AssetCheckEvaluation, AssetCheckResult, AssetMaterialization, Output]]:
+                A set of corresponding Dagster events.
+
+                In a Dagster asset definition, the following are yielded:
+                - Output for refables (e.g. models, seeds, snapshots.)
+                - AssetCheckResult for dbt tests.
+
+                For ad hoc usage, the following are yielded:
+                - AssetMaterialization for refables (e.g. models, seeds, snapshots.)
+                - AssetCheckEvaluation for dbt tests.
+        """
+        dagster_dbt_translator = dagster_dbt_translator or DagsterDbtTranslator()
+        has_asset_def: bool = bool(context and context.has_assets_def)
+
+        run = DbtCloudRun.from_run_details(run_details=client.get_run_details(run_id=self.run_id))
+
+        invocation_id: str = self.run_results["metadata"]["invocation_id"]
+        for result in self.run_results["results"]:
+            unique_id: str = result["unique_id"]
+            dbt_resource_props: Mapping[str, Any] = manifest["nodes"].get(unique_id)
+            if not dbt_resource_props:
+                logger.warning(
+                    f"Unique ID {unique_id} not found in manifest. "
+                    f"This can happen if you are parsing old runs fetched via the sensor, "
+                    f"or if your manifest is out of date. "
+                    f"Reloading your code location will fix the latter."
+                )
+                continue
+            select: str = ".".join(dbt_resource_props["fqn"])
+
+            default_metadata = {
+                "unique_id": unique_id,
+                "invocation_id": invocation_id,
+                "execution_duration": result["execution_time"],
+            }
+
+            if run.url:
+                default_metadata["run_url"] = MetadataValue.url(run.url)
+
+            resource_type: str = dbt_resource_props["resource_type"]
+            result_status: str = result["status"]
+            materialization: str = dbt_resource_props["config"]["materialized"]
+
+            is_ephemeral = materialization == "ephemeral"
+
+            # Build the specs for the given unique ID
+            asset_specs, _ = build_dbt_specs(
+                manifest=manifest,
+                translator=dagster_dbt_translator,
+                select=select,
+                exclude="",
+                selector="",
+                io_manager_key=None,
+                project=None,
+            )
+
+            if (
+                resource_type in REFABLE_NODE_TYPES
+                and result_status == NodeStatus.Success
+                and not is_ephemeral
+            ):
+                spec = asset_specs[0]
+                metadata = {
+                    **default_metadata,
+                    COMPLETED_AT_TIMESTAMP_METADATA_KEY: MetadataValue.timestamp(
+                        get_completed_at_timestamp(result=result)
+                    ),
+                }
+                if context and has_asset_def:
+                    yield Output(
+                        value=None,
+                        output_name=spec.key.to_python_identifier(),
+                        metadata=metadata,
+                    )
+                else:
+                    yield AssetMaterialization(
+                        asset_key=spec.key,
+                        metadata=metadata,
+                    )
+            elif resource_type == NodeType.Test:
+                metadata = {
+                    **default_metadata,
+                    "status": result_status,
+                    COMPLETED_AT_TIMESTAMP_METADATA_KEY: MetadataValue.timestamp(
+                        get_completed_at_timestamp(result=result)
+                    ),
+                }
+                if result["failures"] is not None:
+                    metadata["dagster_dbt/failed_row_count"] = result["failures"]
+
+                asset_check_key = get_asset_check_key_for_test(
+                    manifest=manifest,
+                    dagster_dbt_translator=dagster_dbt_translator,
+                    test_unique_id=unique_id,
+                    project=None,
+                )
+
+                if (
+                    context
+                    and has_asset_def
+                    and asset_check_key is not None
+                    and asset_check_key in context.selected_asset_check_keys
+                ):
+                    # The test is an asset check in an asset, so yield an `AssetCheckResult`.
+                    yield AssetCheckResult(
+                        passed=result_status == TestStatus.Pass,
+                        asset_key=asset_check_key.asset_key,
+                        check_name=asset_check_key.name,
+                        metadata=metadata,
+                        severity=(
+                            AssetCheckSeverity.WARN
+                            if result_status == TestStatus.Warn
+                            else AssetCheckSeverity.ERROR
+                        ),
+                    )
+                elif not has_asset_def and asset_check_key is not None:
+                    yield AssetCheckEvaluation(
+                        passed=result_status == TestStatus.Pass,
+                        asset_key=asset_check_key.asset_key,
+                        check_name=asset_check_key.name,
+                        metadata=metadata,
+                        severity=(
+                            AssetCheckSeverity.WARN
+                            if result_status == TestStatus.Warn
+                            else AssetCheckSeverity.ERROR
+                        ),
+                    )