flyteplugins-dbt 0.0.0a0__py3-none-any.whl

flyteplugins/dbt/__init__.py

@@ -0,0 +1,12 @@
+from flyteplugins.dbt.resolver import DbtTaskResolver
+from flyteplugins.dbt.runner import DbtEventCallback, DbtInvocationError, DbtNodeResult, invoke_dbt
+from flyteplugins.dbt.task import DbtTask
+
+__all__ = [
+    "DbtEventCallback",
+    "DbtInvocationError",
+    "DbtNodeResult",
+    "DbtTask",
+    "DbtTaskResolver",
+    "invoke_dbt",
+]

flyteplugins/dbt/resolver.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import json
+import pathlib
+
+from flyte._task import TaskTemplate
+
+
+class DbtTaskResolver:
+    """Reconstructs a DbtTask in the remote task container."""
+
+    @property
+    def import_path(self) -> str:
+        return "flyteplugins.dbt.resolver.DbtTaskResolver"
+
+    def load_task(self, loader_args: list[str]) -> TaskTemplate:
+        from flyteplugins.dbt.task import DbtTask
+
+        it = iter(loader_args)
+        args_dict: dict[str, str] = {}
+        for key in it:
+            try:
+                args_dict[key] = next(it)
+            except StopIteration:
+                raise ValueError(f"Odd number of loader args: missing value for key '{key}'")
+
+        callbacks = json.loads(args_dict.get("callbacks_json", "[]"))
+
+        return DbtTask(
+            name=args_dict["name"],
+            task_environment=None,
+            project_dir=args_dict.get("project_dir") or None,
+            profiles_dir=args_dict.get("profiles_dir") or None,
+            profile=args_dict.get("profile") or None,
+            target_path=args_dict.get("target_path") or None,
+            callbacks=callbacks,
+        )
+
+    def loader_args(self, task: TaskTemplate, root_dir: pathlib.Path | None = None) -> list[str]:
+        from flyteplugins.dbt.runner import callback_import_paths
+        from flyteplugins.dbt.task import DbtTask
+
+        if not isinstance(task, DbtTask):
+            raise TypeError(f"DbtTaskResolver only handles DbtTask, got {type(task)}")
+
+        callback_paths = callback_import_paths(task.callbacks, source_dir=root_dir)
+
+        return [
+            "name",
+            task.name,
+            "project_dir",
+            task.project_dir or "",
+            "profiles_dir",
+            task.profiles_dir or "",
+            "profile",
+            task.profile or "",
+            "target_path",
+            task.target_path or "",
+            "callbacks_json",
+            json.dumps(callback_paths),
+        ]

flyteplugins/dbt/runner.py

