dbt-data-engineering-toolkit-compiler 3.0.1__tar.gz

dbt_data_engineering_toolkit_compiler-3.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Systemizing Solutions and dbt_data_engineering_toolkit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dbt_data_engineering_toolkit_compiler-3.0.1/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: dbt-data-engineering-toolkit-compiler
+Version: 3.0.1
+Summary: Compile BA-authored Excel data products into ODCS and readable dbt projects.
+License-Expression: MIT
+Keywords: dbt,data-contract,data-engineering,odcs,sql
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Typing :: Typed
+Requires-Python: <3.15,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: datacontract-cli[excel]<2,>=1.1.3
+Requires-Dist: dbt-core<2,>=1.10.6
+Requires-Dist: dbt-duckdb<2,>=1.10
+Requires-Dist: duckdb<1.5,>=1.4
+Requires-Dist: openpyxl<4,>=3.1
+Requires-Dist: pydantic<3,>=2.10
+Requires-Dist: PyYAML<7,>=6
+Requires-Dist: sqlfluff<5,>=3.4
+Requires-Dist: sqlfluff-templater-dbt<5,>=3.4
+Provides-Extra: athena
+Requires-Dist: dbt-athena-community<2,>=1.10; extra == "athena"
+Provides-Extra: bigquery
+Requires-Dist: dbt-bigquery<2,>=1.10; extra == "bigquery"
+Provides-Extra: clickhouse
+Requires-Dist: dbt-clickhouse<2,>=1.10; extra == "clickhouse"
+Provides-Extra: databricks
+Requires-Dist: dbt-databricks<2,>=1.10; extra == "databricks"
+Provides-Extra: duckdb
+Requires-Dist: dbt-duckdb<2,>=1.10; extra == "duckdb"
+Requires-Dist: duckdb<1.5,>=1.4; extra == "duckdb"
+Provides-Extra: postgres
+Requires-Dist: dbt-postgres<2,>=1.10; extra == "postgres"
+Provides-Extra: redshift
+Requires-Dist: dbt-redshift<2,>=1.10; extra == "redshift"
+Provides-Extra: snowflake
+Requires-Dist: dbt-snowflake<2,>=1.10; extra == "snowflake"
+Provides-Extra: spark
+Requires-Dist: dbt-spark[PyHive]<2,>=1.10; extra == "spark"
+Provides-Extra: test
+Requires-Dist: pyright<2,>=1.1.390; extra == "test"
+Requires-Dist: pytest<10,>=8; extra == "test"
+Requires-Dist: pytest-cov<8,>=6; extra == "test"
+Requires-Dist: ruff<1,>=0.9; extra == "test"
+Provides-Extra: release
+Requires-Dist: build<2,>=1.2; extra == "release"
+Requires-Dist: bumpver>=2024.1130; extra == "release"
+Dynamic: license-file
+
+# Data Engineering Toolkit compiler
+
+The `det` CLI turns the controlled V2.3.0 official-ODCS Excel superset into
+canonical ODCS, DET execution metadata, and a readable dbt project. It includes
+safe questionnaire-based workbook creation, ODCS/DDL/dbt-to-Excel import and
+merge-safe synchronization, source-schema import, cross-sheet semantic/type
+validation, atomic post-sync generation, Data Contract synchronization, SQLFluff,
+and the isolated `det prove` acceptance flow. Data Contract CLI, dbt Core,
+DuckDB, and SQLFluff are default dependencies.
+
+V2.3.0 makes the visible official `Quality` sheet authoritative, preserves
+advanced per-rule ODCS values, supports eight production warehouse providers, and adds mandatory
+85.01% Python statement coverage. The generated dbt package has 98.53% DuckDB-scoped macro
+implementation coverage plus 100% public-API direct execution coverage and supports dbt Core plus
+Fusion-compatible projects. External resources
+are isolated behind brokers; reusable services interpret workbooks and input
+formats; independent components validate with stable diagnostic codes; and one
+emitter owns each artifact family. The CLI remains a thin exposer over
+`ToolkitApplication`.
+
+## Install
+
+```bash
+python -m pip install dbt-data-engineering-toolkit-compiler==2.3.0
+```
+
+The default installation includes Data Contract CLI, dbt Core, dbt-duckdb,
+DuckDB, and SQLFluff. Install one additional warehouse adapter per deployment
+environment, for example:
+
+```bash
+python -m pip install "dbt-data-engineering-toolkit-compiler[snowflake]"
+```
+
+Supported extras are `athena`, `bigquery`, `clickhouse`, `databricks`,
+`duckdb`, `postgres`, `redshift`, `snowflake`, and `spark`.
+
+## Safe first workbook
+
+```bash
+det workbook build data_product.xlsx --no-input
+det validate data_product.xlsx
+```
+
+The default is blank: it does not add Customer 360 sample data. Use
+`--sample-customer-data` only when you explicitly want the demonstration.
+
+Continue with `det --help` and `det workbook --help`. The source repository's
+root README contains the complete workbook-to-ODCS-to-dbt walkthrough,
+architecture, compatibility matrix, testing definitions, and deployment guide.

