contextbase-shared-plugins 0.2.3__py3-none-any.whl

contextbase_shared_plugins-0.2.3.dist-info/METADATA

@@ -0,0 +1,22 @@
+Metadata-Version: 2.3
+Name: contextbase-shared-plugins
+Version: 0.2.3
+Summary: Shared infrastructure for ContextBase plugins
+Author: Alizain Feerasta
+Author-email: Alizain Feerasta <alizain.feerasta@gmail.com>
+Requires-Dist: contextbase-shared-types==0.2.3
+Requires-Dist: airbyte
+Requires-Dist: azure-identity>=1.25.1
+Requires-Dist: dagster==1.12.14
+Requires-Dist: dagster-dlt==0.28.14
+Requires-Dist: dlt[postgres]>=1.26.0
+Requires-Dist: google-api-python-client>=2.185.0
+Requires-Dist: google-auth>=2.0.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: psycopg2-binary
+Requires-Dist: pyarrow>=22.0.0,<23.0.0
+Requires-Dist: pydantic>=2.12.0
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: pydantic-settings>=2.13.1
+Requires-Dist: tenacity>=8.2
+Requires-Python: >=3.14, <3.15

contextbase_shared_plugins-0.2.3.dist-info/RECORD

@@ -0,0 +1,37 @@
+shared_plugins/__init__.py,sha256=M6TV9owojVWO8c6E00UD1yA4-R1T_HsjnzP7sKr6Wl8,364
+shared_plugins/automation.py,sha256=ZFpRzQUnyH_J_GoSZCrYYWNO6OcsnvbQ_kjFS2BnetA,380
+shared_plugins/bindings.py,sha256=ex44eHvl-kePdN8ZyhVo0z2H_u-gNuZzxkcITEPfi_M,7559
+shared_plugins/control_plane.py,sha256=U00Xv7AG4wPRwsMcGoowQ1eexm5RpfWGNveFD_LwfRw,7271
+shared_plugins/dlt.py,sha256=YMJ3Gd-uCFuL8ppma7ghuOy3PzbulZUlZRSVy_1ibg8,2878
+shared_plugins/env.py,sha256=YqUva_GQegPPVHe99Y-JmthSbwNfUHehDetNxiN4Vr0,3487
+shared_plugins/exceptions.py,sha256=hV-Dn01TrvmFpMkRoNRy629KLL-Rdh3zi82z9JAodKM,318
+shared_plugins/google_client/__init__.py,sha256=56uWeZViYLtnuD5X5iSiwmbbZVSMSuRhpOhjpPrwrAk,62
+shared_plugins/google_client/auth.py,sha256=vHMik1ZypS2anYtgveveis3Jxk3lOFWRy_M83cFAPBo,2583
+shared_plugins/google_client/batch_retry.py,sha256=sVK-uPXgF4a-ZDWunN_k5PUJYk1FsgvJzLYX3qmKrp8,10167
+shared_plugins/google_client/http_errors.py,sha256=j_8vQ4URdnKYBatrkqSq2GHrRCgyHJZufyZIpvEn3S8,806
+shared_plugins/microsoft_dataverse/__init__.py,sha256=xMLs_ICxnVkCfvpUHy-YK7d3ufk6OmUpVtweWLoudS4,840
+shared_plugins/microsoft_dataverse/annotations.py,sha256=5Qz6RjCfcrkSUMEhdIvbcWo6r-AM449rJgDaRA_er_w,1567
+shared_plugins/microsoft_dataverse/auth.py,sha256=PrMvAgfAT5fZt66zes6ShEzppFGSWCu5PudO0Y4wR8k,627
+shared_plugins/microsoft_dataverse/binding_config.py,sha256=oFHYqKZHlKdcMQ98IOAdqt1KK2r2JwX716ny86lyS1c,1294
+shared_plugins/microsoft_dataverse/client.py,sha256=dDduQF5GuYCA76wuwmbfiQUwPttZ3tihg9dJh2TZcV4,16276
+shared_plugins/microsoft_dataverse/ctx.py,sha256=_nZYNPaDA9njvviwgMIdEKc815dnUM_CzwFGhqSMIpM,783
+shared_plugins/microsoft_dataverse/identifiers.py,sha256=OMzQI2vVgL4AvWHMybOyltpjqW2Sr7q_gHU4doJN6iE,2300
+shared_plugins/microsoft_dataverse/ingress.py,sha256=5PlVPxuzbY8whs6FjtTnqCVhFGHZnkzFzSgsf3RlO2U,2276
+shared_plugins/microsoft_dataverse/metadata.py,sha256=NV_JaviYd2JdOtMx1z1sN9ezMxGPWBO1XYt7COzG8s8,4510
+shared_plugins/microsoft_dataverse/runtime_schema.py,sha256=T1tNTX2CqOVGIBIY9YHNuc1dAFG60fD5owEH0224VD4,11554
+shared_plugins/microsoft_dataverse/source.py,sha256=Kn6WGbucWdDXD8OtsSf2e7dThhnXKpoQf41ZgtELLKM,7584
+shared_plugins/microsoft_dataverse/tables.py,sha256=j-20oGgYTUrc6De7_cni7nR9D9XfcHfa6zyOgc_FU1I,1192
+shared_plugins/microsoft_dataverse/translators.py,sha256=3sKhUrhYgrDGjP_ZXFv8XNkrhvDqRA93idzMYShCFLs,5081
+shared_plugins/microsoft_dataverse/types.py,sha256=G_e9NhvAQ6ljIwAxssH8VP6IZHEFKQ0s2DjSQ0xNiAY,11727
+shared_plugins/models.py,sha256=m4nNrPTmwR1zV2EoUvuwfhS_WjBi05x61_bShOso3j0,2669
+shared_plugins/naming.py,sha256=tE7oANx8SxGjfDzZT0GqDcObzFLs_RrS_B2vw_cdPjU,2208
+shared_plugins/pg_column_comments.py,sha256=HTSC8Og4jPXdBaiEhrAN__k2UOnb3E_6g38teLp2Q7s,2346
+shared_plugins/pyairbyte.py,sha256=iVPVjn2x1K07YVeDlJVMpuH26YRvXRJ0PxWwHlXdZQM,14038
+shared_plugins/resources.py,sha256=i-pVKSXmSBAjKh6-KfAppAcuGiPt4cerjExM6nxEqvs,5429
+shared_plugins/scratch.py,sha256=oZCJZSB5m80Ez7Ox8Ktl7rKV2vFIJyp8LBkZcXp6wlA,4176
+shared_plugins/sqlalchemy_types.py,sha256=1e_OxfUQzY377VlV4gidtVroK6FkgdOyMvgZeATxv8E,7123
+shared_plugins/sqlite.py,sha256=Pl3gXNixyQOrz19HgGojux0Ywkxukmub7rkwdkhU3QY,4301
+shared_plugins/values.py,sha256=DhTk62AvmPcfUvCa_n-dXN5zTdu4UN9tJeyjzMhGTl8,3199
+contextbase_shared_plugins-0.2.3.dist-info/WHEEL,sha256=i9aSRDivn5iP9LaR1BLQX2GNAuriQWPsFwbbWygTX2k,81
+contextbase_shared_plugins-0.2.3.dist-info/METADATA,sha256=_xi9qHr6p43ZyLcTXGVf-r6iAH5vXBpEwX2nm7OlJnU,771
+contextbase_shared_plugins-0.2.3.dist-info/RECORD,,