@@ -0,0 +1,308 @@
+from __future__ import annotations
+
+import html
+import importlib
+import pathlib
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from typing import Any, Optional
+
+_MAX_DBT_INVOCATION_ERROR_RESULTS = 10
+
+DbtEventCallback = Callable[[Any], None]
+
+
+@dataclass
+class DbtNodeResult:
+    """Small serializable summary of one dbt node result."""
+
+    unique_id: str
+    name: str
+    resource_type: str
+    status: str
+    message: Optional[str] = None
+    failures: Optional[int] = None
+    execution_time: Optional[float] = None
+    relation_name: Optional[str] = None
+
+
+class DbtInvocationError(RuntimeError):
+    """Raised when dbt finishes cleanly but reports failed node results."""
+
+    def __init__(self, cli_args: list[str], results: list[DbtNodeResult]):
+        self.cli_args = cli_args
+        self.results = results
+        super().__init__(_format_dbt_invocation_error(cli_args, results))
+
+
+def _format_dbt_invocation_error(cli_args: list[str], results: list[DbtNodeResult]) -> str:
+    if not results:
+        return f"dbt invocation failed for cli_args={cli_args!r}"
+
+    failed_results = [result for result in results if result.status.lower() not in {"pass", "success"}]
+    if not failed_results:
+        failed_results = results
+
+    node_summaries = []
+    for result in failed_results[:_MAX_DBT_INVOCATION_ERROR_RESULTS]:
+        details = [f"status={result.status!r}"]
+        if result.failures is not None:
+            details.append(f"failures={result.failures}")
+        if result.message:
+            details.append(f"message={result.message!r}")
+        node_summaries.append(f"{result.unique_id or result.name} ({', '.join(details)})")
+
+    suffix = ""
+    if len(failed_results) > _MAX_DBT_INVOCATION_ERROR_RESULTS:
+        suffix = f"; and {len(failed_results) - _MAX_DBT_INVOCATION_ERROR_RESULTS} more"
+
+    return f"dbt invocation failed for cli_args={cli_args!r}: {', '.join(node_summaries)}{suffix}"
+
+
+def _node_name(node: Any) -> str:
+    return str(getattr(node, "name", "") or getattr(node, "unique_id", ""))
+
+
+def _node_resource_type(node: Any) -> str:
+    resource_type = getattr(node, "resource_type", "")
+    if hasattr(resource_type, "value"):
+        return str(resource_type.value)
+    return str(resource_type)
+
+
+def _summarize_node_result(result: Any) -> DbtNodeResult:
+    node = getattr(result, "node", None)
+    return DbtNodeResult(
+        unique_id=str(getattr(result, "unique_id", "") or getattr(node, "unique_id", "")),
+        name=_node_name(node),
+        resource_type=_node_resource_type(node),
+        status=str(getattr(result, "status", "")),
+        message=getattr(result, "message", None),
+        failures=getattr(result, "failures", None),
+        execution_time=getattr(result, "execution_time", None),
+        relation_name=getattr(result, "relation_name", None),
+    )
+
+
+def _is_node_result(result: Any) -> bool:
+    return hasattr(result, "node") or hasattr(result, "unique_id") or hasattr(result, "status")
+
+
+def _raw_node_results(runner_result: Any) -> list[Any]:
+    raw_results = getattr(runner_result, "result", None)
+    if raw_results is None:
+        return []
+
+    if hasattr(raw_results, "results"):
+        raw_results = raw_results.results
+
+    if isinstance(raw_results, tuple):
+        raw_results = list(raw_results)
+    elif not isinstance(raw_results, list):
+        raw_results = []
+
+    return raw_results
+
+
+def summarize_dbt_runner_result(runner_result: Any) -> list[DbtNodeResult]:
+    return [_summarize_node_result(result) for result in _raw_node_results(runner_result) if _is_node_result(result)]
+
+
+_REPORT_CSS = """
+<style>
+  .dbt-report {
+    font-family: Inter, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+    margin: 0 0 1rem;
+  }
+  .dbt-report h2 {
+    font-size: 1rem;
+    font-weight: 650;
+    margin: 0 0 0.75rem;
+  }
+  .dbt-report table {
+    border-collapse: collapse;
+    font-size: 0.875rem;
+    width: 100%;
+  }
+  .dbt-report th,
+  .dbt-report td {
+    border-bottom: 1px solid #d9dee7;
+    padding: 0.5rem 0.625rem;
+    text-align: left;
+    vertical-align: top;
+  }
+  .dbt-report th {
+    background: #f7f8fa;
+    color: #394150;
+    font-weight: 650;
+  }
+  .dbt-report .status-pass,
+  .dbt-report .status-success {
+    color: #087443;
+    font-weight: 650;
+  }
+  .dbt-report .status-fail,
+  .dbt-report .status-error {
+    color: #b42318;
+    font-weight: 650;
+  }
+  .dbt-report .muted {
+    color: #697386;
+  }
+</style>
+""".strip()
+
+
+def _html_cell(value: Any) -> str:
+    if value is None or value == "":
+        return '<span class="muted">-</span>'
+    return html.escape(str(value))
+
+
+def dbt_results_to_html(results: list[DbtNodeResult]) -> str:
+    rows = []
+    for result in results:
+        status = result.status.lower()
+        status_class = "status-" + "".join(ch if ch.isalnum() else "-" for ch in status)
+        rows.append(
+            "<tr>"
+            f"<td>{_html_cell(result.name or result.unique_id)}</td>"
+            f"<td>{_html_cell(result.resource_type)}</td>"
+            f'<td class="{html.escape(status_class)}">{_html_cell(result.status)}</td>'
+            f"<td>{_html_cell(result.failures)}</td>"
+            f"<td>{_html_cell(result.execution_time)}</td>"
+            f"<td>{_html_cell(result.message)}</td>"
+            "</tr>"
+        )
+
+    body = (
+        "<p>No dbt node results were returned for this command.</p>"
+        if not rows
+        else (
+            "<table>"
+            "<thead><tr>"
+            "<th>Node</th><th>Type</th><th>Status</th><th>Failures</th><th>Execution Time</th><th>Message</th>"
+            "</tr></thead>"
+            f"<tbody>{''.join(rows)}</tbody>"
+            "</table>"
+        )
+    )
+    return f'{_REPORT_CSS}<section class="dbt-report"><h2>dbt node results</h2>{body}</section>'
+
+
+def write_dbt_report(results: list[DbtNodeResult]) -> None:
+    try:
+        import flyte.report
+
+        flyte.report.get_tab("dbt").replace(dbt_results_to_html(results))
+        flyte.report.flush()
+    except Exception:
+        from flyte._logging import logger
+
+        logger.debug("Failed to write dbt report.", exc_info=True)
+
+
+def callback_import_path(callback: DbtEventCallback, source_dir: pathlib.Path | None = None) -> str:
+    name = getattr(callback, "__name__", None)
+    qualname = getattr(callback, "__qualname__", None)
+    if not qualname or "<locals>" in qualname or name == "<lambda>":
+        raise ValueError("dbt callbacks used in DbtTask must be importable functions when running remotely.")
+
+    if source_dir is None:
+        module = getattr(callback, "__module__", None)
+        if not module:
+            raise ValueError("dbt callbacks used in DbtTask must be importable functions when running remotely.")
+    else:
+        from flyte._module import extract_obj_module
+
+        module, _ = extract_obj_module(callback, source_dir=source_dir)
+
+    import_path = f"{module}:{qualname}"
+    if callback.__module__ == "__main__" and source_dir is not None:
+        # The workflow file is imported under its file name in the container.
+        # Importing it here would load a second copy, so identity cannot match.
+        return import_path
+    try:
+        resolved_callback = import_callback(import_path)
+    except (AttributeError, ModuleNotFoundError):
+        if source_dir is not None:
+            return import_path
+        raise
+    if resolved_callback is not callback:
+        raise ValueError(f"dbt callback {import_path!r} must resolve to the original callback object when imported.")
+    return import_path
+
+
+def _import_dotted_path(import_path: str) -> Any:
+    parts = import_path.split(".")
+    for module_end in range(len(parts), 0, -1):
+        module_name = ".".join(parts[:module_end])
+        try:
+            value: Any = importlib.import_module(module_name)
+        except ModuleNotFoundError:
+            continue
+        for attr in parts[module_end:]:
+            value = getattr(value, attr)
+        return value
+    raise ModuleNotFoundError(f"No module found in dbt callback import path: {import_path!r}")
+
+
+def import_callback(import_path: str) -> DbtEventCallback:
+    if ":" in import_path:
+        module_name, attr_path = import_path.split(":", 1)
+        if not module_name or not attr_path:
+            raise ValueError(f"Invalid dbt callback import path: {import_path!r}")
+
+        value: Any = importlib.import_module(module_name)
+        for attr in attr_path.split("."):
+            value = getattr(value, attr)
+    else:
+        value = _import_dotted_path(import_path)
+
+    if not callable(value):
+        raise TypeError(f"dbt callback import path does not resolve to a callable: {import_path!r}")
+    return value
+
+
+def resolve_callbacks(callbacks: Sequence[DbtEventCallback | str] | None) -> list[DbtEventCallback]:
+    resolved = []
+    for callback in callbacks or []:
+        if isinstance(callback, str):
+            resolved.append(import_callback(callback))
+        else:
+            resolved.append(callback)
+    return resolved
+
+
+def callback_import_paths(
+    callbacks: Sequence[DbtEventCallback | str] | None,
+    source_dir: pathlib.Path | None = None,
+) -> list[str]:
+    paths = []
+    for callback in callbacks or []:
+        if isinstance(callback, str):
+            import_callback(callback)
+            paths.append(callback)
+        else:
+            paths.append(callback_import_path(callback, source_dir=source_dir))
+    return paths
+
+
+def invoke_dbt(
+    cli_args: list[str],
+    callbacks: Sequence[DbtEventCallback | str] | None = None,
+) -> list[DbtNodeResult]:
+    """Run exactly one dbtRunner invocation and return a serializable summary."""
+    from dbt.cli.main import dbtRunner
+
+    args = list(cli_args)
+    event_callbacks = resolve_callbacks(callbacks)
+
+    runner_result = dbtRunner(callbacks=event_callbacks).invoke(args)
+    results = summarize_dbt_runner_result(runner_result)
+    write_dbt_report(results)
+    if not runner_result.success:
+        if runner_result.exception is not None:
+            raise runner_result.exception
+        raise DbtInvocationError(args, results)
+    return results

