dagster-dbt 0.27.13__tar.gz → 0.28.8__tar.gz

{dagster_dbt-0.27.13/dagster_dbt.egg-info → dagster_dbt-0.28.8}/PKG-INFO

@@ -1,28 +1,29 @@
 Metadata-Version: 2.4
 Name: dagster-dbt
-Version: 0.27.13
+Version: 0.28.8
 Summary: A Dagster integration for dbt
 Home-page: https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-dbt
 Author: Dagster Labs
 Author-email: hello@dagsterlabs.com
 License: Apache-2.0
-Classifier: Programming Language :: Python :: 3.9
 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: Operating System :: OS Independent
-Requires-Python: >=3.9,<3.14
+Requires-Python: >=3.10,<3.15
 License-File: LICENSE
-Requires-Dist: dagster==1.11.13
+Requires-Dist: dagster==1.12.8
 Requires-Dist: dbt-core<1.11,>=1.7
+Requires-Dist: gitpython
 Requires-Dist: Jinja2
 Requires-Dist: networkx
 Requires-Dist: orjson
 Requires-Dist: requests
 Requires-Dist: rich
-Requires-Dist: sqlglot[rs]
+Requires-Dist: sqlglot[rs]<28.1.0
 Requires-Dist: typer>=0.9.0
 Requires-Dist: packaging
 Provides-Extra: test-bare

{dagster_dbt-0.27.13 → dagster_dbt-0.28.8}/dagster_dbt/asset_decorator.py