contextbase_shared_plugins-0.2.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.15
+Root-Is-Purelib: true
+Tag: py3-none-any

shared_plugins/__init__.py

@@ -0,0 +1,12 @@
+from .models import (
+    CtxModel as CtxModel,
+    IngressModel as IngressModel,
+    StrictModel as StrictModel,
+    partialize as partialize,
+)
+from .resources import (
+    ctx_dlt_resource as ctx_dlt_resource,
+    ctx_dlt_transformer as ctx_dlt_transformer,
+)
+
+import shared_plugins.pg_column_comments as _pg_column_comments  # noqa: F401  # side-effect import

shared_plugins/automation.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import dagster as dg
+
+
+def non_overlapping_automation_condition(
+    condition: dg.AutomationCondition,
+) -> dg.AutomationCondition:
+    # Cron and missing-based automation can keep requesting work while the
+    # current partition is still active unless we add this explicit guard.
+    return condition & ~dg.AutomationCondition.in_progress()

shared_plugins/bindings.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import os
+import sys
+from collections.abc import Callable, Collection, Iterable, Iterator
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Annotated, TypeVar
+
+from pydantic import (
+    BaseModel,
+    BeforeValidator,
+    ConfigDict,
+    Field,
+    StringConstraints,
+    ValidationError,
+)
+
+from shared_types.api_key_auth import ApiKeyAuth
+from shared_types.authenticated_account import AuthenticatedAccountRef
+from shared_types.binding_auth_none import BindingAuthNone
+from shared_types.client_credentials_auth import ClientCredentialsAuth
+from shared_types.dagster_binding_plan import DagsterAllPlanBinding
+
+from .exceptions import PluginConfigurationError
+from .models import CtxModel
+
+RowFilter = Callable[[str, CtxModel], bool]
+RowT = TypeVar("RowT", bound=CtxModel)
+
+_UTC_TIMESTAMP_PATTERN = r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$"
+
+NonEmptyText = Annotated[
+    str,
+    StringConstraints(strip_whitespace=True, min_length=1),
+]
+UtcTimestampText = Annotated[
+    str,
+    StringConstraints(
+        strip_whitespace=True,
+        min_length=1,
+        pattern=_UTC_TIMESTAMP_PATTERN,
+    ),
+]
+StrictNonNegativeInt = Annotated[int, Field(strict=True, ge=0)]
+ResolvedPath = Annotated[
+    Path, BeforeValidator(lambda value: _resolve_binding_path(value))
+]
+
+
+class BaseBindingConfigModel(BaseModel):
+    """Canonical base class for every plugin's ``BindingConfig`` and any nested
+    sub-models it uses.
+
+    Declares ``extra="forbid"`` once so plugins never redeclare it and cannot
+    accidentally allow unknown keys. Every ``BaseModel`` that lives inside a
+    plugin's ``binding_config.py`` inherits from this class, at every depth of
+    the config tree.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+
+BindingConfigT = TypeVar("BindingConfigT", bound=BaseBindingConfigModel)
+
+
+@dataclass(frozen=True)
+class ResolvedBindingModels:
+    active: tuple[str, ...]
+    filter: RowFilter | None
+
+
+def require_authenticated_account(
+    binding: DagsterAllPlanBinding,
+) -> AuthenticatedAccountRef:
+    auth_payload = binding.auth
+    if isinstance(auth_payload, AuthenticatedAccountRef):
+        return auth_payload
+
+    raise RuntimeError(
+        f"{binding.plugin_id} binding requires auth.type='authenticated_account', got '{auth_payload.type}'."
+    )
+
+
+def require_api_key(binding: DagsterAllPlanBinding) -> ApiKeyAuth:
+    auth_payload = binding.auth
+    if isinstance(auth_payload, ApiKeyAuth):
+        return auth_payload
+
+    raise RuntimeError(
+        f"{binding.plugin_id} binding requires auth.type='api_key', got '{auth_payload.type}'."
+    )
+
+
+def require_client_credentials(binding: DagsterAllPlanBinding) -> ClientCredentialsAuth:
+    auth_payload = binding.auth
+    if isinstance(auth_payload, ClientCredentialsAuth):
+        return auth_payload
+
+    raise RuntimeError(
+        f"{binding.plugin_id} binding requires auth.type='client_credentials', got '{auth_payload.type}'."
+    )
+
+
+def require_binding_auth_none(binding: DagsterAllPlanBinding) -> BindingAuthNone:
+    auth_payload = binding.auth
+    if isinstance(auth_payload, BindingAuthNone):
+        return auth_payload
+
+    raise RuntimeError(
+        f"{binding.plugin_id} binding requires auth.type='none', got '{auth_payload.type}'."
+    )
+
+
+def parse_binding_config(
+    binding: DagsterAllPlanBinding,
+    config_model: type[BindingConfigT],
+) -> BindingConfigT:
+    try:
+        return config_model.model_validate(binding.config)
+    except ValidationError as exc:
+        raise PluginConfigurationError(
+            f"{binding.plugin_id} binding.config is invalid: {exc}"
+        ) from exc
+
+
+def resolve_binding_models(
+    binding: DagsterAllPlanBinding,
+    *,
+    supported_models: Collection[str],
+    default_active: Collection[str] = (),
+) -> ResolvedBindingModels:
+    models_payload = binding.models
+    raw_active = (
+        default_active
+        if models_payload is None or models_payload.active is None
+        else models_payload.active
+    )
+    active_models = tuple(dict.fromkeys(raw_active))
+    unsupported_models = tuple(
+        model_name for model_name in active_models if model_name not in supported_models
+    )
+    if unsupported_models:
+        supported = ", ".join(sorted(supported_models))
+        unsupported = ", ".join(unsupported_models)
+        raise PluginConfigurationError(
+            f"{binding.plugin_id} models.active contains unsupported models [{unsupported}]. "
+            f"Supported models: [{supported}]."
+        )
+
+    return ResolvedBindingModels(
+        active=active_models,
+        filter=_load_row_filter(
+            None if models_payload is None else models_payload.filter,
+            plugin_id=binding.plugin_id,
+        ),
+    )
+
+
+def iter_active_model_rows(
+    *,
+    model_name: str,
+    rows: Iterable[RowT],
+    binding_models: ResolvedBindingModels,
+) -> Iterator[RowT]:
+    if model_name not in binding_models.active:
+        return
+
+    for row in rows:
+        if _should_keep_model_row(
+            model_name=model_name,
+            row=row,
+            binding_models=binding_models,
+        ):
+            yield row
+
+
+def _should_keep_model_row(
+    *,
+    model_name: str,
+    row: RowT,
+    binding_models: ResolvedBindingModels,
+) -> bool:
+    row_filter = binding_models.filter
+    if row_filter is None:
+        return True
+
+    return row_filter(model_name, row.model_copy(deep=True))
+
+
+def _load_row_filter(
+    filter_ref: str | None,
+    *,
+    plugin_id: str,
+) -> RowFilter | None:
+    if filter_ref is None:
+        return None
+
+    module_path_raw, separator, attr_name = filter_ref.partition(":")
+    if separator != ":" or not module_path_raw or not attr_name:
+        raise PluginConfigurationError(
+            f"Invalid {plugin_id} models.filter. Expected '<path.py>:<callable>'."
+        )
+
+    module_path = Path(module_path_raw).expanduser()
+    if not module_path.is_absolute():
+        module_path = (Path.cwd() / module_path).resolve()
+    else:
+        module_path = module_path.resolve()
+
+    if not module_path.is_file():
+        raise PluginConfigurationError(
+            f"{plugin_id} models.filter path does not exist: {module_path}"
+        )
+
+    module_name = _filter_module_name(module_path)
+    spec = importlib.util.spec_from_file_location(module_name, module_path)
+    if spec is None or spec.loader is None:
+        raise PluginConfigurationError(
+            f"Unable to load {plugin_id} models.filter module: {module_path}"
+        )
+
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[module_name] = module
+    spec.loader.exec_module(module)
+
+    row_filter = getattr(module, attr_name, None)
+    if not callable(row_filter):
+        raise PluginConfigurationError(
+            f"{plugin_id} models.filter '{filter_ref}' does not resolve to a callable"
+        )
+    return row_filter
+
+
+def _filter_module_name(module_path: Path) -> str:
+    digest = hashlib.sha1(str(module_path).encode("utf-8")).hexdigest()[:12]
+    return f"shared_plugins_binding_filter_{digest}"
+
+
+def _resolve_binding_path(value: object) -> Path:
+    if isinstance(value, Path):
+        path = value
+    elif isinstance(value, str):
+        stripped = value.strip()
+        if not stripped:
+            raise ValueError("Path values must not be empty.")
+        path = Path(os.path.expandvars(stripped)).expanduser()
+    else:
+        raise TypeError(f"Expected path-like value, got {type(value).__name__}")
+
+    return path.resolve(strict=False)

shared_plugins/control_plane.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from datetime import timezone
+from pathlib import Path
+from typing import Any
+
+import httpx
+from pydantic import ValidationError
+from shared_types.authenticated_account import AuthenticatedAccountRef
+from shared_types.dagster_binding_plan import (
+    DagsterAllPlanBinding,
+    DagsterBindingPlanAll,
+)
+from shared_types.oauth_access_token import OAuthAccessTokenSuccess
+
+from .models import format_validation_error
+
+_DAGSTER_BINDING_PLAN_PATH = "/api/v1/binding-plan"
+_OAUTH_ACCESS_TOKEN_PATH = "/api/v1/oauth-access-token"
+_OAUTH_REFRESH_ACCESS_TOKEN_PATH = "/api/v1/oauth-refresh-access-token"
+
+
+def _control_plane_endpoint(
+    control_plane_base_url: httpx.URL,
+    path: str,
+    *,
+    query: dict[str, str] | None = None,
+) -> str:
+    endpoint = control_plane_base_url.join(path)
+    if query:
+        endpoint = endpoint.copy_with(params=query)
+    return str(endpoint)
+
+
+def _parse_json_response(response: Any, *, endpoint: str, label: str) -> Any:
+    try:
+        return response.json()
+    except json.JSONDecodeError as exc:
+        raise RuntimeError(
+            f"{label} response from {endpoint} is not valid JSON: {exc.msg} (line {exc.lineno}, column {exc.colno})."
+        ) from exc
+
+
+class ControlPlaneClient:
+    def __init__(
+        self,
+        *,
+        control_plane_url: str,
+        root_dir: Path,
+        get: Callable[..., Any] | None = None,
+        post: Callable[..., Any] | None = None,
+    ) -> None:
+        normalized_control_plane_url = control_plane_url.strip()
+        if not normalized_control_plane_url:
+            raise RuntimeError("control_plane_url cannot be blank.")
+        if not normalized_control_plane_url.startswith(("http://", "https://")):
+            raise RuntimeError("control_plane_url must use http:// or https://.")
+
+        if not isinstance(root_dir, Path):
+            raise TypeError("root_dir must be a pathlib.Path.")
+        if not root_dir.is_absolute():
+            raise RuntimeError("root_dir must be an absolute path.")
+
+        self._control_plane_base_url = httpx.URL(
+            normalized_control_plane_url.rstrip("/")
+        )
+        self._root_dir = root_dir
+        self._get = httpx.get if get is None else get
+        self._post = httpx.post if post is None else post
+
+    def load_binding_plan(self) -> DagsterBindingPlanAll:
+        endpoint = _control_plane_endpoint(
+            self._control_plane_base_url,
+            _DAGSTER_BINDING_PLAN_PATH,
+            query={"mode": "dagster", "root_dir": str(self._root_dir)},
+        )
+
+        try:
+            response = self._get(endpoint, timeout=10.0)
+        except httpx.RequestError as exc:
+            raise RuntimeError(
+                f"Failed to fetch binding plan from {endpoint}: {exc}"
+            ) from exc
+
+        if response.status_code < 200 or response.status_code >= 300:
+            detail = response.text.strip() or "no response body"
+            raise RuntimeError(
+                f"Failed to fetch binding plan from {endpoint} (status={response.status_code}): {detail}"
+            )
+
+        payload = _parse_json_response(
+            response, endpoint=endpoint, label="Binding plan"
+        )
+
+        try:
+            plan = DagsterBindingPlanAll.model_validate(payload)
+        except ValidationError as exc:
+            error_message = format_validation_error(exc)
+            raise RuntimeError(
+                f"Binding plan response from {endpoint} failed model validation: {error_message}."
+            ) from exc
+
+        return plan.model_copy(
+            update={"generated_at": plan.generated_at.astimezone(timezone.utc)}
+        )
+
+    def list_active_bindings(self, plugin_id: str) -> list[DagsterAllPlanBinding]:
+        plan = self.load_binding_plan()
+        return [binding for binding in plan.bindings if binding.plugin_id == plugin_id]
+
+    def get_binding(self, plugin_id: str, binding_id: str) -> DagsterAllPlanBinding:
+        for binding in self.list_active_bindings(plugin_id):
+            if str(binding.binding_id) == binding_id:
+                return binding
+
+        raise RuntimeError(
+            f"Binding '{binding_id}' was not found for plugin_id '{plugin_id}'."
+        )
+
+    def get_access_token(
+        self,
+        auth: AuthenticatedAccountRef,
+    ) -> OAuthAccessTokenSuccess:
+        endpoint = _control_plane_endpoint(
+            self._control_plane_base_url,
+            _OAUTH_ACCESS_TOKEN_PATH,
+        )
+
+        try:
+            response = self._post(
+                endpoint,
+                json={
+                    "account_id": auth.account_id,
+                    "provider_id": auth.provider_id,
+                    "root_dir": str(self._root_dir),
+                },
+                timeout=10.0,
+            )
+        except httpx.RequestError as exc:
+            raise RuntimeError(
+                f"Failed to fetch OAuth access token from {endpoint}: {exc}"
+            ) from exc
+
+        if response.status_code != 200:
+            detail = response.text.strip() or "no response body"
+            raise RuntimeError(
+                f"Failed to fetch OAuth access token from {endpoint} (status={response.status_code}): {detail}"
+            )
+
+        payload = _parse_json_response(
+            response,
+            endpoint=endpoint,
+            label="OAuth access token",
+        )
+
+        try:
+            return OAuthAccessTokenSuccess.model_validate(payload)
+        except ValidationError as exc:
+            error_message = format_validation_error(exc)
+            raise RuntimeError(
+                f"OAuth access token response from {endpoint} failed model validation: {error_message}."
+            ) from exc
+
+    def refresh_access_token(
+        self,
+        auth: AuthenticatedAccountRef,
+    ) -> OAuthAccessTokenSuccess:
+        endpoint = _control_plane_endpoint(
+            self._control_plane_base_url,
+            _OAUTH_REFRESH_ACCESS_TOKEN_PATH,
+        )
+
+        try:
+            response = self._post(
+                endpoint,
+                json={
+                    "account_id": auth.account_id,
+                    "provider_id": auth.provider_id,
+                    "root_dir": str(self._root_dir),
+                },
+                timeout=10.0,
+            )
+        except httpx.RequestError as exc:
+            raise RuntimeError(
+                f"Failed to refresh OAuth access token from {endpoint}: {exc}"
+            ) from exc
+
+        if response.status_code != 200:
+            detail = response.text.strip() or "no response body"
+            raise RuntimeError(
+                f"Failed to refresh OAuth access token from {endpoint} (status={response.status_code}): {detail}"
+            )
+
+        payload = _parse_json_response(
+            response,
+            endpoint=endpoint,
+            label="OAuth refresh access token",
+        )
+
+        try:
+            return OAuthAccessTokenSuccess.model_validate(payload)
+        except ValidationError as exc:
+            error_message = format_validation_error(exc)
+            raise RuntimeError(
+                f"OAuth refresh access token response from {endpoint} failed model validation: {error_message}."
+            ) from exc

shared_plugins/dlt.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Any
+
+import dlt
+from dagster import AssetExecutionContext
+from dagster_dlt import DagsterDltResource
+from dlt.common.schema import Schema
+from dlt.destinations.sql_client import SqlClientBase
+from shared_types.dagster_binding_plan import DagsterAllPlanBinding
+
+from .control_plane import ControlPlaneClient
+from .naming import dlt_dataset_name, dlt_pipeline_name
+from .resources import DLT_TRANSLATOR
+
+DLT_DESTINATION = "postgres"
+
+
+def pre_register_source_schema(pipeline: Any, source: Any) -> None:
+    """Idempotently register an empty Schema for `source.name` on the
+    pipeline. This lets resources call `pipe.sql_client(schema_name=<source>)`
+    on cold start; without it, dlt's `_get_schema_or_create` falls through to
+    `Schema(pipeline_name)`, which raises `InvalidSchemaName` whenever the
+    pipeline_name exceeds dlt's 64-char Schema regex limit. Safe to call on
+    warm runs — `has_schema` short-circuits when the schema is already on
+    disk or restored from destination state."""
+    if not pipeline.schemas.has_schema(source.name):
+        pipeline.schemas.save_schema(Schema(source.name))
+
+
+def resolve_partition_binding(
+    *,
+    context: AssetExecutionContext,
+    control_plane: ControlPlaneClient,
+    plugin_id: str,
+) -> DagsterAllPlanBinding:
+    partition_key = context.partition_key
+    if partition_key is None:
+        raise RuntimeError("Missing partition key; expected binding_id partition.")
+
+    return control_plane.get_binding(plugin_id=plugin_id, binding_id=partition_key)
+
+
+def run_dlt_pipeline(
+    *,
+    context: AssetExecutionContext,
+    dlt_resource: DagsterDltResource,
+    source: Any,
+    plugin_id: str,
+    binding_id: str,
+    job_name: str,
+) -> Iterator[Any]:
+    pipeline = dlt.pipeline(
+        pipeline_name=dlt_pipeline_name(plugin_id, binding_id, job_name),
+        destination=DLT_DESTINATION,
+        dataset_name=dlt_dataset_name(plugin_id),
+        progress="log",
+    )
+    pre_register_source_schema(pipeline, source)
+    context.log.info(f"Starting {plugin_id} job={job_name} for binding_id={binding_id}")
+    yield from dlt_resource.run(
+        context=context,
+        dlt_source=source,
+        dlt_pipeline=pipeline,
+        dagster_dlt_translator=DLT_TRANSLATOR,
+    )
+    context.log.info(
+        f"Completed {plugin_id} job={job_name} for binding_id={binding_id}"
+    )
+
+
+def destination_has_table(
+    sql_client: SqlClientBase[Any],
+    table_name: str,
+) -> bool:
+    """Check whether a table exists in the dlt destination dataset."""
+    query = (
+        "SELECT 1 FROM information_schema.tables"
+        " WHERE table_schema = current_schema() AND table_name = %s"
+        " LIMIT 1"
+    )
+    with sql_client.execute_query(query, table_name) as cursor:
+        return cursor.fetchone() is not None