contractforge-databricks 0.1.0__py3-none-any.whl

contractforge_databricks/bundles/project.py

@@ -0,0 +1,213 @@
+"""Render Databricks Asset Bundles from ContractForge project metadata."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Mapping
+
+from contractforge_databricks.bundles.project_config import (
+    databricks_deployment,
+    databricks_scheduling,
+    job_fields,
+    mapping,
+    required_text,
+    runtime_environment,
+    sequence,
+    slug,
+    text,
+    validation_job_name,
+    variable_parameter,
+    variables,
+)
+from contractforge_databricks.cli_io import yaml_dump
+
+_DEFAULT_TARGET = "dev"
+_DEFAULT_CONTRACT_NOTEBOOK = "./notebooks/run_contractforge.py"
+_DEFAULT_ENVIRONMENT_KEY = "contractforge_runtime"
+_EXTRA_TASK_META_KEYS = {
+    "base_parameters",
+    "depends_on",
+    "environment_key",
+    "name",
+    "notebook_path",
+    "task_key",
+}
+
+
+def render_databricks_project_bundle(
+    project: Mapping[str, Any],
+    *,
+    project_root: str | Path | None = None,
+    target: str = _DEFAULT_TARGET,
+) -> dict[str, Any]:
+    """Render a Databricks Asset Bundle document from project-level metadata."""
+
+    deployment = databricks_deployment(project)
+    scheduling = databricks_scheduling(project)
+    project_name = required_text(project.get("name"), "project.name")
+    bundle_name = text(deployment.get("bundle_name")) or slug(project_name)
+    job_key = text(deployment.get("job_key")) or slug(project_name)
+    job_name = text(deployment.get("job_name")) or validation_job_name(project) or project_name
+    variables_payload = variables(deployment)
+    job = {
+        "name": job_name,
+        **job_fields(scheduling),
+        **runtime_environment(deployment, variables_payload),
+        "tasks": _tasks(project, deployment, scheduling, variables_payload),
+    }
+    bundle: dict[str, Any] = {
+        "bundle": {"name": bundle_name},
+        "resources": {"jobs": {job_key: job}},
+        "targets": {target: {"default": True}},
+    }
+    workspace_root = text(deployment.get("workspace_root_path") or deployment.get("workspace_root"))
+    if workspace_root:
+        bundle["workspace"] = {"root_path": workspace_root}
+    if variables_payload:
+        bundle["variables"] = variables_payload
+    return bundle
+
+
+def render_databricks_project_bundle_yaml(
+    project: Mapping[str, Any],
+    *,
+    project_root: str | Path | None = None,
+    target: str = _DEFAULT_TARGET,
+) -> str:
+    """Render a Databricks Asset Bundle YAML document from project metadata."""
+
+    return yaml_dump(render_databricks_project_bundle(project, project_root=project_root, target=target))
+
+
+def _tasks(
+    project: Mapping[str, Any],
+    deployment: Mapping[str, Any],
+    scheduling: Mapping[str, Any],
+    variables: Mapping[str, Any],
+) -> list[dict[str, Any]]:
+    task_overrides = mapping(scheduling.get("tasks"))
+    task_keys = _all_task_keys(project, scheduling, task_overrides)
+    extra_tasks = _extra_tasks(scheduling, deployment, task_keys)
+    return [
+        *[task for task in extra_tasks if not task.get("depends_on")],
+        *[
+        _contract_task(step, deployment, task_overrides, task_keys, variables)
+        for step in _execution_order(project)
+        ],
+        *[task for task in extra_tasks if task.get("depends_on")],
+    ]
+
+
+def _extra_tasks(
+    scheduling: Mapping[str, Any],
+    deployment: Mapping[str, Any],
+    task_keys: Mapping[str, str],
+) -> list[dict[str, Any]]:
+    return [_extra_task(task, deployment, task_keys) for task in sequence(scheduling.get("extra_tasks")) if isinstance(task, Mapping)]
+
+
+def _extra_task(task: Mapping[str, Any], deployment: Mapping[str, Any], task_keys: Mapping[str, str]) -> dict[str, Any]:
+    task_key = required_text(task.get("task_key") or task.get("name"), "scheduling.databricks.extra_tasks[].task_key")
+    environment_key = text(task.get("environment_key") or deployment.get("environment_key")) or _DEFAULT_ENVIRONMENT_KEY
+    rendered = {
+        "task_key": task_key,
+        "environment_key": environment_key,
+        **_task_dependencies(task, task_keys),
+        **_extra_task_body(task),
+    }
+    return {key: value for key, value in rendered.items() if value not in ({}, None)}
+
+
+def _extra_task_body(task: Mapping[str, Any]) -> dict[str, Any]:
+    if isinstance(task.get("notebook_task"), Mapping):
+        return {"notebook_task": dict(task["notebook_task"])}
+    notebook_path = text(task.get("notebook_path"))
+    if notebook_path:
+        return {
+            "notebook_task": {
+                "notebook_path": notebook_path,
+                "base_parameters": {str(key): str(value) for key, value in mapping(task.get("base_parameters")).items()},
+            }
+        }
+    raw = {str(key): value for key, value in task.items() if key not in _EXTRA_TASK_META_KEYS}
+    return raw
+
+
+def _contract_task(
+    step: Mapping[str, Any],
+    deployment: Mapping[str, Any],
+    task_overrides: Mapping[str, Any],
+    task_keys: Mapping[str, str],
+    variables: Mapping[str, Any],
+) -> dict[str, Any]:
+    name = required_text(step.get("name"), "execution_order[].name")
+    override = mapping(task_overrides.get(name))
+    contract = _databricks_contract(step)
+    environment_key = text(override.get("environment_key") or deployment.get("environment_key")) or _DEFAULT_ENVIRONMENT_KEY
+    notebook_path = text(override.get("notebook_path") or deployment.get("contract_notebook_path")) or _DEFAULT_CONTRACT_NOTEBOOK
+    task = {
+        "task_key": task_keys[name],
+        "environment_key": environment_key,
+        **_task_dependencies(step, task_keys),
+        "notebook_task": {
+            "notebook_path": notebook_path,
+            "base_parameters": _base_parameters(contract, override, variables),
+        },
+    }
+    return {key: value for key, value in task.items() if value not in ({}, None)}
+
+
+def _base_parameters(contract: str, override: Mapping[str, Any], variables: Mapping[str, Any]) -> dict[str, str]:
+    base = {
+        **variable_parameter("bundle_root", variables),
+        "contract": contract,
+        **variable_parameter("evidence_catalog", variables),
+        **variable_parameter("evidence_schema", variables),
+    }
+    extra = mapping(override.get("base_parameters"))
+    return {**base, **{str(key): str(value) for key, value in extra.items()}}
+
+
+def _task_dependencies(step: Mapping[str, Any], task_keys: Mapping[str, str]) -> dict[str, list[dict[str, str]]]:
+    dependencies = [_dependency_task_key(name, task_keys) for name in sequence(step.get("depends_on"))]
+    return {"depends_on": [{"task_key": key} for key in dependencies]} if dependencies else {}
+
+
+def _dependency_task_key(name: Any, task_keys: Mapping[str, str]) -> str:
+    value = required_text(name, "execution_order[].depends_on[]")
+    return task_keys.get(value, value)
+
+
+def _databricks_contract(step: Mapping[str, Any]) -> str:
+    contracts = mapping(step.get("contracts"))
+    value = text(contracts.get("databricks"))
+    if not value:
+        raise ValueError(f"execution_order entry {step.get('name')!r} must declare contracts.databricks")
+    path = Path(value)
+    return str(path.as_posix() if path.is_absolute() else path.as_posix())
+
+
+def _all_task_keys(project: Mapping[str, Any], scheduling: Mapping[str, Any], task_overrides: Mapping[str, Any]) -> dict[str, str]:
+    contract_keys = {
+        name: text(mapping(task_overrides.get(name)).get("task_key") or step.get("task_key")) or slug(name)
+        for step in _execution_order(project)
+        for name in (required_text(step.get("name"), "execution_order[].name"),)
+    }
+    extra_keys = {
+        required_text(task.get("name"), "scheduling.databricks.extra_tasks[].name"): required_text(
+            task.get("task_key"), "scheduling.databricks.extra_tasks[].task_key"
+        )
+        for task in sequence(scheduling.get("extra_tasks"))
+        if isinstance(task, Mapping) and task.get("name")
+    }
+    return {**contract_keys, **extra_keys}
+
+
+def _execution_order(project: Mapping[str, Any]) -> tuple[Mapping[str, Any], ...]:
+    steps = project.get("execution_order")
+    if not isinstance(steps, list) or not steps:
+        raise ValueError("project.execution_order must be a non-empty list")
+    invalid = [step for step in steps if not isinstance(step, Mapping)]
+    if invalid:
+        raise ValueError("project.execution_order entries must be objects")
+    return tuple(steps)

contractforge_databricks/bundles/project_config.py

@@ -0,0 +1,133 @@
+"""Configuration helpers for Databricks project bundle rendering."""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Mapping
+
+from contractforge_core.project import adapter_scheduling, quartz_cron_expression
+
+_JOB_FIELD_BUILDERS = {
+    "email_notifications": lambda value: value,
+    "max_concurrent_runs": lambda value: int(value),
+    "notification_settings": lambda value: value,
+    "queue": lambda value: {"enabled": bool(value)} if isinstance(value, bool) else value,
+    "schedule": lambda value: databricks_schedule(mapping(value)),
+    "tags": lambda value: value,
+    "timeout_seconds": lambda value: int(value),
+    "webhook_notifications": lambda value: value,
+}
+
+
+def runtime_environment(deployment: Mapping[str, Any], variables: Mapping[str, Any]) -> dict[str, Any]:
+    environment = mapping(deployment.get("runtime_environment"))
+    enabled = environment.get("enabled", True)
+    if not enabled:
+        return {}
+    dependency_values = dependencies(environment, variables)
+    if not dependency_values:
+        return {}
+    return {
+        "environments": [
+            {
+                "environment_key": text(deployment.get("environment_key")) or "contractforge_runtime",
+                "spec": {
+                    "environment_version": str(environment.get("environment_version") or "2"),
+                    "dependencies": dependency_values,
+                },
+            }
+        ]
+    }
+
+
+def dependencies(environment: Mapping[str, Any], variables: Mapping[str, Any]) -> list[str]:
+    configured = [str(value) for value in sequence(environment.get("dependencies"))]
+    wheel_vars = [f"${{var.{name}}}" for name in ("core_wheel_path", "databricks_wheel_path") if name in variables]
+    return configured or wheel_vars
+
+
+def job_fields(scheduling: Mapping[str, Any]) -> dict[str, Any]:
+    fields = mapping(scheduling.get("job"))
+    direct = {key: scheduling[key] for key in ("max_concurrent_runs", "queue", "schedule", "tags") if key in scheduling}
+    configured = {**direct, **fields}
+    return {
+        key: _JOB_FIELD_BUILDERS[key](value)
+        for key, value in configured.items()
+        if key in _JOB_FIELD_BUILDERS and value is not None
+    }
+
+
+def databricks_schedule(schedule: Mapping[str, Any]) -> dict[str, Any]:
+    cron = schedule.get("quartz_cron_expression") or _quartz_from_standard(schedule.get("cron"))
+    if not cron:
+        raise ValueError("schedule.cron is required for Databricks project scheduling")
+    return {
+        "quartz_cron_expression": str(cron),
+        "timezone_id": str(schedule.get("timezone_id") or schedule.get("timezone") or "UTC"),
+        "pause_status": str(schedule.get("pause_status") or _pause_status(schedule)),
+    }
+
+
+def variables(deployment: Mapping[str, Any]) -> dict[str, Any]:
+    raw = mapping(deployment.get("variables"))
+    defaults = {
+        key: deployment[key]
+        for key in ("bundle_root", "core_wheel_path", "databricks_wheel_path", "evidence_catalog", "evidence_schema")
+        if key in deployment
+    }
+    values = {**defaults, **raw}
+    return {str(key): value if isinstance(value, Mapping) else {"default": str(value)} for key, value in values.items()}
+
+
+def variable_parameter(name: str, variables: Mapping[str, Any]) -> dict[str, str]:
+    return {name: f"${{var.{name}}}"} if name in variables else {}
+
+
+def databricks_deployment(project: Mapping[str, Any]) -> Mapping[str, Any]:
+    deployment = mapping(project.get("deployment"))
+    validation = mapping(project.get("validation"))
+    return {**mapping(validation.get("databricks")), **mapping(deployment.get("databricks"))}
+
+
+def databricks_scheduling(project: Mapping[str, Any]) -> Mapping[str, Any]:
+    return adapter_scheduling(project, "databricks")
+
+
+def validation_job_name(project: Mapping[str, Any]) -> str | None:
+    validation = mapping(project.get("validation"))
+    databricks = mapping(validation.get("databricks"))
+    return text(databricks.get("job_name"))
+
+
+def mapping(value: Any) -> Mapping[str, Any]:
+    return value if isinstance(value, Mapping) else {}
+
+
+def sequence(value: Any) -> tuple[Any, ...]:
+    return tuple(value) if isinstance(value, list) else ()
+
+
+def required_text(value: Any, field_name: str) -> str:
+    value_text = text(value)
+    if not value_text:
+        raise ValueError(f"{field_name} must not be empty")
+    return value_text
+
+
+def text(value: Any) -> str | None:
+    return str(value).strip() if value is not None and str(value).strip() else None
+
+
+def slug(value: str) -> str:
+    rendered = re.sub(r"[^A-Za-z0-9_]+", "_", value.strip()).strip("_").lower()
+    return rendered or "contractforge_project"
+
+
+def _quartz_from_standard(value: Any) -> str:
+    return quartz_cron_expression(str(value)) if value is not None and str(value).strip() else ""
+
+
+def _pause_status(schedule: Mapping[str, Any]) -> str:
+    if schedule.get("paused", False) or schedule.get("enabled") is False:
+        return "PAUSED"
+    return "UNPAUSED"

contractforge_databricks/capabilities/__init__.py

@@ -0,0 +1,17 @@
+from contractforge_databricks.capabilities.evaluate import evaluate_databricks_capabilities
+from contractforge_databricks.capabilities.mapping import to_core_capabilities
+from contractforge_databricks.capabilities.models import (
+    CapabilityEvidence,
+    DatabricksCapabilities,
+    NativeCapability,
+)
+from contractforge_databricks.capabilities.uc import uc_capability_issues
+
+__all__ = [
+    "CapabilityEvidence",
+    "DatabricksCapabilities",
+    "NativeCapability",
+    "evaluate_databricks_capabilities",
+    "to_core_capabilities",
+    "uc_capability_issues",
+]

contractforge_databricks/capabilities/builders.py

@@ -0,0 +1,43 @@
+"""Capability factory helpers."""
+
+from __future__ import annotations
+
+from contractforge_core.capabilities import NativeCapability, capability
+
+
+def uc_sql_capability(name: str, *, is_uc_target: bool, is_databricks: bool) -> NativeCapability:
+    if not is_uc_target:
+        return capability(
+            name,
+            "unsupported",
+            "Unity Catalog governance capability requires a three-part target table name.",
+            requires=("Unity Catalog", "catalog.schema.table"),
+        )
+    if is_databricks:
+        return capability(
+            name,
+            "supported",
+            "Unity Catalog SQL governance capability is eligible for this Databricks target.",
+            requires=("Unity Catalog privileges",),
+        )
+    return capability(
+        name,
+        "unknown",
+        "Target is Unity Catalog-shaped, but Databricks runtime evidence was not detected.",
+        requires=("Unity Catalog privileges",),
+    )
+
+
+def workspace_capability(
+    name: str,
+    *,
+    is_databricks: bool,
+    is_uc_target: bool,
+    reason: str,
+    requires: tuple[str, ...],
+) -> NativeCapability:
+    if not is_databricks:
+        return capability(name, "unsupported", f"{reason} Databricks runtime evidence was not detected.", requires=requires)
+    if not is_uc_target:
+        return capability(name, "unknown", f"{reason} Target/catalog context is incomplete.", requires=requires)
+    return capability(name, "unknown", f"{reason} Workspace configuration and permissions were not probed.", requires=requires)

contractforge_databricks/capabilities/evaluate.py

@@ -0,0 +1,162 @@
+"""Non-destructive Databricks capability evaluation."""
+
+from __future__ import annotations
+
+from contractforge_databricks.capabilities.builders import capability, uc_sql_capability, workspace_capability
+from contractforge_databricks.capabilities.models import DatabricksCapabilities
+from contractforge_databricks.capabilities.runtime import is_three_part_name, runtime_evidence, runtime_kind
+
+
+def evaluate_databricks_capabilities(
+    *,
+    target_table: str | None = None,
+    runtime_type: str | None = None,
+    spark_version: str | None = None,
+    spark_conf: dict[str, str] | None = None,
+    environment: dict[str, str] | None = None,
+) -> DatabricksCapabilities:
+    """Evaluate Databricks-native capability eligibility from passive evidence."""
+    conf = {str(key): str(value) for key, value in (spark_conf or {}).items()}
+    env = {str(key): str(value) for key, value in (environment or {}).items()}
+    kind = runtime_kind(runtime_type=runtime_type, spark_conf=conf, environment=env)
+    is_databricks = kind in {"databricks_classic", "databricks_serverless"}
+    is_uc_target = is_three_part_name(target_table)
+    evidence = runtime_evidence(runtime_kind=kind, spark_version=spark_version, spark_conf=conf, environment=env)
+
+    capabilities = {
+        "databricks_runtime": capability(
+            "databricks_runtime",
+            "supported" if is_databricks else "unsupported",
+            "Databricks runtime evidence was detected."
+            if is_databricks
+            else "No Databricks runtime evidence was detected.",
+            evidence=evidence,
+        ),
+        "serverless_runtime": capability(
+            "serverless_runtime",
+            "supported" if kind == "databricks_serverless" else "unsupported",
+            "The current runtime is Databricks serverless."
+            if kind == "databricks_serverless"
+            else "The current runtime is not classified as Databricks serverless.",
+            evidence=evidence,
+        ),
+        "delta_tables": capability(
+            "delta_tables",
+            "supported" if is_databricks else "unknown",
+            "Delta tables are native to Databricks runtimes."
+            if is_databricks
+            else "Delta support was not probed outside Databricks.",
+            evidence=evidence,
+            requires=("Delta Lake runtime",),
+        ),
+        "sql_merge": capability(
+            "sql_merge",
+            "supported" if is_databricks else "unknown",
+            "Databricks SQL MERGE is eligible in Databricks runtimes."
+            if is_databricks
+            else "SQL MERGE support was not probed outside Databricks.",
+            evidence=evidence,
+            requires=("Delta table", "MERGE privilege"),
+        ),
+        "unity_catalog_table": capability(
+            "unity_catalog_table",
+            "supported" if is_uc_target else "unsupported",
+            "Target table is a three-part Unity Catalog name."
+            if is_uc_target
+            else "Target table is not a three-part Unity Catalog name.",
+            requires=("catalog.schema.table",),
+        ),
+        "uc_table_comments": uc_sql_capability(
+            "uc_table_comments", is_uc_target=is_uc_target, is_databricks=is_databricks
+        ),
+        "uc_column_comments": uc_sql_capability(
+            "uc_column_comments", is_uc_target=is_uc_target, is_databricks=is_databricks
+        ),
+        "uc_table_tags": uc_sql_capability("uc_table_tags", is_uc_target=is_uc_target, is_databricks=is_databricks),
+        "uc_column_tags": uc_sql_capability("uc_column_tags", is_uc_target=is_uc_target, is_databricks=is_databricks),
+        "uc_grants": uc_sql_capability("uc_grants", is_uc_target=is_uc_target, is_databricks=is_databricks),
+        "uc_row_filters": uc_sql_capability("uc_row_filters", is_uc_target=is_uc_target, is_databricks=is_databricks),
+        "uc_column_masks": uc_sql_capability("uc_column_masks", is_uc_target=is_uc_target, is_databricks=is_databricks),
+        "uc_abac_policies": workspace_capability(
+            "uc_abac_policies",
+            is_databricks=is_databricks,
+            is_uc_target=is_uc_target,
+            reason="Unity Catalog ABAC policies require workspace/account feature support and permissions.",
+            requires=("Unity Catalog", "policy privileges", "supported workspace feature"),
+        ),
+        "uc_external_locations": workspace_capability(
+            "uc_external_locations",
+            is_databricks=is_databricks,
+            is_uc_target=True,
+            reason="External Locations are Unity Catalog storage-governance objects.",
+            requires=("Unity Catalog", "storage credential", "external location privileges"),
+        ),
+        "uc_volumes": workspace_capability(
+            "uc_volumes",
+            is_databricks=is_databricks,
+            is_uc_target=True,
+            reason="Volumes are Unity Catalog storage objects exposed through /Volumes paths.",
+            requires=("Unity Catalog", "volume privileges"),
+        ),
+        "databricks_connections": workspace_capability(
+            "databricks_connections",
+            is_databricks=is_databricks,
+            is_uc_target=True,
+            reason="Databricks Connections are governed workspace objects and must be configured externally.",
+            requires=("Databricks connection", "connection privileges"),
+        ),
+        "autoloader_cloudfiles": capability(
+            "autoloader_cloudfiles",
+            "supported" if is_databricks else "unsupported",
+            "Auto Loader cloudFiles is a Databricks runtime capability."
+            if is_databricks
+            else "Auto Loader cloudFiles requires Databricks runtime support.",
+            evidence=evidence,
+            requires=("spark.readStream.format('cloudFiles')",),
+        ),
+        "lakeflow_declarative_pipelines": workspace_capability(
+            "lakeflow_declarative_pipelines",
+            is_databricks=is_databricks,
+            is_uc_target=True,
+            reason="Lakeflow Declarative Pipelines are Databricks-native pipeline artifacts.",
+            requires=("Databricks workspace pipeline support", "Unity Catalog for governed pipelines"),
+        ),
+        "lakeflow_auto_cdc": workspace_capability(
+            "lakeflow_auto_cdc",
+            is_databricks=is_databricks,
+            is_uc_target=is_uc_target,
+            reason="Lakeflow AUTO CDC requires workspace support and CDC-compatible source semantics.",
+            requires=("Lakeflow Declarative Pipelines", "keys", "sequence_by", "CDC source semantics"),
+        ),
+        "liquid_clustering": workspace_capability(
+            "liquid_clustering",
+            is_databricks=is_databricks,
+            is_uc_target=True,
+            reason="Liquid Clustering is a Databricks Delta table optimization feature.",
+            requires=("Delta table", "supported Databricks runtime", "table alter privileges"),
+        ),
+        "delta_control_tables": capability(
+            "delta_control_tables",
+            "supported" if is_databricks else "unknown",
+            "Delta tables can implement ContractForge evidence stores on Databricks."
+            if is_databricks
+            else "Evidence storage was not probed outside Databricks.",
+            evidence=evidence,
+            requires=("Delta table create/write privileges",),
+        ),
+        "snapshot_soft_delete_merge": capability(
+            "snapshot_soft_delete_merge",
+            "supported" if is_databricks else "unknown",
+            "Databricks Delta MERGE supports NOT MATCHED BY SOURCE update semantics."
+            if is_databricks
+            else "Snapshot reconciliation was not probed outside Databricks.",
+            evidence=evidence,
+            requires=("Delta MERGE", "NOT MATCHED BY SOURCE"),
+        ),
+    }
+    return DatabricksCapabilities(
+        runtime_kind=kind,
+        target_table=target_table,
+        spark_version=spark_version,
+        capabilities=capabilities,
+    )

contractforge_databricks/capabilities/mapping.py

@@ -0,0 +1,36 @@
+"""Map Databricks-native capabilities to ContractForge Core capabilities."""
+
+from __future__ import annotations
+
+from contractforge_core.capabilities import PlatformCapabilities
+from contractforge_databricks.capabilities.models import DatabricksCapabilities
+from contractforge_databricks.write_modes.registry import list_write_modes
+
+
+def to_core_capabilities(capabilities: DatabricksCapabilities) -> PlatformCapabilities:
+    review_required = []
+    if capabilities.status("lakeflow_auto_cdc") == "unknown":
+        review_required.append("lakeflow_auto_cdc")
+
+    return PlatformCapabilities(
+        platform="databricks",
+        supports_append=capabilities.supports("delta_tables"),
+        supports_overwrite=capabilities.supports("delta_tables"),
+        supports_merge=capabilities.supports("sql_merge"),
+        supports_hash_diff=capabilities.supports("sql_merge"),
+        supports_scd2=capabilities.supports("sql_merge"),
+        supports_snapshot_soft_delete=capabilities.supports("snapshot_soft_delete_merge"),
+        supports_schema_evolution=capabilities.supports("delta_tables"),
+        supports_row_filters=capabilities.supports("uc_row_filters"),
+        supports_column_masks=capabilities.supports("uc_column_masks"),
+        supports_available_now_streaming=capabilities.supports("autoloader_cloudfiles"),
+        supports_required_columns_quality=True,
+        supports_unique_key_quality=True,
+        supports_max_null_ratio_quality=True,
+        supports_expression_quality=True,
+        supports_shape=capabilities.supports("databricks_runtime"),
+        supports_transform=capabilities.supports("databricks_runtime"),
+        evidence_stores=("delta_control_tables",) if capabilities.supports("delta_control_tables") else (),
+        review_required_semantics=tuple(review_required),
+        supported_custom_write_modes=list_write_modes(),
+    )

contractforge_databricks/capabilities/models.py

@@ -0,0 +1,44 @@
+"""Databricks-native capability evidence models."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Literal
+
+from contractforge_core.capabilities import (
+    CapabilityEvidence as CapabilityEvidence,
+    CapabilityStatus,
+    NativeCapability,
+)
+
+RuntimeKind = Literal["databricks_serverless", "databricks_classic", "spark", "unknown"]
+
+
+@dataclass(frozen=True)
+class DatabricksCapabilities:
+    runtime_kind: RuntimeKind
+    target_table: str | None
+    spark_version: str | None
+    capabilities: dict[str, NativeCapability] = field(default_factory=dict)
+
+    def supports(self, name: str) -> bool:
+        capability = self.capabilities.get(name)
+        return bool(capability and capability.supported)
+
+    def status(self, name: str) -> CapabilityStatus:
+        capability = self.capabilities.get(name)
+        return "unknown" if capability is None else capability.status
+
+    def unsupported(self) -> list[NativeCapability]:
+        return [item for item in self.capabilities.values() if item.status == "unsupported"]
+
+    def unknown(self) -> list[NativeCapability]:
+        return [item for item in self.capabilities.values() if item.status == "unknown"]
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "runtime_kind": self.runtime_kind,
+            "target_table": self.target_table,
+            "spark_version": self.spark_version,
+            "capabilities": {name: item.as_dict() for name, item in self.capabilities.items()},
+        }