dbt_data_engineering_toolkit_compiler-3.0.1/README.md

@@ -0,0 +1,50 @@
+# Data Engineering Toolkit compiler
+
+The `det` CLI turns the controlled V2.3.0 official-ODCS Excel superset into
+canonical ODCS, DET execution metadata, and a readable dbt project. It includes
+safe questionnaire-based workbook creation, ODCS/DDL/dbt-to-Excel import and
+merge-safe synchronization, source-schema import, cross-sheet semantic/type
+validation, atomic post-sync generation, Data Contract synchronization, SQLFluff,
+and the isolated `det prove` acceptance flow. Data Contract CLI, dbt Core,
+DuckDB, and SQLFluff are default dependencies.
+
+V2.3.0 makes the visible official `Quality` sheet authoritative, preserves
+advanced per-rule ODCS values, supports eight production warehouse providers, and adds mandatory
+85.01% Python statement coverage. The generated dbt package has 98.53% DuckDB-scoped macro
+implementation coverage plus 100% public-API direct execution coverage and supports dbt Core plus
+Fusion-compatible projects. External resources
+are isolated behind brokers; reusable services interpret workbooks and input
+formats; independent components validate with stable diagnostic codes; and one
+emitter owns each artifact family. The CLI remains a thin exposer over
+`ToolkitApplication`.
+
+## Install
+
+```bash
+python -m pip install dbt-data-engineering-toolkit-compiler==2.3.0
+```
+
+The default installation includes Data Contract CLI, dbt Core, dbt-duckdb,
+DuckDB, and SQLFluff. Install one additional warehouse adapter per deployment
+environment, for example:
+
+```bash
+python -m pip install "dbt-data-engineering-toolkit-compiler[snowflake]"
+```
+
+Supported extras are `athena`, `bigquery`, `clickhouse`, `databricks`,
+`duckdb`, `postgres`, `redshift`, `snowflake`, and `spark`.
+
+## Safe first workbook
+
+```bash
+det workbook build data_product.xlsx --no-input
+det validate data_product.xlsx
+```
+
+The default is blank: it does not add Customer 360 sample data. Use
+`--sample-customer-data` only when you explicitly want the demonstration.
+
+Continue with `det --help` and `det workbook --help`. The source repository's
+root README contains the complete workbook-to-ODCS-to-dbt walkthrough,
+architecture, compatibility matrix, testing definitions, and deployment guide.

dbt_data_engineering_toolkit_compiler-3.0.1/pyproject.toml