flyteplugins/dbt/task.py

@@ -0,0 +1,251 @@
+from __future__ import annotations
+
+import inspect
+import shlex
+import weakref
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Optional
+
+from flyte.extend import RuntimeTaskTemplate
+from flyte.models import NativeInterface
+
+from flyteplugins.dbt.runner import (
+    DbtEventCallback,
+    DbtNodeResult,
+    invoke_dbt,
+)
+
+if TYPE_CHECKING:
+    from flyte import CacheRequest, TaskEnvironment
+
+
+_MANAGED_DBT_FLAGS = {
+    "--project-dir",
+    "--profiles-dir",
+    "--profile",
+    "--target",
+    "--target-path",
+    "--select",
+    "--exclude",
+}
+
+
+def _validate_cache(cache: CacheRequest) -> CacheRequest:
+    from flyte._cache.cache import cache_from_request
+
+    if cache_from_request(cache).behavior != "disable":
+        raise ValueError("DbtTask does not support caching yet. Set cache='disable' or remove cache configuration.")
+    return cache
+
+
+def _validate_project_dir(project_dir: str | None) -> None:
+    if project_dir is None:
+        return
+    if not (Path(project_dir) / "dbt_project.yml").exists():
+        raise ValueError(f"dbt project_dir {project_dir!r} must contain a dbt_project.yml file.")
+
+
+def _validate_extra_args(extra_args: list[str] | None) -> list[str]:
+    args = list(extra_args or [])
+    managed_flags = sorted(set(args) & _MANAGED_DBT_FLAGS)
+    if managed_flags:
+        raise ValueError("dbt extra_args cannot include flags managed by DbtTask: " + ", ".join(managed_flags))
+    return args
+
+
+def _parse_command(command: str | list[str]) -> list[str]:
+    if isinstance(command, str):
+        args = shlex.split(command)
+    else:
+        args = list(command)
+    if not args:
+        raise ValueError("dbt command must include at least one argument.")
+    return args
+
+
+def _build_cli_args(
+    *,
+    command: str | list[str],
+    project_dir: str | None,
+    profiles_dir: str | None,
+    profile: str | None,
+    target_path: str | None,
+    select: list[str] | None,
+    exclude: list[str] | None,
+    target: str | None,
+    extra_args: list[str] | None,
+) -> list[str]:
+    _validate_project_dir(project_dir)
+    args = _parse_command(command)
+    if project_dir:
+        args.extend(["--project-dir", project_dir])
+    if profiles_dir:
+        args.extend(["--profiles-dir", profiles_dir])
+    if profile:
+        args.extend(["--profile", profile])
+    if target:
+        args.extend(["--target", target])
+    if target_path:
+        args.extend(["--target-path", target_path])
+    if select:
+        args.extend(["--select", *select])
+    if exclude:
+        args.extend(["--exclude", *exclude])
+    args.extend(_validate_extra_args(extra_args))
+    return args
+
+
+@dataclass(kw_only=True)
+class DbtTask(RuntimeTaskTemplate):
+    """A Flyte task that maps one dbtRunner.invoke(...) call to one task."""
+
+    project_dir: str | None = None
+    profiles_dir: str | None = None
+    profile: str | None = None
+    target_path: str | None = None
+    callbacks: list[DbtEventCallback | str] = field(default_factory=list)
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        task_environment: Optional[TaskEnvironment] = None,
+        project_dir: str | None = None,
+        profiles_dir: str | None = None,
+        profile: str | None = None,
+        target_path: str | None = None,
+        callbacks: list[DbtEventCallback | str] | None = None,
+        **kwargs: Any,
+    ):
+        project_dir = kwargs.pop("project_dir", project_dir)
+        profiles_dir = kwargs.pop("profiles_dir", profiles_dir)
+        profile = kwargs.pop("profile", profile)
+        target_path = kwargs.pop("target_path", target_path)
+        self.project_dir = project_dir
+        self.profiles_dir = profiles_dir
+        self.profile = profile
+        self.target_path = target_path
+        self.callbacks = list(callbacks or [])
+        from flyteplugins.dbt.resolver import DbtTaskResolver
+
+        task_name = f"{task_environment.name}.{name}" if task_environment else name
+        interface = kwargs.pop(
+            "interface",
+            NativeInterface(
+                inputs={
+                    "command": (str | list[str], inspect.Parameter.empty),
+                    "select": (Optional[list[str]], None),
+                    "exclude": (Optional[list[str]], None),
+                    "target": (Optional[str], None),
+                    "extra_args": (Optional[list[str]], None),
+                },
+                outputs={"results": list[DbtNodeResult]},
+            ),
+        )
+        parent_env = kwargs.pop("parent_env", weakref.ref(task_environment) if task_environment else None)
+        parent_env_name = kwargs.pop("parent_env_name", task_environment.name if task_environment else None)
+        cache = kwargs.pop("cache", task_environment.cache if task_environment else "disable")
+        cache = _validate_cache(cache)
+
+        super().__init__(
+            name=task_name,
+            interface=interface,
+            image=kwargs.pop("image", task_environment.image if task_environment else "auto"),
+            resources=kwargs.pop("resources", task_environment.resources if task_environment else None),
+            cache=cache,
+            reusable=kwargs.pop("reusable", task_environment.reusable if task_environment else None),
+            env_vars=kwargs.pop("env_vars", task_environment.env_vars if task_environment else None),
+            secrets=kwargs.pop("secrets", task_environment.secrets if task_environment else None),
+            service_account=kwargs.pop(
+                "service_account", task_environment.service_account if task_environment else None
+            ),
+            pod_template=kwargs.pop("pod_template", task_environment.pod_template if task_environment else None),
+            report=kwargs.pop("report", False),
+            queue=kwargs.pop("queue", task_environment.queue if task_environment else None),
+            interruptible=kwargs.pop("interruptible", task_environment.interruptible if task_environment else False),
+            short_name=kwargs.pop("short_name", name if task_environment else ""),
+            task_type=kwargs.pop("task_type", "dbt"),
+            _call_as_synchronous=kwargs.pop("_call_as_synchronous", True),
+            parent_env=parent_env,
+            parent_env_name=parent_env_name,
+            task_resolver=kwargs.pop("task_resolver", DbtTaskResolver()),
+            **kwargs,
+        )
+
+        if task_environment is not None:
+            task_environment._tasks[task_name] = self
+
+    def forward(self, *args: Any, **kwargs: Any) -> list[DbtNodeResult]:
+        kwargs = self.interface.convert_to_kwargs(*args, **kwargs)
+        cli_args = _build_cli_args(
+            command=kwargs["command"],
+            project_dir=self.project_dir,
+            profiles_dir=self.profiles_dir,
+            profile=self.profile,
+            target_path=self.target_path,
+            select=kwargs.get("select"),
+            exclude=kwargs.get("exclude"),
+            target=kwargs.get("target"),
+            extra_args=kwargs.get("extra_args"),
+        )
+        return invoke_dbt(
+            cli_args,
+            callbacks=self.callbacks,
+        )
+
+    async def aio(
+        self,
+        command: str | list[str],
+        *,
+        select: list[str] | None = None,
+        exclude: list[str] | None = None,
+        target: str | None = None,
+        extra_args: list[str] | None = None,
+    ) -> list[DbtNodeResult]:
+        return await super().aio(
+            command=command,
+            select=select,
+            exclude=exclude,
+            target=target,
+            extra_args=extra_args,
+        )
+
+    def __call__(
+        self,
+        command: str | list[str],
+        *,
+        select: list[str] | None = None,
+        exclude: list[str] | None = None,
+        target: str | None = None,
+        extra_args: list[str] | None = None,
+    ) -> list[DbtNodeResult]:
+        return super().__call__(
+            command=command,
+            select=select,
+            exclude=exclude,
+            target=target,
+            extra_args=extra_args,
+        )
+
+    async def execute(self, *args: Any, **kwargs: Any) -> list[DbtNodeResult]:
+        kwargs = self.interface.convert_to_kwargs(*args, **kwargs)
+        cli_args = _build_cli_args(
+            command=kwargs["command"],
+            project_dir=self.project_dir,
+            profiles_dir=self.profiles_dir,
+            profile=self.profile,
+            target_path=self.target_path,
+            select=kwargs.get("select"),
+            exclude=kwargs.get("exclude"),
+            target=kwargs.get("target"),
+            extra_args=kwargs.get("extra_args"),
+        )
+
+        from flyte._utils.asyncify import run_sync_in_thread
+
+        return await run_sync_in_thread(
+            invoke_dbt,
+            cli_args,
+            self.callbacks,
+        )

