contractforge-databricks 0.1.0__py3-none-any.whl

contractforge_databricks/runtime/write_flow.py

@@ -0,0 +1,146 @@
+"""Prepared write flow for Databricks runtime ingestion."""
+
+from __future__ import annotations
+
+from time import perf_counter
+from typing import Any
+from typing import NamedTuple
+
+from contractforge_core.execution import ExecutionOutcome
+from contractforge_core.quality import QualityRuleResult
+from contractforge_core.runtime import PreparedInput, QueryOne, rows_written_from_outcome
+from contractforge_core.semantic import SemanticContract
+from contractforge_databricks.evidence import EvidenceWriter
+from contractforge_databricks.execution import SqlRunner, with_delta_retry
+from contractforge_databricks.runtime.governance import apply_runtime_governance
+from contractforge_databricks.runtime.maintenance import run_post_write_maintenance
+from contractforge_databricks.runtime.merge_validation import validate_merge_source_safety
+from contractforge_databricks.runtime.models import DatabricksIngestOptions
+from contractforge_databricks.runtime.partitioning import replace_partition_predicate, target_partition_predicate
+from contractforge_databricks.runtime.schema import setup_and_sync_schema
+from contractforge_databricks.runtime.utils import utc_now_str
+from contractforge_databricks.runtime.write import execute_prepared_write
+
+
+class WriteFlowResult(NamedTuple):
+    outcome: ExecutionOutcome
+    logical_rows_written: int
+    schema_changes: dict[str, Any]
+    governance_results: dict[str, Any]
+    write_started_at: str
+    write_finished_at: str
+    stage_durations: dict[str, float]
+
+
+def execute_runtime_write_flow(
+    *,
+    runner: SqlRunner,
+    evidence: EvidenceWriter,
+    contract: SemanticContract,
+    prepared: PreparedInput,
+    opts: DatabricksIngestOptions,
+    run_id: str,
+    target: str,
+    query_one: QueryOne | None = None,
+    quality_results: tuple[QualityRuleResult, ...] = (),
+) -> WriteFlowResult:
+    stage_durations: dict[str, float] = {}
+    schema_start = perf_counter()
+    schema_changes = setup_and_sync_schema(
+        runner=runner,
+        evidence=evidence,
+        contract=contract,
+        prepared=prepared,
+        run_id=run_id,
+        ensure_table=opts.ensure_table,
+        target_schema=opts.target_schema,
+    )
+    stage_durations["schema"] = _elapsed(schema_start)
+    validation_start = perf_counter()
+    validate_merge_source_safety(
+        contract=contract,
+        prepared=prepared,
+        query_one=query_one,
+        quality_results=quality_results,
+    )
+    stage_durations["preflight"] = _elapsed(validation_start)
+    write_started_at = _utc_now()
+    write_start = perf_counter()
+    outcome = with_delta_retry(
+        lambda: execute_prepared_write(
+            runner=runner,
+            contract=contract,
+            prepared=prepared,
+            replace_partition_predicate=replace_partition_predicate(
+                contract=contract,
+                prepared=prepared,
+                query_one=query_one,
+            ),
+            target_schema=opts.target_schema,
+            query_one=query_one,
+            target_partition_predicate=target_partition_predicate(
+                contract=contract,
+                prepared=prepared,
+                query_one=query_one,
+            ),
+        ),
+        attempts=_retry_attempts(contract),
+        backoff_seconds=_retry_backoff_seconds(contract),
+        jitter=lambda: 0.0,
+    )
+    write_finished_at = _utc_now()
+    stage_durations["write"] = _elapsed(write_start)
+    logical_rows_written = rows_written_from_outcome(prepared, outcome)
+    maintenance_start = perf_counter()
+    run_post_write_maintenance(
+        runner=runner,
+        contract=contract,
+        target_table=target,
+        outcome=outcome,
+        rows_written=logical_rows_written,
+    )
+    stage_durations["maintenance"] = _elapsed(maintenance_start)
+    governance_start = perf_counter()
+    governance_results = apply_runtime_governance(
+        runner=runner,
+        contract=contract,
+        run_id=run_id,
+        evidence_catalog=opts.catalog,
+        evidence_schema=opts.schema,
+    )
+    stage_durations["governance"] = _elapsed(governance_start)
+    return WriteFlowResult(
+        outcome,
+        logical_rows_written,
+        schema_changes,
+        governance_results,
+        write_started_at,
+        write_finished_at,
+        stage_durations,
+    )
+
+
+def _retry_attempts(contract: SemanticContract) -> int:
+    metadata = contract.operations.metadata if contract.operations and contract.operations.metadata else {}
+    value = metadata.get("retry_attempts", 1)
+    try:
+        return max(1, int(value))
+    except (TypeError, ValueError):
+        return 1
+
+
+def _retry_backoff_seconds(contract: SemanticContract) -> float:
+    metadata = contract.operations.metadata if contract.operations and contract.operations.metadata else {}
+    value = metadata.get("retry_backoff_seconds", 1.0)
+    try:
+        return max(0.0, float(value))
+    except (TypeError, ValueError):
+        return 1.0
+
+
+def _utc_now() -> str:
+    return utc_now_str()
+
+
+def _elapsed(start: float) -> float:
+    return round(perf_counter() - start, 6)