@@ -1,5 +1,5 @@
-from collections.abc import Mapping
-from typing import Any, Callable, Optional
+from collections.abc import Callable, Mapping
+from typing import Any, Optional
 
 from dagster import (
     AssetsDefinition,

{dagster_dbt-0.27.13 → dagster_dbt-0.28.8}/dagster_dbt/asset_utils.py

@@ -1,11 +1,14 @@
 import hashlib
 import os
+import shutil
+import tempfile
 import textwrap
 from collections import defaultdict
 from collections.abc import Iterable, Mapping, Sequence
 from pathlib import Path
 from typing import TYPE_CHECKING, AbstractSet, Annotated, Any, Final, Optional, Union  # noqa: UP035
 
+import yaml
 from dagster import (
     AssetCheckKey,
     AssetCheckSpec,
@@ -18,7 +21,6 @@ from dagster import (
     DagsterInvalidDefinitionError,
     DagsterInvariantViolationError,
     DefaultScheduleStatus,
-    LegacyFreshnessPolicy,
     OpExecutionContext,
     RunConfig,
     ScheduleDefinition,
@@ -33,6 +35,7 @@ from dagster._core.definitions.metadata import TableMetadataSet
 from dagster._core.errors import DagsterInvalidPropertyError
 from dagster._core.types.dagster_type import Nothing
 from dagster._record import ImportFrom, record
+from dagster_shared.record import replace
 
 from dagster_dbt.dbt_project import DbtProject
 from dagster_dbt.metadata_set import DbtMetadataSet
@@ -56,6 +59,10 @@ DBT_DEFAULT_SELECTOR = ""
 DBT_INDIRECT_SELECTION_ENV: Final[str] = "DBT_INDIRECT_SELECTION"
 DBT_EMPTY_INDIRECT_SELECTION: Final[str] = "empty"
 
+# Threshold for switching to selector file to avoid CLI argument length limits
+# https://github.com/dagster-io/dagster/issues/16997
+_SELECTION_ARGS_THRESHOLD: Final[int] = 200
+
 DUPLICATE_ASSET_KEY_ERROR_MESSAGE = (
     "The following dbt resources are configured with identical Dagster asset keys."
     " Please ensure that each dbt resource generates a unique Dagster asset key."
@@ -168,7 +175,9 @@ def get_asset_keys_by_output_name_for_source(
         raise KeyError(f"Could not find a dbt source with name: {source_name}")
 
     return {
-        dagster_name_fn(value): dagster_dbt_translator.get_asset_spec(manifest, unique_id, None).key
+        dagster_name_fn(value): dagster_dbt_translator.get_asset_spec(
+            manifest, unique_id, dbt_project
+        ).key
         for unique_id, value in matching.items()
     }
 
@@ -442,6 +451,10 @@ def get_updated_cli_invocation_params_for_context(
             [assets_def]
         )
 
+        # Get project_dir from dbt_project if available
+        project_dir = Path(dbt_project.project_dir) if dbt_project else None
+        target_project = dbt_project
+
         selection_args, indirect_selection_override = get_subset_selection_for_context(
             context=context,
             manifest=manifest,
@@ -451,17 +464,49 @@ def get_updated_cli_invocation_params_for_context(
             dagster_dbt_translator=dagster_dbt_translator,
             current_dbt_indirect_selection_env=indirect_selection,
         )
+        if (
+            selection_args[0] == "--select"
+            and project_dir
+            and len(resources := selection_args[1].split(" ")) > _SELECTION_ARGS_THRESHOLD
+        ):
+            temp_project_dir = tempfile.mkdtemp()
+            shutil.copytree(project_dir, temp_project_dir, dirs_exist_ok=True)
+            selectors_path = Path(temp_project_dir) / "selectors.yml"
+
+            # Delete any existing selectors, we need to create our own
+            if selectors_path.exists():
+                selectors_path.unlink()
+
+            selector_name = f"dagster_run_{context.run_id}"
+            temp_selectors = {
+                "selectors": [
+                    {
+                        "name": selector_name,
+                        "definition": {"union": list(resources)},
+                    }
+                ]
+            }
+            selectors_path.write_text(yaml.safe_dump(temp_selectors))
+            logger.info(
+                f"DBT selection of {len(resources)} resources exceeds threshold of {_SELECTION_ARGS_THRESHOLD}. "
+                "This may exceed system argument length limits. "
+                f"Executing materialization against temporary copy of DBT project at {temp_project_dir} with ephemeral selector."
+            )
+            selection_args = ["--selector", selector_name]
+            target_project = replace(dbt_project, project_dir=Path(temp_project_dir))
 
         indirect_selection = (
             indirect_selection_override if indirect_selection_override else indirect_selection
         )
+    else:
+        target_project = dbt_project
 
     return DbtCliInvocationPartialParams(
         manifest=manifest,
         dagster_dbt_translator=dagster_dbt_translator,
         selection_args=selection_args,
         indirect_selection=indirect_selection,
-        dbt_project=dbt_project,
+        dbt_project=target_project,
     )
 
 
@@ -527,6 +572,9 @@ def default_metadata_from_dbt_resource_props(
             dbt_resource_props.get("database"),
             dbt_resource_props.get("schema"),
             dbt_resource_props.get("alias"),
+            dbt_resource_props.get("name")
+            if dbt_resource_props.get("resource_type") == "source"
+            else None,
         ]
         if relation_part
     ]
@@ -604,25 +652,6 @@ def default_owners_from_dbt_resource_props(
     return [owner] if isinstance(owner, str) else owner
 
 
-def default_freshness_policy_fn(
-    dbt_resource_props: Mapping[str, Any],
-) -> Optional[LegacyFreshnessPolicy]:
-    dagster_metadata = dbt_resource_props.get("meta", {}).get("dagster", {})
-    freshness_policy_config = dagster_metadata.get("freshness_policy", {})
-
-    freshness_policy = (
-        LegacyFreshnessPolicy(
-            maximum_lag_minutes=float(freshness_policy_config["maximum_lag_minutes"]),
-            cron_schedule=freshness_policy_config.get("cron_schedule"),
-            cron_schedule_timezone=freshness_policy_config.get("cron_schedule_timezone"),
-        )
-        if freshness_policy_config
-        else None
-    )
-
-    return freshness_policy
-
-
 def default_auto_materialize_policy_fn(
     dbt_resource_props: Mapping[str, Any],
 ) -> Optional[AutoMaterializePolicy]:
@@ -813,7 +842,7 @@ def build_dbt_specs(
 
         # add check specs associated with the asset
         for child_unique_id in child_map.get(unique_id, []):
-            if not child_unique_id.startswith("test"):
+            if child_unique_id not in selected_unique_ids or not child_unique_id.startswith("test"):
                 continue
             check_spec = translator.get_asset_check_spec(
                 asset_spec=spec,

{dagster_dbt-0.27.13 → dagster_dbt-0.28.8}/dagster_dbt/cloud/asset_defs.py

@@ -1,9 +1,9 @@
 import json
 import shlex
 from argparse import ArgumentParser, Namespace
-from collections.abc import Mapping, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from contextlib import suppress
-from typing import Any, Callable, Optional, Union, cast
+from typing import Any, Optional, Union, cast
 
 import dagster._check as check
 from dagster import (
@@ -33,7 +33,6 @@ from dagster_dbt.asset_utils import (
     default_asset_key_fn,
     default_auto_materialize_policy_fn,
     default_description_fn,
-    default_freshness_policy_fn,
     default_group_from_dbt_resource_props,
     get_node,
 )
@@ -326,10 +325,6 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
             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):  # pyright: ignore[reportIncompatibleMethodOverride]
-                return self._node_info_to_freshness_policy_fn(dbt_resource_props)
-
             @classmethod
             def get_auto_materialize_policy(cls, dbt_resource_props):  # pyright: ignore[reportIncompatibleMethodOverride]
                 return self._node_info_to_auto_materialize_policy_fn(dbt_resource_props)
@@ -375,11 +370,6 @@ class DbtCloudCacheableAssetsDefinition(CacheableAssetsDefinition):
                     for spec in specs
                 },
             },
-            legacy_freshness_policies_by_output_name={
-                spec.key.to_python_identifier(): spec.legacy_freshness_policy
-                for spec in specs
-                if spec.legacy_freshness_policy
-            },
             auto_materialize_policies_by_output_name={
                 spec.key.to_python_identifier(): spec.auto_materialize_policy
                 for spec in specs
@@ -546,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[LegacyFreshnessPolicy]
-    ] = default_freshness_policy_fn,
     node_info_to_auto_materialize_policy_fn: Callable[
         [Mapping[str, Any]], Optional[AutoMaterializePolicy]
     ] = default_auto_materialize_policy_fn,
@@ -570,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
@@ -631,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-0.27.13 → dagster_dbt-0.28.8}/dagster_dbt/cloud/utils.py

@@ -1,5 +1,5 @@
-from collections.abc import Iterator, Mapping, Sequence
-from typing import Any, Callable, Optional, Union
+from collections.abc import Callable, Iterator, Mapping, Sequence
+from typing import Any, Optional, Union
 
 import dateutil
 from dagster import (

{dagster_dbt-0.27.13 → dagster_dbt-0.28.8}/dagster_dbt/cloud_v2/asset_decorator.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Optional
+from collections.abc import Callable
+from typing import Any, Optional
 
 from dagster import AssetsDefinition, multi_asset
 from dagster._annotations import public

{dagster_dbt-0.27.13 → dagster_dbt-0.28.8}/dagster_dbt/cloud_v2/cli_invocation.py

@@ -1,3 +1,4 @@
+import sys
 from collections.abc import Iterator, Mapping, Sequence
 from typing import Any, Optional, Union
 
@@ -54,6 +55,12 @@ class DbtCloudCliInvocation:
         self, timeout: Optional[float] = None
     ) -> Iterator[Union[AssetCheckEvaluation, AssetCheckResult, AssetMaterialization, Output]]:
         run = self.run_handler.wait(timeout=timeout)
+
+        # Write dbt Cloud run logs to stdout
+        logs = self.run_handler.get_run_logs()
+        if logs:
+            sys.stdout.write(logs)
+
         if "run_results.json" in self.run_handler.list_run_artifacts():
             run_results = DbtCloudJobRunResults.from_run_results_json(
                 run_results_json=self.run_handler.get_run_results()

{dagster_dbt-0.27.13 → dagster_dbt-0.28.8}/dagster_dbt/cloud_v2/client.py

@@ -92,7 +92,7 @@ class DbtCloudWorkspaceClient(DagsterModel):
         data: Optional[Mapping[str, Any]] = None,
         params: Optional[Mapping[str, Any]] = None,
         session_attr: str = "_get_session",
-    ) -> Mapping[str, Any]:
+    ) -> requests.Response:
         url = f"{base_url}/{endpoint}" if endpoint else base_url
 
         num_retries = 0
@@ -107,7 +107,7 @@ class DbtCloudWorkspaceClient(DagsterModel):
                     timeout=self.request_timeout,
                 )
                 response.raise_for_status()
-                return response.json()
+                return response
             except RequestException as e:
                 self._log.error(
                     f"Request to dbt Cloud API failed for url {url} with method {method} : {e}"
@@ -143,7 +143,7 @@ class DbtCloudWorkspaceClient(DagsterModel):
         """
         if not description:
             description = "A job that runs dbt models, sources, and tests."
-        return self._make_request(
+        response = self._make_request(
             method="post",
             endpoint="jobs",
             base_url=self.api_v2_url,
@@ -155,7 +155,8 @@ class DbtCloudWorkspaceClient(DagsterModel):
                 "description": description,
                 "job_type": "other",
             },
-        )["data"]
+        )
+        return response.json()["data"]
 
     def list_jobs(
         self,
@@ -185,7 +186,7 @@ class DbtCloudWorkspaceClient(DagsterModel):
                 "limit": DAGSTER_DBT_CLOUD_LIST_JOBS_INDIVIDUAL_REQUEST_LIMIT,
                 "offset": len(results),
             },
-        )["data"]:
+        ).json()["data"]:
             results.extend(jobs)
             if len(jobs) < DAGSTER_DBT_CLOUD_LIST_JOBS_INDIVIDUAL_REQUEST_LIMIT:
                 break
@@ -201,7 +202,7 @@ class DbtCloudWorkspaceClient(DagsterModel):
             method="get",
             endpoint=f"jobs/{job_id}",
             base_url=self.api_v2_url,
-        )["data"]
+        ).json()["data"]
 
     def destroy_job(self, job_id: int) -> Mapping[str, Any]:
         """Destroys a given dbt Cloud job.
@@ -213,7 +214,7 @@ class DbtCloudWorkspaceClient(DagsterModel):
             method="delete",
             endpoint=f"jobs/{job_id}",
             base_url=self.api_v2_url,
-        )["data"]
+        ).json()["data"]
 
     def trigger_job_run(
         self, job_id: int, steps_override: Optional[Sequence[str]] = None
@@ -237,7 +238,7 @@ class DbtCloudWorkspaceClient(DagsterModel):
             data={"steps_override": steps_override, "cause": DAGSTER_ADHOC_TRIGGER_CAUSE}
             if steps_override
             else {"cause": DAGSTER_ADHOC_TRIGGER_CAUSE},
-        )["data"]
+        ).json()["data"]
 
     def get_runs_batch(
         self,
@@ -278,26 +279,35 @@ class DbtCloudWorkspaceClient(DagsterModel):
                 "finished_at__range": f"""["{finished_at_lower_bound.isoformat()}", "{finished_at_upper_bound.isoformat()}"]""",
                 "order_by": "finished_at",
             },
-        )
+        ).json()
         data = cast("Sequence[Mapping[str, Any]]", resp["data"])
         total_count = resp["extra"]["pagination"]["total_count"]
         return data, total_count
 