flyteplugins_dbt-0.0.0a0.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: flyteplugins-dbt
+Version: 0.0.0a0
+Summary: dbt task plugin for flyte
+Author-email: Jan Fiedler <jan@union.ai>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: dbt-core
+Requires-Dist: flyte
+
+# flyteplugins-dbt
+
+Run dbt CLI invocations as Flyte v2 tasks.
+
+`DbtTask` maps one `dbtRunner.invoke(...)` call to one Flyte task. Project-level dbt paths are configured on the task, and invocation-level options are task inputs.
+
+Install the dbt adapter required by your project, such as `dbt-duckdb`, `dbt-bigquery`, or `dbt-snowflake`, in the task image alongside this plugin.
+
+```python
+from pathlib import Path
+
+import flyte
+from flyteplugins.dbt import DbtTask
+
+DBT_PROJECT_DIR = "jaffle_shop"
+DBT_PROFILES_DIR = "dbt-profiles"
+
+env = flyte.TaskEnvironment(
+    name="dbt",
+    image=flyte.Image.from_debian_base()
+    .with_requirements("requirements.txt")
+    .with_source_folder(Path(DBT_PROJECT_DIR))
+    .with_source_folder(Path(DBT_PROFILES_DIR)),
+)
+
+dbt_test = DbtTask(
+    name="dbt-test",
+    task_environment=env,
+    project_dir=DBT_PROJECT_DIR,
+    profiles_dir=DBT_PROFILES_DIR,
+    profile=DBT_PROJECT_DIR,
+    report=True,
+)
+
+
+@env.task
+async def main():
+    return await dbt_test.aio(command="test", select=["stg_orders+"], target="prod")
+```
+
+Multi-token dbt commands can be passed as a shell-style string or as explicit tokens:
+
+```python
+await dbt_test.aio(command="docs generate")
+await dbt_test.aio(command=["source", "freshness"])
+```
+
+The task returns a list of `DbtNodeResult` values summarized from dbt node results. If dbt reports failure, the task raises the dbt exception when one is available, otherwise it raises `DbtInvocationError` with the summarized node results.
+
+When `report=True`, the task writes a dbt report tab with node names, resource types, statuses, failures, execution times, and messages. The report is written before dbt failures are raised, so failed dbt runs can still show succeeded and failed node results.
+
+## Event callbacks
+
+Custom dbt event callbacks can be passed to `DbtTask`.
+
+```python
+def log_dbt_node(event):
+    data = getattr(event, "data", None)
+    node_info = getattr(data, "node_info", None)
+    if node_info is None:
+        return
+
+    node_name = getattr(node_info, "node_name", None)
+    node_status = getattr(node_info, "node_status", None)
+    print(f"dbt node={node_name} status={node_status}")
+
+
+dbt_test = DbtTask(
+    name="dbt-test",
+    task_environment=env,
+    callbacks=[log_dbt_node],
+)
+```
+
+For remote execution, callbacks must be importable functions. Import-path strings are also supported:
+
+```python
+dbt_test = DbtTask(
+    name="dbt-test",
+    task_environment=env,
+    callbacks=["my_project.callbacks.log_dbt_node"],
+)
+```