contractforge_databricks/runtime/write_strategy.py

@@ -0,0 +1,40 @@
+"""Runtime write-engine evidence for Databricks ingestion."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from contractforge_core.semantic import SemanticContract
+from contractforge_databricks.capabilities import evaluate_databricks_capabilities
+from contractforge_databricks.contract_extensions import databricks_extensions
+from contractforge_databricks.write_modes import choose_write_strategy
+
+
+def write_strategy_evidence(contract: SemanticContract, target: str, runtime: dict[str, Any]) -> dict[str, str]:
+    capabilities = evaluate_databricks_capabilities(
+        target_table=target,
+        runtime_type=str(runtime.get("runtime_type") or "serverless"),
+        spark_version=str(runtime["spark_version"]) if runtime.get("spark_version") else None,
+    )
+    strategy = choose_write_strategy(contract, capabilities)
+    return {
+        "write_engine_requested": _requested_engine(contract),
+        "write_engine_selected": strategy.engine,
+        "write_engine_status": strategy.kind,
+        "write_engine_reason": strategy.reason,
+        "write_engine_fallback_policy": _fallback_policy(contract),
+    }
+
+
+def _requested_engine(contract: SemanticContract) -> str:
+    write_engine = databricks_extensions(contract).get("write_engine")
+    if isinstance(write_engine, dict):
+        return str(write_engine.get("requested") or write_engine.get("engine") or "auto")
+    return str(write_engine or "auto")
+
+
+def _fallback_policy(contract: SemanticContract) -> str:
+    write_engine = databricks_extensions(contract).get("write_engine")
+    if isinstance(write_engine, dict):
+        return str(write_engine.get("fallback_policy") or "fail")
+    return "fail"

contractforge_databricks/schema/__init__.py

@@ -0,0 +1,21 @@
+from contractforge_core.schema import (
+    SchemaDiff,
+    TypeChange,
+    compare_schema,
+    is_type_widening,
+    validate_schema_diff,
+)
+from contractforge_databricks.schema.policy import DatabricksSchemaPolicyPlan, plan_schema_policy
+from contractforge_databricks.schema.sync import render_add_columns_sql, render_type_widening_sql
+
+__all__ = [
+    "DatabricksSchemaPolicyPlan",
+    "SchemaDiff",
+    "TypeChange",
+    "compare_schema",
+    "is_type_widening",
+    "plan_schema_policy",
+    "render_add_columns_sql",
+    "render_type_widening_sql",
+    "validate_schema_diff",
+]

contractforge_databricks/schema/diff.py

@@ -0,0 +1,11 @@
+"""Compatibility exports for platform-neutral schema diff helpers."""
+
+from contractforge_core.schema import SchemaDiff, TypeChange, compare_schema, is_type_widening, validate_schema_diff
+
+__all__ = [
+    "SchemaDiff",
+    "TypeChange",
+    "compare_schema",
+    "is_type_widening",
+    "validate_schema_diff",
+]

contractforge_databricks/schema/policy.py

@@ -0,0 +1,33 @@
+"""Databricks schema policy planning."""
+
+from __future__ import annotations
+
+from contractforge_core.schema import SchemaPolicyPlan
+from contractforge_core.semantic import SemanticContract
+
+DatabricksSchemaPolicyPlan = SchemaPolicyPlan
+
+
+def plan_schema_policy(contract: SemanticContract) -> DatabricksSchemaPolicyPlan:
+    policy = contract.write.schema_policy
+    if policy == "strict":
+        return DatabricksSchemaPolicyPlan(
+            policy=policy,
+            writer_options={},
+            preflight_required=True,
+            reason="Strict schema requires adapter preflight comparison before Delta write.",
+        )
+    if policy == "additive_only":
+        return DatabricksSchemaPolicyPlan(
+            policy=policy,
+            writer_options={"mergeSchema": "true"},
+            preflight_required=True,
+            reason="Additive-only schema allows new nullable columns after preflight validation.",
+        )
+    return DatabricksSchemaPolicyPlan(
+        policy=policy,
+        writer_options={"mergeSchema": "true"},
+        preflight_required=True,
+        reason="Permissive schema can use Delta schema merge, but type widening still requires evidence.",
+        warnings=("type widening must be recorded as schema-change evidence",),
+    )

contractforge_databricks/schema/sync.py

@@ -0,0 +1,23 @@
+"""Render Databricks SQL for validated schema changes."""
+
+from __future__ import annotations
+
+from contractforge_core.schema import SchemaDiff
+from contractforge_databricks.sql import quote_identifier, quote_table_name
+
+
+def render_add_columns_sql(*, target_table: str, source_schema: dict[str, str], diff: SchemaDiff) -> str:
+    columns = [column for column in diff.added_columns if column in source_schema]
+    if not columns:
+        return "-- No additive schema changes to apply.\n"
+    cols_sql = ", ".join(f"{quote_identifier(column)} {source_schema[column]}" for column in columns)
+    return f"ALTER TABLE {quote_table_name(target_table)} ADD COLUMNS ({cols_sql})"
+
+
+def render_type_widening_sql(*, target_table: str, diff: SchemaDiff) -> str:
+    statements = [
+        f"ALTER TABLE {quote_table_name(target_table)} ALTER COLUMN {quote_identifier(change.column)} TYPE {change.source_type}"
+        for change in diff.type_changes
+        if change.allowed
+    ]
+    return ";\n".join(statements) + (";\n" if statements else "-- No type widening changes to apply.\n")

contractforge_databricks/security/__init__.py

@@ -0,0 +1,21 @@
+from contractforge_core.errors import exception_message, short_error_message
+from contractforge_core.security import redact_text, redact_value
+from contractforge_databricks.security.secrets import (
+    assert_no_inline_jdbc_secrets,
+    contains_secret_placeholder,
+    resolve_databricks_secret_placeholders,
+    secret_placeholder_refs,
+)
+from contractforge_databricks.security.source_policy import validate_source_security
+
+__all__ = [
+    "exception_message",
+    "assert_no_inline_jdbc_secrets",
+    "contains_secret_placeholder",
+    "redact_text",
+    "redact_value",
+    "resolve_databricks_secret_placeholders",
+    "secret_placeholder_refs",
+    "short_error_message",
+    "validate_source_security",
+]

contractforge_databricks/security/errors.py

@@ -0,0 +1,5 @@
+"""Compatibility exports for platform-neutral operational error normalization."""
+
+from contractforge_core.errors import exception_message, short_error_message
+
+__all__ = ["exception_message", "short_error_message"]

contractforge_databricks/security/redaction.py

@@ -0,0 +1,5 @@
+"""Compatibility exports for platform-neutral redaction helpers."""
+
+from contractforge_core.security import REDACTED, redact_text, redact_value
+
+__all__ = ["REDACTED", "redact_text", "redact_value"]

contractforge_databricks/security/secrets.py

@@ -0,0 +1,114 @@
+"""Databricks-owned secret placeholder resolution."""
+
+from __future__ import annotations
+
+import os
+import re
+from collections.abc import Mapping
+from typing import Any
+
+SECRET_PLACEHOLDER_RE = re.compile(r"\{\{\s*secret:[^}]+\}\}", re.IGNORECASE)
+ENV_OVERRIDE_FLAG = "CONTRACTFORGE_ALLOW_SECRET_ENV_OVERRIDE"
+_TRUE_VALUES = {"1", "true", "yes", "on"}
+_SENSITIVE_JDBC_OPTION_KEYS = ("password", "sfpassword")
+_URL_INLINE_CREDENTIALS_RE = re.compile(r"://[^/@\s]+:[^/@\s]+@")
+
+
+def contains_secret_placeholder(value: Any) -> bool:
+    """Return True if a string or nested value contains a secret placeholder."""
+
+    if isinstance(value, Mapping):
+        return any(contains_secret_placeholder(item) for item in value.values())
+    if isinstance(value, (list, tuple)):
+        return any(contains_secret_placeholder(item) for item in value)
+    if isinstance(value, str):
+        return SECRET_PLACEHOLDER_RE.search(value) is not None
+    return False
+
+
+def secret_placeholder_refs(value: str) -> tuple[tuple[str, str], ...]:
+    """Return ``(scope, key)`` references found in a placeholder-bearing string."""
+
+    return tuple(_parse_secret_ref(match.group(0)[2:-2].strip()) for match in SECRET_PLACEHOLDER_RE.finditer(value))
+
+
+def assert_no_inline_jdbc_secrets(options: Mapping[str, Any]) -> None:
+    """Refuse JDBC options that declare raw credentials in the contract.
+
+    Databricks resolves ``{{ secret:scope/key }}`` placeholders at runtime via
+    dbutils. Accepting a literal JDBC password or URL credential would put the
+    secret in versioned contract files and review artifacts before the adapter
+    ever has a chance to redact it.
+    """
+
+    for key in _SENSITIVE_JDBC_OPTION_KEYS:
+        if key in options and not contains_secret_placeholder(options[key]) and str(options[key]) != "{{rds_iam_token}}":
+            raise ValueError(
+                f"JDBC '{key}' must be provided via a {{{{ secret:scope/key }}}} placeholder "
+                "or adapter-owned runtime authentication; inline credentials are not accepted."
+            )
+    url = str(options.get("url") or "")
+    if _URL_INLINE_CREDENTIALS_RE.search(url) and not contains_secret_placeholder(url):
+        raise ValueError(
+            "JDBC url embeds inline credentials; move them to auth using {{ secret:scope/key }} placeholders."
+        )
+
+
+def resolve_databricks_secret_placeholders(value: Any) -> Any:
+    """Resolve ``{{ secret:scope/key }}`` placeholders recursively at adapter runtime."""
+
+    if isinstance(value, Mapping):
+        return {key: resolve_databricks_secret_placeholders(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [resolve_databricks_secret_placeholders(item) for item in value]
+    if isinstance(value, tuple):
+        return tuple(resolve_databricks_secret_placeholders(item) for item in value)
+    if isinstance(value, str):
+        return SECRET_PLACEHOLDER_RE.sub(lambda match: _resolve_secret_token(match.group(0)[2:-2].strip()), value)
+    return value
+
+
+def _env_override_enabled() -> bool:
+    """Return True only when CONTRACTFORGE_ALLOW_SECRET_ENV_OVERRIDE is explicitly on.
+
+    Honoring CONTRACTFORGE_SECRET_* env vars by default lets anyone who can
+    set cluster environment variables (init scripts, cluster policies) shadow
+    a secret coming from dbutils.secrets without an audit trail. Gating the
+    behavior behind a single explicit flag keeps the override available for
+    runtime token injection (e.g. RDS IAM tokens) while making the resolver
+    safe-by-default in shared workspaces.
+    """
+
+    raw = os.environ.get(ENV_OVERRIDE_FLAG, "")
+    return raw.strip().lower() in _TRUE_VALUES
+
+
+def _resolve_secret_token(token: str) -> str:
+    scope, key = _parse_secret_ref(token)
+    if _env_override_enabled():
+        env_name = f"CONTRACTFORGE_SECRET_{scope}_{key}".upper().replace("-", "_").replace(".", "_")
+        if env_name in os.environ:
+            return os.environ[env_name]
+    return str(_dbutils().secrets.get(scope=scope, key=key))
+
+
+def _parse_secret_ref(token: str) -> tuple[str, str]:
+    ref = token[len("secret:") :].strip() if token.lower().startswith("secret:") else token.strip()
+    if "/" not in ref:
+        raise ValueError("Secret placeholder must use format {{ secret:scope/key }}")
+    scope, key = [part.strip() for part in ref.split("/", 1)]
+    if not scope or not key:
+        raise ValueError("Secret placeholder requires non-empty scope and key")
+    return scope, key
+
+
+def _dbutils() -> Any:
+    try:
+        from IPython import get_ipython  # type: ignore
+
+        shell = get_ipython()
+        if shell and "dbutils" in shell.user_ns:
+            return shell.user_ns["dbutils"]
+    except Exception:
+        pass
+    raise RuntimeError("Could not resolve dbutils to access Databricks Secrets")

contractforge_databricks/security/source_policy.py

@@ -0,0 +1,17 @@
+"""Databricks source-level security policy checks."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from contractforge_core.connectors import JDBC_CONNECTORS, jdbc_common_options
+from contractforge_databricks.security.secrets import assert_no_inline_jdbc_secrets
+
+
+def validate_source_security(source: dict[str, Any]) -> None:
+    """Validate adapter security policy before runtime placeholder resolution."""
+
+    source_type = source.get("type")
+    connector = source.get("connector")
+    if source_type == "jdbc" or connector in JDBC_CONNECTORS:
+        assert_no_inline_jdbc_secrets(jdbc_common_options(source))