-    def get_run_details(self, run_id: int) -> Mapping[str, Any]:
+    def get_run_details(
+        self, run_id: int, include_related: Optional[Sequence[str]] = None
+    ) -> Mapping[str, Any]:
         """Retrieves the details of a given dbt Cloud Run.
 
         Args:
-            run_id (str): The dbt Cloud Run ID. You can retrieve this value from the
+            run_id (int): The dbt Cloud Run ID. You can retrieve this value from the
                 URL of the given run in the dbt Cloud UI.
+            include_related (Optional[Sequence[str]]): List of related fields to pull with the run.
+                Valid values are "trigger", "job", "debug_logs", and "run_steps".
 
         Returns:
             Dict[str, Any]: Parsed json data representing the API response.
         """
+        params = {}
+        if include_related:
+            params["include_related"] = ",".join(include_related)
+
         return self._make_request(
             method="get",
             endpoint=f"runs/{run_id}",
             base_url=self.api_v2_url,
-        )["data"]
+            params=params,
+        ).json()["data"]
 
     def poll_run(
         self,
@@ -352,21 +362,25 @@ class DbtCloudWorkspaceClient(DagsterModel):
                 endpoint=f"runs/{run_id}/artifacts",
                 base_url=self.api_v2_url,
                 session_attr="_get_artifact_session",
-            )["data"],
+            ).json()["data"],
         )
 
     def get_run_artifact(self, run_id: int, path: str) -> Mapping[str, Any]:
         """Retrieves an artifact at the given path for a given dbt Cloud Run.
 
+        Args:
+            run_id (int): The dbt Cloud Run ID.
+            path (str): The path to the artifact (e.g., "run_results.json", "manifest.json").
+
         Returns:
-            Dict[str, Any]: Parsed json data representing the API response.
+            Dict[str, Any]: Parsed json data representing the artifact.
         """
         return self._make_request(
             method="get",
             endpoint=f"runs/{run_id}/artifacts/{path}",
             base_url=self.api_v2_url,
             session_attr="_get_artifact_session",
-        )
+        ).json()
 
     def get_run_results_json(self, run_id: int) -> Mapping[str, Any]:
         """Retrieves the run_results.json artifact of a given dbt Cloud Run.
@@ -384,6 +398,65 @@ class DbtCloudWorkspaceClient(DagsterModel):
         """
         return self.get_run_artifact(run_id=run_id, path="manifest.json")
 
