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

dagster_dbt/utils.py

@@ -1,244 +1,111 @@
 from argparse import Namespace
-from typing import (
-    AbstractSet,
-    Any,
-    Callable,
-    Dict,
-    Iterator,
-    Mapping,
-    Optional,
-    Sequence,
-    Union,
-)
-
-import dateutil
-from dagster import (
-    AssetKey,
-    AssetMaterialization,
-    AssetObservation,
-    MetadataValue,
-    Output,
-    _check as check,
-)
-from dagster._core.definitions.metadata import RawMetadataValue
-
-from .types import DbtOutput
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, AbstractSet, Any, Optional, cast  # noqa: UP035
+
+import dagster_shared.check as check
+import orjson
+from dagster import AssetKey
+from dagster._utils.names import clean_name_lower
+from packaging import version
+
+from dagster_dbt.compat import DBT_PYTHON_VERSION
+
+if TYPE_CHECKING:
+    from dagster_dbt.core.resource import DbtProject
 
 # dbt resource types that may be considered assets
 ASSET_RESOURCE_TYPES = ["model", "seed", "snapshot"]
 
 
-def default_node_info_to_asset_key(node_info: Mapping[str, Any]) -> AssetKey:
-    return AssetKey(node_info["unique_id"].split("."))
+clean_name = clean_name_lower
 
 
-def _resource_type(unique_id: str) -> str:
-    # returns the type of the node (e.g. model, test, snapshot)
-    return unique_id.split(".")[0]
+def default_node_info_to_asset_key(node_info: Mapping[str, Any]) -> AssetKey:
+    return AssetKey(node_info["unique_id"].split("."))
 
 
 def dagster_name_fn(dbt_resource_props: Mapping[str, Any]) -> str:
     return dbt_resource_props["unique_id"].replace(".", "_").replace("-", "_").replace("*", "_star")
 
 
-def _node_result_to_metadata(node_result: Mapping[str, Any]) -> Mapping[str, RawMetadataValue]:
-    return {
-        "Materialization Strategy": node_result["config"]["materialized"],
-        "Database": node_result["database"],
-        "Schema": node_result["schema"],
-        "Alias": node_result["alias"],
-        "Description": node_result["description"],
-    }
-
-
-def _timing_to_metadata(timings: Sequence[Mapping[str, Any]]) -> Mapping[str, RawMetadataValue]:
-    metadata: Dict[str, RawMetadataValue] = {}
-    for timing in timings:
-        if timing["name"] == "execute":
-            desc = "Execution"
-        elif timing["name"] == "compile":
-            desc = "Compilation"
-        else:
-            continue
-
-        # dateutil does not properly expose its modules to static checkers
-        started_at = dateutil.parser.isoparse(timing["started_at"])  # type: ignore
-        completed_at = dateutil.parser.isoparse(timing["completed_at"])  # type: ignore
-        duration = completed_at - started_at
-        metadata.update(
-            {
-                f"{desc} Started At": started_at.isoformat(timespec="seconds"),
-                f"{desc} Completed At": started_at.isoformat(timespec="seconds"),
-                f"{desc} Duration": duration.total_seconds(),
-            }
-        )
-    return metadata
-
-
-def result_to_events(
-    result: Mapping[str, Any],
-    docs_url: Optional[str] = None,
-    node_info_to_asset_key: Optional[Callable[[Mapping[str, Any]], AssetKey]] = None,
-    manifest_json: Optional[Mapping[str, Any]] = None,
-    extra_metadata: Optional[Mapping[str, RawMetadataValue]] = None,
-    generate_asset_outputs: bool = False,
-) -> Iterator[Union[AssetMaterialization, AssetObservation, Output]]:
-    """This is a hacky solution that attempts to consolidate parsing many of the potential formats
-    that dbt can provide its results in. This is known to work for CLI Outputs for dbt versions 0.18+,
-    as well as RPC responses for a similar time period, but as the RPC response schema is not documented
-    nor enforced, this can become out of date easily.
-    """
-    node_info_to_asset_key = check.opt_callable_param(
-        node_info_to_asset_key, "node_info_to_asset_key", default=default_node_info_to_asset_key
-    )
-
-    # status comes from set of fields rather than "status"
-    if "fail" in result:
-        status = (
-            "fail"
-            if result.get("fail")
-            else "skip"
-            if result.get("skip")
-            else "error"
-            if result.get("error")
-            else "success"
-        )
-    else:
-        status = result["status"]
-
-    # all versions represent timing the same way
-    metadata = {"Status": status, "Execution Time (seconds)": result["execution_time"]}
-    metadata.update(_timing_to_metadata(result["timing"]))
-
-    # working with a response that contains the node block (RPC and CLI 0.18.x)
-    if "node" in result:
-        unique_id = result["node"]["unique_id"]
-        metadata.update(_node_result_to_metadata(result["node"]))
+def select_unique_ids(
+    select: str,
+    exclude: str,
+    selector: str,
+    project: Optional["DbtProject"],
+    manifest_json: Mapping[str, Any],
+) -> AbstractSet[str]:
+    """Given dbt selection paramters, return the unique ids of all resources that match that selection."""
+    manifest_version = version.parse(manifest_json.get("metadata", {}).get("dbt_version", "0.0.0"))
+    # using dbt Fusion, efficient to invoke the CLI for selection
+    if manifest_version.major >= 2 and project is not None:
+        return _select_unique_ids_from_cli(select, exclude, selector, project)
+    # using dbt-core, too slow to invoke the CLI, so we use library functions instead
+    elif DBT_PYTHON_VERSION is not None:
+        return _select_unique_ids_from_manifest(select, exclude, selector, manifest_json)
     else:
-        unique_id = result["unique_id"]
-
-    if docs_url:
-        metadata["docs_url"] = MetadataValue.url(f"{docs_url}#!/model/{unique_id}")
+        # in theory, as long as dbt-core is a dependency of dagster-dbt, this can't happen, but adding
+        # this for now to be safe
+        check.failed(
+            "dbt-core is not installed and no `project` was passed to `select_unique_ids`. "
+            "This can happen if you are using the dbt Cloud integration without the dbt-core package installed."
+        )
 
-    if extra_metadata:
-        metadata.update(extra_metadata)
 
-    # if you have a manifest available, get the full node info, otherwise just populate unique_id
-    dbt_resource_props = (
-        manifest_json["nodes"][unique_id] if manifest_json else {"unique_id": unique_id}
-    )
+def _select_unique_ids_from_cli(
+    select: str,
+    exclude: str,
+    selector: str,
+    project: "DbtProject",
+) -> AbstractSet[str]:
+    """Uses the available dbt CLI to list the unique ids of the selected models. This is not recommended if
+    dbt-core is available, as it will be slower than using the manifest.
+    """
+    from dagster_dbt.core.resource import DbtCliResource
 
-    node_resource_type = _resource_type(unique_id)
-
-    if node_resource_type in ASSET_RESOURCE_TYPES and status == "success":
-        if generate_asset_outputs:
-            yield Output(
-                value=None,
-                output_name=dagster_name_fn(dbt_resource_props),
-                metadata=metadata,
-            )
-        else:
-            yield AssetMaterialization(
-                asset_key=node_info_to_asset_key(dbt_resource_props),
-                description=f"dbt node: {unique_id}",
-                metadata=metadata,
-            )
-    # can only associate tests with assets if we have manifest_json available
-    elif node_resource_type == "test" and manifest_json and status != "skipped":
-        upstream_unique_ids = manifest_json["nodes"][unique_id]["depends_on"]["nodes"]
-        # tests can apply to multiple asset keys
-        for upstream_id in upstream_unique_ids:
-            # the upstream id can reference a node or a source
-            dbt_resource_props = manifest_json["nodes"].get(upstream_id) or manifest_json[
-                "sources"
-            ].get(upstream_id)
-            if dbt_resource_props is None:
+    cmd = ["list", "--output", "json"]
+    if select and select != "fqn:*":
+        cmd.append("--select")
+        cmd.append(select)
+    if exclude:
+        cmd.append("--exclude")
+        cmd.append(exclude)
+    if selector:
+        cmd.append("--selector")
+        cmd.append(selector)
+
+    raw_events = DbtCliResource(project_dir=project).cli(cmd)._stream_stdout()  # noqa
+    unique_ids = set()
+    for event in raw_events:
+        if isinstance(event, dict):
+            try:
+                msg = orjson.loads(event.get("info", {}).get("msg", "{}"))
+            except orjson.JSONDecodeError:
                 continue