contractforge_databricks/shapes/__init__.py

@@ -0,0 +1,3 @@
+from contractforge_databricks.shapes.sql import render_shape_sql
+
+__all__ = ["render_shape_sql"]

contractforge_databricks/shapes/sql.py

@@ -0,0 +1,123 @@
+"""Databricks SQL review rendering for core shape intent."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from contractforge_core.semantic import SemanticContract
+from contractforge_databricks.sql import quote_identifier, quote_table_name
+
+
+def render_shape_sql(
+    contract: SemanticContract,
+    *,
+    source_view: str = "${source_view}",
+    output_view: str = "${shaped_view}",
+) -> str:
+    if not contract.shape:
+        return "-- No shape declared.\n"
+    shape = contract.shape.raw
+    lines = [
+        "-- Shape SQL review artifact.",
+        "-- Databricks runtime may execute equivalent PySpark preparation for complex nested schemas.",
+        f"CREATE OR REPLACE TEMP VIEW {quote_table_name(output_view)} AS",
+        "SELECT",
+        ",\n".join(f"  {item}" for item in _select_items(shape)),
+        f"FROM {_from_clause(shape, source_view)}",
+    ]
+    return "\n".join(lines) + ";\n" + _review_notes(shape)
+
+
+def _select_items(shape: dict[str, Any]) -> list[str]:
+    items: list[str] = ["*"]
+    for config in shape.get("parse_json", ()):
+        column = str(config["column"])
+        schema = config.get("schema") or f"${{schema:{config.get('schema_ref')}}}"
+        alias = str(config.get("alias") or column)
+        cast_input = str(config.get("cast_input") or "").strip().upper()
+        source_expr = _path_expr(column)
+        if cast_input == "STRING":
+            source_expr = f"CAST({source_expr} AS STRING)"
+        items.append(f"from_json({source_expr}, '{schema}') AS {quote_identifier(alias)}")
+    for config in shape.get("zip_arrays", ()):
+        columns = ", ".join(_path_expr(path) for path in config.get("columns", {}))
+        items.append(f"arrays_zip({columns}) AS {quote_identifier(str(config['alias']))}")
+    for config in shape.get("arrays", ()):
+        rendered = _array_item(config)
+        if rendered:
+            items.append(rendered)
+    if shape.get("columns"):
+        return _projection_items(shape["columns"])
+    return items
+
+
+def _projection_items(columns: dict[str, Any]) -> list[str]:
+    items = []
+    for path, config in columns.items():
+        if isinstance(config, str):
+            alias = config
+            expr = _path_expr(path)
+        else:
+            alias = str(config.get("alias") or _default_alias(path))
+            expr = str(config["expression"]) if config.get("expression") else _path_expr(path)
+            if config.get("cast"):
+                expr = f"CAST({expr} AS {config['cast']})"
+        items.append(f"{expr} AS {quote_identifier(alias)}")
+    return items
+
+
+def _array_item(config: dict[str, Any]) -> str | None:
+    path = str(config["path"])
+    alias = str(config.get("alias") or _default_alias(path))
+    mode = str(config.get("mode", "keep"))
+    expr = _path_expr(path)
+    if mode == "keep":
+        return None
+    if mode == "to_json":
+        return f"to_json({expr}) AS {quote_identifier(alias)}"
+    if mode == "size":
+        return f"size({expr}) AS {quote_identifier(alias)}"
+    if mode == "first":
+        return f"element_at({expr}, 1) AS {quote_identifier(alias)}"
+    if mode == "explode":
+        return f"explode({expr}) AS {quote_identifier(alias)}"
+    if mode == "explode_outer":
+        return f"explode_outer({expr}) AS {quote_identifier(alias)}"
+    return None
+
+
+def _from_clause(shape: dict[str, Any], source_view: str) -> str:
+    if _flatten_enabled(shape):
+        return f"{quote_table_name(source_view)} -- flatten requires schema-aware expansion"
+    return quote_table_name(source_view)
+
+
+def _review_notes(shape: dict[str, Any]) -> str:
+    notes = []
+    if _flatten_enabled(shape):
+        flatten = shape.get("flatten")
+        separator = flatten.get("separator", "_") if isinstance(flatten, dict) else "_"
+        notes.append(f"-- flatten: enabled with separator {separator!r}; runtime must expand struct leaves.")
+    changing = [
+        config["path"]
+        for config in shape.get("arrays", ())
+        if config.get("mode") in {"explode", "explode_outer"}
+    ]
+    if changing and not shape.get("allow_cardinality_change_on_bronze", False):
+        notes.append("-- cardinality review: explode/explode_outer changes row counts and may require layer policy review.")
+    return ("\n".join(notes) + "\n") if notes else ""
+
+
+def _flatten_enabled(shape: dict[str, Any]) -> bool:
+    flatten = shape.get("flatten")
+    if isinstance(flatten, bool):
+        return flatten
+    return isinstance(flatten, dict) and bool(flatten.get("enabled"))
+
+
+def _path_expr(path: str) -> str:
+    return ".".join(quote_identifier(part) for part in str(path).split("."))
+
+
+def _default_alias(path: str) -> str:
+    return str(path).replace(".", "_")

contractforge_databricks/sources/__init__.py

@@ -0,0 +1,67 @@
+from contractforge_databricks.sources.autoloader import render_autoloader_python
+from contractforge_databricks.sources.artifacts import render_source_artifacts
+from contractforge_databricks.sources.bounded_streams import (
+    eventhubs_bounded_options,
+    is_bounded_stream_source,
+    kafka_bounded_options,
+    render_bounded_stream_python,
+    render_eventhubs_bounded_python,
+    render_kafka_bounded_python,
+)
+from contractforge_databricks.sources.delta_share import (
+    delta_share_options,
+    is_delta_share_source,
+    render_delta_share_python,
+)
+from contractforge_databricks.sources.files import (
+    is_catalog_source,
+    is_file_source,
+    render_catalog_source_python,
+    render_file_source_python,
+)
+from contractforge_databricks.sources.http_file import is_http_file_source, render_http_file_python
+from contractforge_databricks.sources.interpret import interpret_incremental_files_source, is_incremental_file_source
+from contractforge_databricks.sources.jdbc import jdbc_options, render_jdbc_python
+from contractforge_databricks.sources.metadata import render_source_metadata_json, source_metadata_from_contract
+from contractforge_databricks.sources.native_passthrough import render_native_passthrough_plan
+from contractforge_databricks.sources.rds_iam import (
+    generate_rds_iam_auth_token,
+    infer_aws_region_from_rds_host,
+    parse_jdbc_host_port,
+)
+from contractforge_databricks.sources.rest_api import is_rest_api_connector, render_rest_api_review_plan
+from contractforge_databricks.sources.support import databricks_source_support, list_databricks_source_support
+
+__all__ = [
+    "is_catalog_source",
+    "is_bounded_stream_source",
+    "is_delta_share_source",
+    "is_file_source",
+    "is_http_file_source",
+    "is_incremental_file_source",
+    "is_rest_api_connector",
+    "interpret_incremental_files_source",
+    "eventhubs_bounded_options",
+    "delta_share_options",
+    "generate_rds_iam_auth_token",
+    "jdbc_options",
+    "infer_aws_region_from_rds_host",
+    "kafka_bounded_options",
+    "list_databricks_source_support",
+    "parse_jdbc_host_port",
+    "render_autoloader_python",
+    "render_bounded_stream_python",
+    "render_catalog_source_python",
+    "render_delta_share_python",
+    "render_eventhubs_bounded_python",
+    "render_file_source_python",
+    "render_http_file_python",
+    "render_jdbc_python",
+    "render_kafka_bounded_python",
+    "render_native_passthrough_plan",
+    "render_rest_api_review_plan",
+    "render_source_artifacts",
+    "render_source_metadata_json",
+    "source_metadata_from_contract",
+    "databricks_source_support",
+]