+    def get_run_logs(self, run_id: int, max_retries: int = 3, retry_delay: float = 2.0) -> str:
+        """Retrieves the stdout/stderr logs from a given dbt Cloud Run.
+
+        This method fetches logs from the run_steps field by calling get_run_details
+        with include_related=["run_steps"]. Each step contains a logs field with
+        the stdout/stderr output for that step.
+
+        Note: There can be a slight delay between when a run completes and when the logs
+        are fully populated in the API. This method will retry a few times if it detects
+        completed steps with empty logs.
+
+        Args:
+            run_id (int): The dbt Cloud Run ID.
+            max_retries (int): Maximum number of times to retry fetching logs if empty. Defaults to 3.
+            retry_delay (float): Time in seconds to wait between retries. Defaults to 2.0.
+
+        Returns:
+            str: The concatenated log text content from all run steps.
+        """
+        for attempt in range(max_retries):
+            run_details = self.get_run_details(run_id=run_id, include_related=["run_steps"])
+
+            logs_parts = []
+            run_steps = run_details.get("run_steps", [])
+            completed_steps_with_empty_logs = 0
+
+            for step in run_steps:
+                step_name = step.get("name", "Unknown Step")
+                step_logs = step.get("logs", "")
+                step_status = step.get("status_humanized", "unknown")
+
+                # Track completed steps with empty logs
+                if step_status == "Success" and not step_logs:
+                    completed_steps_with_empty_logs += 1
+
+                if step_logs:
+                    logs_parts.append(f"=== Step: {step_name} ===")
+                    logs_parts.append(step_logs)
+                    logs_parts.append("")  # Empty line between steps
+
+            # If we have completed steps with empty logs and retries left, wait and try again
+            if completed_steps_with_empty_logs > 0 and attempt < max_retries - 1:
+                self._log.warning(
+                    f"Found {completed_steps_with_empty_logs} completed steps with empty logs for run {run_id}. "
+                    f"Retrying in {retry_delay} seconds..."
+                )
+                time.sleep(retry_delay)
+                continue
+
+            # Either we got all logs or we're out of retries
+            if completed_steps_with_empty_logs > 0:
+                self._log.warning(
+                    f"Still missing logs for {completed_steps_with_empty_logs} completed steps after {max_retries} attempts"
+                )
+
+            return "\n".join(logs_parts) if logs_parts else ""
+
+        return ""
+
     def get_project_details(self, project_id: int) -> Mapping[str, Any]:
         """Retrieves the details of a given dbt Cloud Project.
 
@@ -398,7 +471,7 @@ class DbtCloudWorkspaceClient(DagsterModel):
             method="get",
             endpoint=f"projects/{project_id}",
             base_url=self.api_v2_url,
-        )["data"]
+        ).json()["data"]
 
     def get_environment_details(self, environment_id: int) -> Mapping[str, Any]:
         """Retrieves the details of a given dbt Cloud Environment.
