:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
"""
Capability surface for managed_warehouse.
Provisioning state, per-team backfill state, schema naming, Duckgres session setup,
and direct-connection lifecycle commands cross this boundary as contracts or narrow
commands. Django models remain implementation details of the product.
"""
from __future__ import annotations
from datetime import date
from typing import TYPE_CHECKING
from uuid import UUID
from products.managed_warehouse.backend import common, storage
from products.managed_warehouse.backend.common import DUCKGRES_BUCKET_REGION, EARLIEST_BACKFILL_DATE
from products.managed_warehouse.backend.facade.contracts import (
DuckgresQueryServerConfig,
DuckgresStoredBucketConfig,
DuckgresStoredServerConfig,
DuckLakeCatalogConnectionConfig,
ManagedWarehouseBackfillState,
ManagedWarehouseProvisionStatus,
ManagedWarehouseTarget,
)
if TYPE_CHECKING:
import psycopg
from products.managed_warehouse.backend.models import DuckgresServer
from products.warehouse_sources.backend.facade.models import ExternalDataSchema
__all__ = [
"DUCKGRES_BUCKET_REGION",
"EARLIEST_BACKFILL_DATE",
"default_bucket_region",
"deprovision_for_org_deletion",
"duckgres_data_imports_schema",
"duckgres_data_imports_table_name",
"duckgres_data_modeling_schema",
"ducklake_data_modeling_schema",
"get_data_modeling_table_name",
"get_catalog_connection_config",
"get_control_plane_bucket",
"get_duckgres_query_server_config",
"get_managed_warehouse_trino_password",
"get_org_id_for_team",
"get_managed_warehouse_target",
"managed_warehouse_domain",
"managed_warehouse_ingress_ips",
"get_team_deletion_block_reason",
"get_stored_bucket_config",
"get_stored_warehouse_config",
"get_team_backfill_state",
"get_warehouse_provision_status",
"has_provisioned_warehouse",
"is_data_modeling_shadow_ready",
"is_dev_mode",
"organization_is_pending_deletion",
"persist_duckgres_server_for_org",
"reconcile_stored_bucket_config",
"resolve_team_earliest_event_date",
"setup_duckgres_session",
"update_team_earliest_event_date",
"validate_schema_name",
]
def _to_stored_server_config(server: DuckgresServer) -> DuckgresStoredServerConfig:
catalog = None
if server.catalog_host:
catalog = DuckLakeCatalogConnectionConfig(
host=server.catalog_host,
port=server.catalog_port,
database=server.catalog_database,
username=server.catalog_username,
password=server.catalog_password,
)
bucket = None
if server.bucket:
bucket = DuckgresStoredBucketConfig(bucket=server.bucket, region=server.bucket_region)
return DuckgresStoredServerConfig(
organization_id=server.organization_id,
query_server=DuckgresQueryServerConfig(
host=server.host,
port=server.port,
flight_port=server.flight_port,
database=server.database,
username=server.username,
password=server.password,
),
catalog=catalog,
bucket=bucket,
)
def is_dev_mode() -> bool:
"""Whether Duckgres runs in the env-var-configured local mode."""
return common.is_dev_mode()
def default_bucket_region() -> str:
return common.default_bucket_region()
def get_managed_warehouse_target(organization_id: str, *, source_type: str) -> ManagedWarehouseTarget | None:
"""The managed warehouse `organization_id` may reach from a `source_type` source, or None.
The warehouse-source host guard is the only caller. It decides whether a source's host is
exempt from the private-address check, so it needs the control plane's own answer for this
organization rather than any stored row.
"""
from products.managed_warehouse.backend.managed_ingress import get_managed_warehouse_target as _get # noqa: PLC0415
return _get(organization_id, source_type=source_type)
def managed_warehouse_ingress_ips() -> tuple[str, ...]:
"""The address set the managed warehouse ingress answers on, read per call.
The warehouse-source host guard passes this to `ManagedWarehouseTarget.accepts`, so a settings
override in a test takes effect without a reload.
"""
from products.managed_warehouse.backend.managed_ingress import _ingress_ips # noqa: PLC0415
return _ingress_ips()
def managed_warehouse_domain() -> str:
"""The zone managed warehouse hostnames are served under in this deployment."""
from products.managed_warehouse.backend.managed_ingress import managed_warehouse_domain as _domain # noqa: PLC0415
return _domain()
def get_org_id_for_team(team_id: int) -> str:
return common._get_org_id_for_team(team_id)
def organization_is_pending_deletion(organization_id: str | UUID) -> bool:
from posthog.models.organization import Organization # noqa: PLC0415
return Organization.objects.filter(id=organization_id, is_pending_deletion=True).exists()
def get_stored_warehouse_config(organization_id: str) -> DuckgresStoredServerConfig | None:
server = common.get_duckgres_server_for_organization(organization_id)
return _to_stored_server_config(server) if server is not None else None
def get_warehouse_provision_status(organization_id: str) -> ManagedWarehouseProvisionStatus:
return ManagedWarehouseProvisionStatus(provisioned=has_provisioned_warehouse(organization_id))
def has_provisioned_warehouse(organization_id: str | UUID) -> bool:
from products.managed_warehouse.backend.models import DuckgresServer # noqa: PLC0415
return DuckgresServer.objects.filter(organization_id=organization_id).exists()
def is_data_modeling_shadow_ready(
*,
organization_id: str | UUID,
team_id: int,
) -> bool:
from products.managed_warehouse.backend.facade.cp_teams import ( # noqa: PLC0415 -- keeps control-plane imports off startup paths
get_org_team_membership,
)
from products.managed_warehouse.backend.trino_compiler import ( # noqa: PLC0415 -- keeps optional compiler imports off startup paths
get_ready_trino_catalog_name,
)
if get_ready_trino_catalog_name(str(organization_id)) is None:
return False
return get_org_team_membership(str(organization_id), team_id) is not None
def get_duckgres_query_server_config(organization_id: str) -> DuckgresQueryServerConfig:
config = common.get_duckgres_config_for_org(organization_id)
return DuckgresQueryServerConfig(
host=config["DUCKGRES_HOST"],
port=int(config["DUCKGRES_PORT"]),
flight_port=int(config["DUCKGRES_FLIGHT_PORT"]),
database=config["DUCKGRES_DATABASE"],
username=config["DUCKGRES_USERNAME"],
password=config["DUCKGRES_PASSWORD"],
)
def get_managed_warehouse_trino_password(organization_id: str) -> str:
return common.get_trino_password_for_org(organization_id)
def get_catalog_connection_config(organization_id: str) -> DuckLakeCatalogConnectionConfig | None:
stored = get_stored_warehouse_config(organization_id)
return stored.catalog if stored is not None else None
def get_stored_bucket_config(organization_id: str) -> DuckgresStoredBucketConfig | None:
stored = get_stored_warehouse_config(organization_id)
return stored.bucket if stored is not None else None
def persist_duckgres_server_for_org(
organization_id: str | UUID,
*,
host: str,
port: int,
database: str,
username: str,
password: str,
bucket: str | None = None,
bucket_region: str | None = None,
) -> DuckgresStoredServerConfig:
return _to_stored_server_config(
common.upsert_duckgres_server_for_org(
organization_id,
host=host,
port=port,
database=database,
username=username,
password=password,
bucket=bucket,
bucket_region=bucket_region,
)
)
def reconcile_stored_bucket_config(organization_id: str | UUID, *, bucket: str, bucket_region: str) -> bool:
from products.managed_warehouse.backend.models import DuckgresServer # noqa: PLC0415
return bool(
DuckgresServer.objects.filter(organization_id=organization_id)
.exclude(bucket=bucket, bucket_region=bucket_region)
.update(bucket=bucket, bucket_region=bucket_region)
)
def get_control_plane_bucket(organization_id: str | UUID) -> str | None:
from products.managed_warehouse.backend.presentation.views import cp_bucket_for # noqa: PLC0415
return cp_bucket_for(organization_id)
def update_team_earliest_event_date(
organization_id: str | UUID, team_id: int, earliest_event_date: date | None
) -> bool:
from products.managed_warehouse.backend.presentation.views import push_team_earliest_event_date # noqa: PLC0415
return push_team_earliest_event_date(organization_id, team_id, earliest_event_date)
def get_team_deletion_block_reason(team_id: int, organization_id: str | UUID) -> str | None:
from products.managed_warehouse.backend.presentation.views import block_team_deletion # noqa: PLC0415
return block_team_deletion(team_id, organization_id)
def deprovision_for_org_deletion(organization_id: str | UUID) -> None:
from products.managed_warehouse.backend.presentation.views import ( # noqa: PLC0415
deprovision_for_org_deletion as deprovision,
)
deprovision(organization_id)
def duckgres_data_imports_schema(team_id: int) -> str:
return common.duckgres_data_imports_schema(team_id)
def duckgres_data_imports_table_name(schema: ExternalDataSchema) -> str:
return common.duckgres_data_imports_table_name(schema)
def duckgres_data_modeling_schema(team_id: int) -> str:
return common.duckgres_data_modeling_schema(team_id)
def ducklake_data_modeling_schema(team_id: int) -> str:
return common.ducklake_data_modeling_schema(team_id)
def get_data_modeling_table_name(team_id: int, saved_query_id: UUID) -> str:
from products.managed_warehouse.backend.table_binding import (
get_data_modeling_table_names, # noqa: PLC0415 -- defer compiler dependencies until model resolution
)
return get_data_modeling_table_names(team_id, [saved_query_id])[saved_query_id]
def validate_schema_name(name: str | None) -> str | None:
return common.validate_schema_name(name)
def get_team_backfill_state(team_id: int) -> ManagedWarehouseBackfillState:
return common.get_team_backfill_state(team_id)
def resolve_team_earliest_event_date(team_id: int) -> date:
return common.resolve_team_earliest_event_date(team_id)
def setup_duckgres_session(
conn: psycopg.Connection,
extensions: tuple[str, ...] = ("ducklake", "httpfs", "delta"),
) -> None:
storage.setup_duckgres_session(conn, extensions)