-            upstream_asset_key = node_info_to_asset_key(dbt_resource_props)
-            yield AssetObservation(
-                asset_key=upstream_asset_key,
-                metadata={
-                    "Test ID": result["unique_id"],
-                    "Test Status": status,
-                    "Test Message": result.get("message") or "",
-                },
-            )
-
-
-def generate_events(
-    dbt_output: DbtOutput,
-    node_info_to_asset_key: Optional[Callable[[Mapping[str, Any]], AssetKey]] = None,
-    manifest_json: Optional[Mapping[str, Any]] = None,
-) -> Iterator[Union[AssetMaterialization, AssetObservation]]:
-    """This function yields :py:class:`dagster.AssetMaterialization` events for each model updated by
-    a dbt command, and :py:class:`dagster.AssetObservation` events for each test run.
-
-    Information parsed from a :py:class:`~DbtOutput` object.
-    """
-    for result in dbt_output.result["results"]:
-        for event in result_to_events(
-            result,
-            docs_url=dbt_output.docs_url,
-            node_info_to_asset_key=node_info_to_asset_key,
-            manifest_json=manifest_json,
-        ):
-            yield check.inst(
-                event,
-                (AssetMaterialization, AssetObservation),
-            )
-
-
-def generate_materializations(
-    dbt_output: DbtOutput,
-    asset_key_prefix: Optional[Sequence[str]] = None,
-) -> Iterator[AssetMaterialization]:
-    """This function yields :py:class:`dagster.AssetMaterialization` events for each model updated by
-    a dbt command.
-
-    Information parsed from a :py:class:`~DbtOutput` object.
-
-    Examples:
-        .. code-block:: python
-
-            from dagster import op, Output
-            from dagster_dbt.utils import generate_materializations
-            from dagster_dbt import dbt_cli_resource
-
-            @op(required_resource_keys={"dbt"})
-            def my_custom_dbt_run(context):
-                dbt_output = context.resources.dbt.run()
-                for materialization in generate_materializations(dbt_output):
-                    # you can modify the materialization object to add extra metadata, if desired
-                    yield materialization
-                yield Output(my_dbt_output)
-
-            @job(resource_defs={{"dbt":dbt_cli_resource}})
-            def my_dbt_cli_job():
-                my_custom_dbt_run()
-    """
-    asset_key_prefix = check.opt_sequence_param(asset_key_prefix, "asset_key_prefix", of_type=str)
+            unique_ids.add(msg.get("unique_id"))
 