@@ -414,7 +487,7 @@ class DbtCloudWorkspaceClient(DagsterModel):
             method="get",
             endpoint=f"environments/{environment_id}",
             base_url=self.api_v2_url,
-        )["data"]
+        ).json()["data"]
 
     def get_account_details(self) -> Mapping[str, Any]:
         """Retrieves the details of the account associated to the dbt Cloud workspace.
@@ -426,7 +499,7 @@ class DbtCloudWorkspaceClient(DagsterModel):
             method="get",
             endpoint=None,
             base_url=self.api_v2_url,
-        )["data"]
+        ).json()["data"]
 
     def verify_connection(self) -> None:
         """Verifies the connection to the dbt Cloud REST API."""

{dagster_dbt-0.27.13 → dagster_dbt-0.28.8}/dagster_dbt/cloud_v2/run_handler.py

@@ -12,7 +12,9 @@ from dagster import (
     get_dagster_logger,
 )
 from dagster._record import record
+from dagster._time import get_current_timestamp
 from dateutil import parser
+from requests.exceptions import RequestException
 
 from dagster_dbt.asset_utils import build_dbt_specs, get_asset_check_key_for_test
 from dagster_dbt.cloud_v2.client import DbtCloudWorkspaceClient
@@ -61,8 +63,28 @@ class DbtCloudJobRunHandler:
     def list_run_artifacts(self) -> Sequence[str]:
         return self.client.list_run_artifacts(run_id=self.run_id)
 
+    def get_run_logs(self) -> Optional[str]:
+        """Retrieves the stdout/stderr logs from the completed dbt Cloud run.
+
+        This method fetches logs from the run_steps by calling get_run_details
+        with include_related=["run_steps"].
+
+        Returns:
+            Optional[str]: The concatenated log text content from all run steps,
+                or None if logs are not available.
+        """
+        try:
+            return self.client.get_run_logs(run_id=self.run_id)
+        except RequestException as e:
+            logger.warning(f"Failed to retrieve logs for run {self.run_id}: {e}")
+            return None
+
 
 def get_completed_at_timestamp(result: Mapping[str, Any]) -> float:
+    timing = result["timing"]
+    if len(timing) == 0:
+        # as a fallback, use the current timestamp
+        return get_current_timestamp()
     # 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.

{dagster_dbt-0.27.13 → dagster_dbt-0.28.8}/dagster_dbt/cloud_v2/sensor_builder.py

@@ -142,7 +142,7 @@ def sorted_asset_events(
     return [
         sorted_event[1]
         for sorted_event in sorted(
-            materializations_and_timestamps, key=lambda x: (x[0], topo_aks.index(x[1].asset_key))
+            materializations_and_timestamps, key=lambda x: (topo_aks.index(x[1].asset_key), x[0])
         )
     ]
 

{dagster_dbt-0.27.13 → dagster_dbt-0.28.8}/dagster_dbt/compat.py

@@ -1,9 +1,8 @@
 import logging
 from enum import Enum
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, TypeAlias
 
 from packaging import version
-from typing_extensions import TypeAlias
 
 # it's unclear exactly which dbt import adds a handler to the root logger, but something certainly does!
 # on this line, we keep track of the set of handlers that are on the root logger BEFORE any dbt imports