@@ -0,0 +1,122 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dbt-data-engineering-toolkit-compiler"
+version = "3.0.1"
+description = "Compile BA-authored Excel data products into ODCS and readable dbt projects."
+readme = "README.md"
+requires-python = ">=3.11,<3.15"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = ["dbt", "data-contract", "data-engineering", "odcs", "sql"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Environment :: Console",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Database",
+  "Typing :: Typed",
+]
+dependencies = [
+  "datacontract-cli[excel]>=1.1.3,<2",
+  "dbt-core>=1.10.6,<2",
+  "dbt-duckdb>=1.10,<2",
+  "duckdb>=1.4,<1.5",
+  "openpyxl>=3.1,<4",
+  "pydantic>=2.10,<3",
+  "PyYAML>=6,<7",
+  "sqlfluff>=3.4,<5",
+  "sqlfluff-templater-dbt>=3.4,<5",
+]
+
+[project.optional-dependencies]
+athena = ["dbt-athena-community>=1.10,<2"]
+bigquery = ["dbt-bigquery>=1.10,<2"]
+clickhouse = ["dbt-clickhouse>=1.10,<2"]
+databricks = ["dbt-databricks>=1.10,<2"]
+duckdb = ["dbt-duckdb>=1.10,<2", "duckdb>=1.4,<1.5"]
+postgres = ["dbt-postgres>=1.10,<2"]
+redshift = ["dbt-redshift>=1.10,<2"]
+snowflake = ["dbt-snowflake>=1.10,<2"]
+spark = ["dbt-spark[PyHive]>=1.10,<2"]
+test = [
+  "pyright>=1.1.390,<2",
+  "pytest>=8,<10",
+  "pytest-cov>=6,<8",
+  "ruff>=0.9,<1",
+]
+release = ["build>=1.2,<2", "bumpver>=2024.1130"]
+
+[project.scripts]
+det = "dbt_data_engineering_toolkit_compiler.exposers.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+dbt_data_engineering_toolkit_compiler = ["py.typed", "resources/*.yml", "resources/*.xlsx"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q --strict-config --strict-markers"
+
+[tool.coverage.run]
+source = ["dbt_data_engineering_toolkit_compiler"]
+
+[tool.coverage.report]
+fail_under = 80
+show_missing = true
+skip_covered = true
+exclude_also = [
+  "if TYPE_CHECKING:",
+  "if __name__ == .__main__.:",
+  "raise NotImplementedError",
+]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "I", "B"]
+
+[tool.pyright]
+include = ["src"]
+pythonVersion = "3.11"
+typeCheckingMode = "basic"
+reportMissingTypeStubs = false
+
+[tool.bumpver]
+current_version = "3.0.1"
+version_pattern = "MAJOR.MINOR.PATCH"
+commit_message = "bump version {old_version} -> {new_version}"
+tag_message = "v{new_version}"
+tag_scope = "default"
+pre_commit_hook = ""
+post_commit_hook = ""
+commit = true
+tag = true
+push = true
+
+[tool.bumpver.file_patterns]
+"pyproject.toml" = [
+  '^version = "{version}"',
+  '^current_version = "{version}"',
+]
+"src/dbt_data_engineering_toolkit_compiler/version.py" = [
+  '^COMPILER_VERSION = "{version}"',
+  '^WORKBOOK_SCHEMA_VERSION = "{version}"',
+  '^DEFAULT_TOOLKIT_REVISION = "v{version}"',
+  '^DET_SPEC_VERSION = "det/v{version}"',
+  '^OPERATOR_REGISTRY_VERSION = "{version}"',
+]
+"../dbt/dbt_project.yml" = [
+  '^version: {version}$',
+]
+"../aliases/de_toolkit/dbt_project.yml" = [
+  '^version: {version}$',
+]

dbt_data_engineering_toolkit_compiler-3.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dbt_data_engineering_toolkit_compiler-3.0.1/src/dbt_data_engineering_toolkit_compiler/__init__.py

@@ -0,0 +1,5 @@
+"""Controlled data-product compiler for dbt_data_engineering_toolkit."""
+
+from .version import COMPILER_VERSION
+
+__version__ = COMPILER_VERSION

dbt_data_engineering_toolkit_compiler-3.0.1/src/dbt_data_engineering_toolkit_compiler/__main__.py

@@ -0,0 +1,3 @@
+from .exposers.cli import main
+
+raise SystemExit(main())

dbt_data_engineering_toolkit_compiler-3.0.1/src/dbt_data_engineering_toolkit_compiler/adapters.py

@@ -0,0 +1,352 @@
+"""Explicit adapter capabilities used by validation and project emission."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .operational import JsonValue
+
+
+def _env(name: str, default: str | None = None, *, integer: bool = False) -> str:
+    default_argument = f", '{default}'" if default is not None else ""
+    cast = " | int" if integer else ""
+    return "{{ env_var('" + name + "'" + default_argument + ")" + cast + " }}"
+
+
+@dataclass(frozen=True, slots=True)
+class AdapterProvider:
+    name: str
+    display_name: str
+    dbt_dependency: str
+    sqlfluff_dialect: str
+    logical_types: dict[str, str]
+    operational_types: dict[str, str]
+    supported_materializations: frozenset[str]
+    supports_incremental: bool
+    supports_enforced_contracts: bool
+    profile_output: dict[str, JsonValue]
+
+    def data_type(self, logical_type: str, physical_type: str | None) -> str:
+        return physical_type or self.logical_types.get(
+            logical_type.casefold(), logical_type.casefold()
+        )
+
+    def operational_type(self, field_name: str) -> str:
+        return self.operational_types.get(field_name, self.data_type("string", None))
+
+
+class AdapterRegistry:
+    """Single extension point for warehouse-specific compiler behavior."""
+
+    def __init__(self, providers: list[AdapterProvider]):
+        self._providers = {item.name: item for item in providers}
+
+    @classmethod
+    def default(cls) -> "AdapterRegistry":
+        common_materializations = frozenset({"view", "table", "ephemeral"})
+        portable = {
+            "string": "varchar",
+            "number": "numeric",
+            "numeric": "numeric",
+            "integer": "bigint",
+            "boolean": "boolean",
+            "date": "date",
+            "timestamp": "timestamp",
+            "time": "time",
+        }
+        return cls(
+            [
+                AdapterProvider(
+                    name="athena",
+                    display_name="Amazon Athena",
+                    dbt_dependency="dbt-athena-community>=1.10,<2",
+                    sqlfluff_dialect="athena",
+                    logical_types={
+                        **portable,
+                        "string": "varchar",
+                        "number": "double",
+                        "numeric": "decimal(38,6)",
+                        "timestamp": "timestamp",
+                    },
+                    operational_types={
+                        "_det_rejections": "array(varchar)",
+                        "_det_warnings": "array(varchar)",
+                        "_det_loaded_at": "timestamp",
+                        "_det_invocation_id": "varchar",
+                        "_det_source_system": "varchar",
+                    },
+                    supported_materializations=common_materializations,
+                    supports_incremental=False,
+                    supports_enforced_contracts=False,
+                    profile_output={
+                        "type": "athena",
+                        "database": _env("DET_ATHENA_DATABASE", "awsdatacatalog"),
+                        "schema": "__TARGET_SCHEMA__",
+                        "s3_staging_dir": _env("DET_ATHENA_S3_STAGING_DIR"),
+                        "region_name": _env("DET_ATHENA_REGION", "us-east-1"),
+                        "work_group": _env("DET_ATHENA_WORK_GROUP", "primary"),
+                        "threads": 4,
+                    },
+                ),
+                AdapterProvider(
+                    name="bigquery",
+                    display_name="Google BigQuery",
+                    dbt_dependency="dbt-bigquery>=1.10,<2",
+                    sqlfluff_dialect="bigquery",
+                    logical_types={
+                        **portable,
+                        "string": "string",
+                        "number": "float64",
+                        "numeric": "numeric",
+                        "integer": "int64",
+                        "boolean": "bool",
+                    },
+                    operational_types={
+                        "_det_rejections": "array<string>",
+                        "_det_warnings": "array<string>",
+                        "_det_loaded_at": "timestamp",
+                        "_det_invocation_id": "string",
+                        "_det_source_system": "string",
+                    },
+                    supported_materializations=common_materializations,
+                    supports_incremental=False,
+                    supports_enforced_contracts=True,
+                    profile_output={
+                        "type": "bigquery",
+                        "method": "oauth",
+                        "project": _env("DET_BIGQUERY_PROJECT"),
+                        "dataset": "__TARGET_SCHEMA__",
+                        "location": _env("DET_BIGQUERY_LOCATION", "US"),
+                        "threads": 4,
+                    },
+                ),
+                AdapterProvider(
+                    name="clickhouse",
+                    display_name="ClickHouse",
+                    dbt_dependency="dbt-clickhouse>=1.10,<2",
+                    sqlfluff_dialect="clickhouse",
+                    logical_types={
+                        **portable,
+                        "string": "String",
+                        "number": "Float64",
+                        "numeric": "Decimal(38,6)",
+                        "integer": "Int64",
+                        "boolean": "Bool",
+                        "date": "Date",
+                        "timestamp": "DateTime64(6)",
+                        "time": "String",
+                    },
+                    operational_types={
+                        "_det_rejections": "Array(String)",
+                        "_det_warnings": "Array(String)",
+                        "_det_loaded_at": "DateTime64(6)",
+                        "_det_invocation_id": "String",
+                        "_det_source_system": "String",
+                    },
+                    supported_materializations=common_materializations,
+                    supports_incremental=False,
+                    supports_enforced_contracts=False,
+                    profile_output={
+                        "type": "clickhouse",
+                        "host": _env("DET_CLICKHOUSE_HOST"),
+                        "port": _env("DET_CLICKHOUSE_PORT", "8443", integer=True),
+                        "user": _env("DET_CLICKHOUSE_USER", "default"),
+                        "password": _env("DBT_ENV_SECRET_DET_CLICKHOUSE_PASSWORD", ""),
+                        "schema": "__TARGET_SCHEMA__",
+                        "secure": True,
+                        "verify": True,
+                        "threads": 4,
+                    },
+                ),
+                AdapterProvider(
+                    name="databricks",
+                    display_name="Databricks",
+                    dbt_dependency="dbt-databricks>=1.10,<2",
+                    sqlfluff_dialect="databricks",
+                    logical_types={
+                        **portable,
+                        "string": "string",
+                        "number": "double",
+                        "numeric": "decimal(38,6)",
+                        "time": "string",
+                    },
+                    operational_types={
+                        "_det_rejections": "array<string>",
+                        "_det_warnings": "array<string>",
+                        "_det_loaded_at": "timestamp",
+                        "_det_invocation_id": "string",
+                        "_det_source_system": "string",
+                    },
+                    supported_materializations=common_materializations,
+                    supports_incremental=False,
+                    supports_enforced_contracts=True,
+                    profile_output={
+                        "type": "databricks",
+                        "host": _env("DET_DATABRICKS_HOST"),
+                        "http_path": _env("DET_DATABRICKS_HTTP_PATH"),
+                        "token": _env("DBT_ENV_SECRET_DET_DATABRICKS_TOKEN"),
+                        "catalog": _env("DET_DATABRICKS_CATALOG", "hive_metastore"),
+                        "schema": "__TARGET_SCHEMA__",
+                        "threads": 4,
+                    },
+                ),
+                AdapterProvider(
+                    name="duckdb",
+                    display_name="DuckDB",
+                    dbt_dependency="dbt-duckdb>=1.10,<2",
+                    sqlfluff_dialect="duckdb",
+                    logical_types={
+                        **portable,
+                        "string": "varchar",
+                        "number": "double",
+                        "numeric": "decimal(38,6)",
+                    },
+                    operational_types={
+                        "_det_rejections": "varchar[]",
+                        "_det_warnings": "varchar[]",
+                        "_det_loaded_at": "timestamp with time zone",
+                        "_det_invocation_id": "varchar",
+                        "_det_source_system": "varchar",
+                    },
+                    supported_materializations=common_materializations,
+                    supports_incremental=False,
+                    supports_enforced_contracts=True,
+                    profile_output={
+                        "type": "duckdb",
+                        "path": "target/data_product.duckdb",
+                        "schema": "__TARGET_SCHEMA__",
+                        "threads": 4,
+                    },
+                ),
+                AdapterProvider(
+                    name="postgres",
+                    display_name="Postgres",
+                    dbt_dependency="dbt-postgres>=1.10,<2",
+                    sqlfluff_dialect="postgres",
+                    logical_types={**portable, "string": "text"},
+                    operational_types={
+                        "_det_rejections": "text[]",
+                        "_det_warnings": "text[]",
+                        "_det_loaded_at": "timestamp with time zone",
+                        "_det_invocation_id": "text",
+                        "_det_source_system": "text",
+                    },
+                    supported_materializations=common_materializations,
+                    supports_incremental=False,
+                    supports_enforced_contracts=True,
+                    profile_output={
+                        "type": "postgres",
+                        "host": _env("DET_POSTGRES_HOST"),
+                        "port": _env("DET_POSTGRES_PORT", "5432", integer=True),
+                        "user": _env("DET_POSTGRES_USER"),
+                        "password": _env("DET_POSTGRES_PASSWORD"),
+                        "dbname": _env("DET_POSTGRES_DATABASE"),
+                        "schema": "__TARGET_SCHEMA__",
+                        "threads": 4,
+                    },
+                ),
+                AdapterProvider(
+                    name="redshift",
+                    display_name="Amazon Redshift",
+                    dbt_dependency="dbt-redshift>=1.10,<2",
+                    sqlfluff_dialect="redshift",
+                    logical_types={
+                        **portable,
+                        "string": "varchar",
+                        "number": "double precision",
+                        "numeric": "decimal(38,6)",
+                    },
+                    operational_types={
+                        "_det_rejections": "super",
+                        "_det_warnings": "super",
+                        "_det_loaded_at": "timestamp",
+                        "_det_invocation_id": "varchar",
+                        "_det_source_system": "varchar",
+                    },
+                    supported_materializations=common_materializations,
+                    supports_incremental=False,
+                    supports_enforced_contracts=True,
+                    profile_output={
+                        "type": "redshift",
+                        "host": _env("DET_REDSHIFT_HOST"),
+                        "port": _env("DET_REDSHIFT_PORT", "5439", integer=True),
+                        "user": _env("DET_REDSHIFT_USER"),
+                        "password": _env("DBT_ENV_SECRET_DET_REDSHIFT_PASSWORD"),
+                        "dbname": _env("DET_REDSHIFT_DATABASE"),
+                        "schema": "__TARGET_SCHEMA__",
+                        "threads": 4,
+                    },
+                ),
+                AdapterProvider(
+                    name="snowflake",
+                    display_name="Snowflake",
+                    dbt_dependency="dbt-snowflake>=1.10,<2",
+                    sqlfluff_dialect="snowflake",
+                    logical_types={
+                        **portable,
+                        "string": "varchar",
+                        "integer": "number(38,0)",
+                        "timestamp": "timestamp_tz",
+                    },
+                    operational_types={
+                        "_det_rejections": "array",
+                        "_det_warnings": "array",
+                        "_det_loaded_at": "timestamp_tz",
+                        "_det_invocation_id": "varchar",
+                        "_det_source_system": "varchar",
+                    },
+                    supported_materializations=common_materializations,
+                    supports_incremental=False,
+                    supports_enforced_contracts=True,
+                    profile_output={
+                        "type": "snowflake",
+                        "account": _env("DET_SNOWFLAKE_ACCOUNT"),
+                        "user": _env("DET_SNOWFLAKE_USER"),
+                        "password": _env("DBT_ENV_SECRET_DET_SNOWFLAKE_PASSWORD"),
+                        "role": _env("DET_SNOWFLAKE_ROLE"),
+                        "database": _env("DET_SNOWFLAKE_DATABASE"),
+                        "warehouse": _env("DET_SNOWFLAKE_WAREHOUSE"),
+                        "schema": "__TARGET_SCHEMA__",
+                        "threads": 4,
+                    },
+                ),
+                AdapterProvider(
+                    name="spark",
+                    display_name="Apache Spark",
+                    dbt_dependency="dbt-spark[PyHive]>=1.10,<2",
+                    sqlfluff_dialect="sparksql",
+                    logical_types={
+                        **portable,
+                        "string": "string",
+                        "number": "double",
+                        "numeric": "decimal(38,6)",
+                        "time": "string",
+                    },
+                    operational_types={
+                        "_det_rejections": "array<string>",
+                        "_det_warnings": "array<string>",
+                        "_det_loaded_at": "timestamp",
+                        "_det_invocation_id": "string",
+                        "_det_source_system": "string",
+                    },
+                    supported_materializations=common_materializations,
+                    supports_incremental=False,
+                    supports_enforced_contracts=False,
+                    profile_output={
+                        "type": "spark",
+                        "method": "thrift",
+                        "host": _env("DET_SPARK_HOST"),
+                        "port": _env("DET_SPARK_PORT", "10001", integer=True),
+                        "user": _env("DET_SPARK_USER", "dbt"),
+                        "schema": "__TARGET_SCHEMA__",
+                        "threads": 4,
+                    },
+                ),
+            ]
+        )
+
+    def get(self, name: str) -> AdapterProvider | None:
+        return self._providers.get(name.casefold())
+
+    def names(self) -> tuple[str, ...]:
+        return tuple(sorted(self._providers))