flyteplugins_dbt-0.0.0a0.dist-info/RECORD

@@ -0,0 +1,8 @@
+flyteplugins/dbt/__init__.py,sha256=xNbFKiTelhEPnkilDGSHmCbacrUHQpRRgZHXPiUGqZw,338
+flyteplugins/dbt/resolver.py,sha256=x7fQUQF0yVE_o9qxSESIO3dctzj04_s2ndTXpEjAPHA,1963
+flyteplugins/dbt/runner.py,sha256=-e-iVP-7sMSCvB9NsQTbT__MC_VysfNrWSW2w98nzko,10125
+flyteplugins/dbt/task.py,sha256=_huzdAx8NHKD2twmKfLBVIijgDVbHPlz2i21GZeQTmA,8822
+flyteplugins_dbt-0.0.0a0.dist-info/METADATA,sha256=7T2LvdlxTSGIj1HkkUeuSibEDjcdczggxQ8Nnbf0Aeo,2768
+flyteplugins_dbt-0.0.0a0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+flyteplugins_dbt-0.0.0a0.dist-info/top_level.txt,sha256=cgd779rPu9EsvdtuYgUxNHHgElaQvPn74KhB5XSeMBE,13
+flyteplugins_dbt-0.0.0a0.dist-info/RECORD,,

flyteplugins_dbt-0.0.0a0.dist-info/WHEEL

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

flyteplugins_dbt-0.0.0a0.dist-info/top_level.txt

@@ -0,0 +1 @@
+flyteplugins