-    for event in generate_events(
-        dbt_output,
-        node_info_to_asset_key=lambda info: AssetKey(
-            asset_key_prefix + info["unique_id"].split(".")
-        ),
-    ):
-        yield check.inst(event, AssetMaterialization)
+    return unique_ids - {None}
 
 
-def select_unique_ids_from_manifest(
-    select: str,
-    exclude: str,
-    manifest_json: Mapping[str, Any],
+def _select_unique_ids_from_manifest(
+    select: str, exclude: str, selector: str, manifest_json: Mapping[str, Any]
 ) -> AbstractSet[str]:
     """Method to apply a selection string to an existing manifest.json file."""
     import dbt.graph.cli as graph_cli
     import dbt.graph.selector as graph_selector
     from dbt.contracts.graph.manifest import Manifest
+    from dbt.contracts.graph.nodes import SavedQuery, SemanticModel
+    from dbt.contracts.selection import SelectorFile
     from dbt.graph.selector_spec import IndirectSelection, SelectionSpec
     from networkx import DiGraph
 
+    select_specified = select and select != "fqn:*"
+    check.param_invariant(
+        not ((select_specified or exclude) and selector),
+        "selector",
+        "Cannot provide both a selector and a select/exclude param.",
+    )
+
     # NOTE: this was faster than calling `Manifest.from_dict`, so we are keeping this.
     class _DictShim(dict):
         """Shim to enable hydrating a dictionary into a dot-accessible object. We need this because
@@ -252,11 +119,24 @@ def select_unique_ids_from_manifest(
             # allow recursive access e.g. foo.bar.baz
             return _DictShim(ret) if isinstance(ret, dict) else ret
 
+    unit_tests = {}
+    if DBT_PYTHON_VERSION is not None and DBT_PYTHON_VERSION >= version.parse("1.8.0"):
+        from dbt.contracts.graph.nodes import UnitTestDefinition
+
+        unit_tests = (
+            {
+                "unit_tests": {
+                    # Starting in dbt 1.8 unit test nodes must be defined using the UnitTestDefinition class
+                    unique_id: UnitTestDefinition.from_dict(info)
+                    for unique_id, info in manifest_json["unit_tests"].items()
+                },
+            }
+            if manifest_json.get("unit_tests")
+            else {}
+        )
+
     manifest = Manifest(
-        nodes={
-            unique_id: _DictShim(info)
-            for unique_id, info in manifest_json["nodes"].items()  # type: ignore
-        },
+        nodes={unique_id: _DictShim(info) for unique_id, info in manifest_json["nodes"].items()},
         sources={
             unique_id: _DictShim(info)
             for unique_id, info in manifest_json["sources"].items()  # type: ignore
@@ -272,14 +152,38 @@ def select_unique_ids_from_manifest(
         **(  # type: ignore
             {
                 "semantic_models": {
+                    # Semantic model nodes must be defined using the SemanticModel class
+                    unique_id: SemanticModel.from_dict(info)
+                    for unique_id, info in manifest_json["semantic_models"].items()
+                },
+            }
+            if manifest_json.get("semantic_models")
+            else {}
+        ),
+        **(
+            {
+                "saved_queries": {
+                    # Saved query nodes must be defined using the SavedQuery class
+                    unique_id: SavedQuery.from_dict(info)
+                    for unique_id, info in manifest_json["saved_queries"].items()
+                },
+            }
+            if manifest_json.get("saved_queries")
+            else {}
+        ),
+        **(
+            {
+                "selectors": {
                     unique_id: _DictShim(info)
-                    for unique_id, info in manifest_json.get("semantic_models", {}).items()
+                    for unique_id, info in manifest_json["selectors"].items()
                 }
             }
-            if manifest_json.get("semantic_models")
+            if manifest_json.get("selectors")
             else {}
         ),
+        **unit_tests,
     )
+
     child_map = manifest_json["child_map"]
 
     graph = graph_selector.Graph(DiGraph(incoming_graph_data=child_map))
@@ -291,32 +195,30 @@ def select_unique_ids_from_manifest(
             "WARN_ERROR": True,
         }
     )
-    parsed_spec: SelectionSpec = graph_cli.parse_union([select], True)
+
+    if selector:
+        # must parse all selectors to handle dependencies, then grab the specific selector
+        # that was specified
+        result = graph_cli.parse_from_selectors_definition(
+            source=SelectorFile.from_dict({"selectors": manifest.selectors.values()})
+        )
+        if selector not in result:
+            raise ValueError(f"Selector `{selector}` not found in manifest.")
+        parsed_spec: SelectionSpec = cast("SelectionSpec", result[selector]["definition"])
+    else:
+        parsed_spec: SelectionSpec = graph_cli.parse_union([select], True)
 
     if exclude:
         parsed_exclude_spec = graph_cli.parse_union([exclude], False)
         parsed_spec = graph_cli.SelectionDifference(components=[parsed_spec, parsed_exclude_spec])
 
     # execute this selection against the graph
-    selector = graph_selector.NodeSelector(graph, manifest)
-    selected, _ = selector.select_nodes(parsed_spec)
+    node_selector = graph_selector.NodeSelector(graph, manifest)
+    selected, _ = node_selector.select_nodes(parsed_spec)
     return selected
 
 
-def get_dbt_resource_props_by_dbt_unique_id_from_manifest(
-    manifest: Mapping[str, Any],
-) -> Mapping[str, Mapping[str, Any]]:
-    """A mapping of a dbt node's unique id to the node's dictionary representation in the manifest."""
-    return {
-        **manifest["nodes"],
-        **manifest["sources"],
-        **manifest["exposures"],
-        **manifest["metrics"],
-        **manifest.get("semantic_models", {}),
-    }
-
-
-def _set_flag_attrs(kvs: Dict[str, Any]):
+def _set_flag_attrs(kvs: dict[str, Any]):
     from dbt.flags import get_flag_dict, set_flags
 
     new_flags = Namespace()

dagster_dbt/version.py

@@ -1 +1 @@
-__version__ = "0.23.3"
+__version__ = "0.28.4"

dagster_dbt-0.28.4.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: dagster-dbt
+Version: 0.28.4
+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.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10,<3.14
+License-File: LICENSE
+Requires-Dist: dagster==1.12.4
+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]<28.1.0
+Requires-Dist: typer>=0.9.0
+Requires-Dist: packaging
+Provides-Extra: test-bare
+Requires-Dist: pytest-rerunfailures; extra == "test-bare"
+Requires-Dist: pytest-order; extra == "test-bare"
+Provides-Extra: test
+Requires-Dist: pytest-rerunfailures; extra == "test"
+Requires-Dist: pytest-order; extra == "test"
+Requires-Dist: dagster-duckdb; extra == "test"
+Requires-Dist: dagster-duckdb-pandas; extra == "test"
+Requires-Dist: dbt-duckdb<1.9.2; extra == "test"
+Requires-Dist: duckdb<1.4.0; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

dagster_dbt-0.28.4.dist-info/RECORD

@@ -0,0 +1,59 @@
+dagster_dbt/__init__.py,sha256=rlPCxCzovXNDiqXBUEcgNVHjZrXQXwcX3kwUhe_69C4,4708
+dagster_dbt/asset_decorator.py,sha256=OFFjhmDQO6dK8N3U7VQF7gergswkIS3eHnMRwAe2BZY,14892
+dagster_dbt/asset_specs.py,sha256=2EdWIhY2QZhtGXM7N-kkkeK3ClnGgYX7ayRi_X11cLg,2741
+dagster_dbt/asset_utils.py,sha256=HMy-_ifUG7vtsUU0lGaPum99Wn6NXEOjIfg4nW0sw7U,46657
+dagster_dbt/compat.py,sha256=lqzGonzQE7Lb825yRqUaQPXeNQp8umAR4LqyD6COXdc,3609
+dagster_dbt/dagster_dbt_translator.py,sha256=skUpl7NxG7ysDfDOs1pSq1c9-ciByN7LrGvO0ZsC4W4,30274
+dagster_dbt/dbt_core_version.py,sha256=w1P62qDdbApXKv0XvUNr2p7FlwiW68csugsNaqmjNjM,38
+dagster_dbt/dbt_manifest.py,sha256=q10Qq1whh-dLfWtFbTYXYbqBVCf0oU8T1yRPyy9ASw0,1307
+dagster_dbt/dbt_manifest_asset_selection.py,sha256=KSEHcVdtfFZaEqSQDUsAx8H8BQe62jZxAOE_CLtwVlI,5072
+dagster_dbt/dbt_project.py,sha256=HtUuNYbKMAPWqTOPgPeJK4u6b1nKyqHrRNB8sYwOWVw,12203
+dagster_dbt/dbt_project_manager.py,sha256=d4Jq5D5x4ElUOGVG-enlhYr0GMLgC-8uL3FegVHNAE0,6047
+dagster_dbt/dbt_version.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dagster_dbt/errors.py,sha256=a8xag0tjh8OQVkiL10_uwY4hkAgRCH6HtTGaZxIbXZI,1073
+dagster_dbt/freshness_builder.py,sha256=DHAC3AGWAwIA7psDf72R0t5p8NjxDytGU9g5xnca1hc,6395
+dagster_dbt/metadata_set.py,sha256=lqjASYoYeM_Ey6r8UsPUkRMwmuAIfFCFvkNm0xW5xTg,512
+dagster_dbt/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
+dagster_dbt/utils.py,sha256=gT6xO7buRolkhc2fa5ySUPfD1eXo3e6RJWZAKkM6yFo,8513
+dagster_dbt/version.py,sha256=le8GUWDg2-I-aN9BEcWW_cGqOJzU27CUKxY6F59kr5k,23
+dagster_dbt/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dagster_dbt/cli/app.py,sha256=9oBx85uzAkMtBdV39vNm5rxuAGPVYzzDUs6Ek-KL0XY,13516
+dagster_dbt/cloud/__init__.py,sha256=8WKaLuPl_pUG9Cv78GW782vrWQfqK8QtAWegkTxA9r4,441
+dagster_dbt/cloud/asset_defs.py,sha256=4mdXd3tiGd9OPBBF6xvH81DZhcyGL9pAw3WH8dB7Qu8,29311
+dagster_dbt/cloud/cli.py,sha256=VnKzBjn-BPpjn4nPZm5xSrboAKpRhlCa-4IxsN1ROCo,4525
+dagster_dbt/cloud/ops.py,sha256=rsU4qPCRUUzeHRInZph7YEz_iynwu_KidO5vMAYHX5E,4615
+dagster_dbt/cloud/resources.py,sha256=AWW3VTBS6zrSKeDjMJovbnu54sKena93FoZle6ZSSq8,31747
+dagster_dbt/cloud/types.py,sha256=gsigGlKjR3gLePppiYX09S2vx-0PyPvH7AkzOphDSMA,2886
+dagster_dbt/cloud/utils.py,sha256=NnPxHp3r2cpJ0Vi1Gt4eBmBlNbAhdwaR7GUZRkFsLRc,7158
+dagster_dbt/cloud_v2/__init__.py,sha256=9NjPjqm8ytsKiogiW9cUpHgQFaht1q6g_3K7KSKtzsU,471
+dagster_dbt/cloud_v2/asset_decorator.py,sha256=wHL77K2NXvnU0PDEsqyqpiRX1yp1cuQiit1oxRpNY3s,3141
+dagster_dbt/cloud_v2/cli_invocation.py,sha256=EX2a0G7HIlOJBES-Lf3DIp0y1L1vGeiO3ms1a0F9tWc,2235
+dagster_dbt/cloud_v2/client.py,sha256=V7UsepwHteJiEhQ8XT-lzFV-xDlspzVDgMJDxd6FLEg,16674
+dagster_dbt/cloud_v2/resources.py,sha256=ENzllq2rJlD4Tb3_9JTsMVsoBjyKBs28543-L3lfxLU,16925
+dagster_dbt/cloud_v2/run_handler.py,sha256=rLzCMmqX7H6Eos19e5BW8ZYwmfh6F0DSwZOpDtZl-NM,9301
+dagster_dbt/cloud_v2/sensor_builder.py,sha256=8mAm-1ZFvoiVVdxSkSQbMxg18aQUY5kazur7nBVgotM,10446
+dagster_dbt/cloud_v2/types.py,sha256=dI-NIguj582LwTTMXdY5r0U4-INDn9anNy-ciGuEc1s,4136
+dagster_dbt/components/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dagster_dbt/components/dbt_project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dagster_dbt/components/dbt_project/component.py,sha256=IGjNWN7FdyFRxenli-wCI56fMqGfYyhvpZfMH9-EZiE,20599
+dagster_dbt/components/dbt_project/scaffolder.py,sha256=QVnHbDoGtCHXzEUYC9Z3PAvLuJ0A0EecpV2MsBPn7TQ,2922
+dagster_dbt/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dagster_dbt/core/dbt_cli_event.py,sha256=Yqr-UuzFF7jIcI4KRAmiAhGTX9Ay0tIMN2NaJegsrJQ,25203
+dagster_dbt/core/dbt_cli_invocation.py,sha256=lJLoRvy630xUAEdnH76yl5PJ98-OsLx06l813XjzZOM,17505
+dagster_dbt/core/dbt_event_iterator.py,sha256=IL3QsVUDMfGk04SFTkrVEfbbYu745Kn8OyMQlrlHxIE,16953
+dagster_dbt/core/resource.py,sha256=1qIEneW2aZYeArF5w_QV4-Xmf7Kp9kpGaQaxUlL3ZZs,30851
+dagster_dbt/core/utils.py,sha256=ciXjLhFTNVTyDtVWP4Kjee0LWZkIuVJOltvlv0COzDo,577
+dagster_dbt/include/__init__.py,sha256=8ujr-ROlJ5x64POs-bH-0zfjZ2QHx-FgKUZAvAFbSs8,89
+dagster_dbt/include/pyproject.toml.jinja,sha256=_BbC3zmV6ajtGnDMesyut0Yl0Fc7bY-F887KTIKMm1o,661
+dagster_dbt/include/setup.py.jinja,sha256=N3NjYuXvWmaY8bj5GftVxVvImDUGC4YbFc_MdP1-quA,618
+dagster_dbt/include/scaffold/__init__.py.jinja,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dagster_dbt/include/scaffold/assets.py.jinja,sha256=JImqnDUP5ewy8RVti4IuXL70yJnoke54dMuZ3G8Wlx8,562
+dagster_dbt/include/scaffold/definitions.py.jinja,sha256=Hou7emwkEeh5YXTdqjYFrAc2SK-Q6MgTNsQOKA_Vy3s,364
+dagster_dbt/include/scaffold/project.py.jinja,sha256=YNtkT5Hq4VbGw-b7QcxdelhXsesIKORwVuBFGFdfeUs,432
+dagster_dbt/include/scaffold/schedules.py.jinja,sha256=Xua_VtPjYFc498A5uaBGQ36GwV1gqciO4P3D8Yt9M-Y,413
+dagster_dbt-0.28.4.dist-info/licenses/LICENSE,sha256=4lsMW-RCvfVD4_F57wrmpe3vX1xwUk_OAKKmV_XT7Z0,11348
+dagster_dbt-0.28.4.dist-info/METADATA,sha256=yNSxqahe2ufGcj2pOBVNZXED1-AD-RQ51l4epQZkg9g,1579
+dagster_dbt-0.28.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dagster_dbt-0.28.4.dist-info/entry_points.txt,sha256=pbv0tVoTB7cByG-noE8rC6atvthh64qBaTo7PkQ9HbM,163
+dagster_dbt-0.28.4.dist-info/top_level.txt,sha256=hoOwFvw9OpJUN1azE6UVHcxMKqhUwR_BTN0Ay-iKUDA,12
+dagster_dbt-0.28.4.dist-info/RECORD,,

{dagster_dbt-0.23.3.dist-info → dagster_dbt-0.28.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{dagster_dbt-0.23.3.dist-info → dagster_dbt-0.28.4.dist-info}/entry_points.txt

@@ -1,3 +1,6 @@
 [console_scripts]
 dagster-dbt = dagster_dbt.cli.app:app
 dagster-dbt-cloud = dagster_dbt.cloud.cli:app
+
+[dagster_dg_cli.registry_modules]
+dagster_dbt = dagster_dbt

{dagster_dbt-0.23.3.dist-info → dagster_dbt-0.28.4.dist-info/licenses}/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2023 Dagster Labs, Inc".
+   Copyright 2025 Dagster Labs, Inc.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.