frontier-runner 0.1.1__py3-none-any.whl

frontier/__init__.py

@@ -0,0 +1,3 @@
+"""Customer-side Frontier runner."""
+
+__version__ = "0.1.1"

frontier/__main__.py

@@ -0,0 +1,4 @@
+from frontier.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

frontier/adapters/__init__.py

@@ -0,0 +1,8 @@
+from frontier.warehouse import WAREHOUSE_TYPES, WarehouseAdapter, connect_warehouse, open_adapter
+
+__all__ = [
+    "WAREHOUSE_TYPES",
+    "WarehouseAdapter",
+    "connect_warehouse",
+    "open_adapter",
+]

frontier/adapters/base.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import Any
+
+from frontier.config import ConfigError
+from frontier.warehouse import (
+    sql_string,
+    split_relation_parts,
+)
+
+
+class CursorAdapter:
+    """Shared execute/close for DB-API style connections."""
+
+    warehouse_type: str
+    dialect: str
+    _connection: Any = None
+    last_query_id: str | None = None
+
+    def execute(self, sql: str) -> list[tuple[Any, ...]]:
+        connection = self._require_connection()
+        cursor = connection.cursor()
+        try:
+            cursor.execute(sql)
+            self.last_query_id = getattr(cursor, "sfqid", None) or getattr(cursor, "sfqId", None)
+            if self.last_query_id is not None:
+                self.last_query_id = str(self.last_query_id)
+            if cursor.description is None:
+                return []
+            rows = cursor.fetchall() or []
+            return [tuple(row) for row in rows]
+        finally:
+            cursor.close()
+
+    def get_query_profile(self, query_id: str) -> dict[str, Any]:
+        del query_id
+        return {}
+
+    def close(self) -> None:
+        connection = self._connection
+        if connection is not None:
+            connection.close()
+            self._connection = None
+
+    def _require_connection(self) -> Any:
+        if self._connection is None:
+            raise ConfigError(f"{self.warehouse_type} adapter is not connected")
+        return self._connection
+
+    def _table_lookup_sql(self, relation: str) -> str:
+        catalog, schema, table = split_relation_parts(relation)
+        sql = (
+            "select 1 as present from information_schema.tables "
+            f"where lower(table_name) = lower({sql_string(table)})"
+        )
+        if schema:
+            sql += f" and lower(table_schema) = lower({sql_string(schema)})"
+        if catalog:
+            sql += f" and lower(table_catalog) = lower({sql_string(catalog)})"
+        return sql + " limit 1"
+
+    def relation_exists(self, relation: str) -> bool:
+        return bool(self.execute(self._table_lookup_sql(relation)))
+
+    def estimate_query_cost(self, sql: str) -> dict[str, Any]:
+        try:
+            rows = self.execute(f"explain {sql}")
+        except Exception:
+            return {"estimated": False, "warehouse_type": self.warehouse_type}
+        return {
+            "estimated": True,
+            "warehouse_type": self.warehouse_type,
+            "plan_rows": len(rows),
+        }
+
+    def get_query_history(self, run_id: str) -> list[dict[str, Any]]:
+        return []

frontier/adapters/bigquery.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from typing import Any
+
+from frontier.config import ConfigError, redact
+from frontier.warehouse import (
+    env_value,
+    quote_identifier,
+    split_relation_parts,
+    sql_string,
+)
+
+
+class BigQueryAdapter:
+    warehouse_type = "bigquery"
+    dialect = "bigquery"
+
+    def __init__(self, client: Any | None = None, *, project: str | None = None, dataset: str | None = None):
+        self._client = client
+        self.project = project
+        self.dataset = dataset
+
+    def quote_identifier(self, value: str) -> str:
+        return quote_identifier(value, "`")
+
+    def execute(self, sql: str) -> list[tuple[Any, ...]]:
+        client = self._require_client()
+        rows = list(client.query(sql).result())
+        return [tuple(row.values()) for row in rows]
+
+    def relation_exists(self, relation: str) -> bool:
+        catalog, schema, table = split_relation_parts(relation)
+        project = catalog or self.project
+        dataset = schema or self.dataset
+        if not project or not dataset:
+            raise ConfigError("BigQuery relation_exists needs project and dataset")
+        sql = (
+            f"select 1 from `{project}.{dataset}.INFORMATION_SCHEMA.TABLES` "
+            f"where lower(table_name) = lower({sql_string(table)}) "
+            "limit 1"
+        )
+        return bool(self.execute(sql))
+
+    def estimate_query_cost(self, sql: str) -> dict[str, Any]:
+        client = self._require_client()
+        job_config = _dry_run_config()
+        job = client.query(sql, job_config=job_config)
+        bytes_processed = int(getattr(job, "total_bytes_processed", 0) or 0)
+        return {
+            "estimated": True,
+            "warehouse_type": self.warehouse_type,
+            "total_bytes_processed": bytes_processed,
+        }
+
+    def get_query_history(self, run_id: str) -> list[dict[str, Any]]:
+        project = self.project
+        if not project:
+            return []
+        tagged = sql_string(run_id)
+        sql = (
+            f"select job_id, state, total_bytes_processed "
+            f"from `{project}.region-us.INFORMATION_SCHEMA.JOBS_BY_PROJECT` "
+            f"where query like '%' || {tagged} || '%' "
+            "order by creation_time desc limit 50"
+        )
+        try:
+            rows = self.execute(sql)
+        except Exception:
+            return []
+        return [
+            {"query_id": row[0], "status": row[1], "bytes": row[2] if len(row) > 2 else None}
+            for row in rows
+        ]
+
+    def close(self) -> None:
+        client = self._client
+        if client is not None and hasattr(client, "close"):
+            client.close()
+        self._client = None
+
+    def describe(self) -> dict[str, Any]:
+        return redact(
+            {
+                "warehouse_type": self.warehouse_type,
+                "project": self.project,
+                "dataset": self.dataset,
+            }
+        )
+
+    def _require_client(self) -> Any:
+        if self._client is None:
+            raise ConfigError("bigquery adapter is not connected")
+        return self._client
+
+
+def _dry_run_config() -> Any:
+    from google.cloud import bigquery
+
+    return bigquery.QueryJobConfig(dry_run=True, use_query_cache=False)
+
+
+def open_bigquery_adapter(settings: dict[str, Any]) -> BigQueryAdapter:
+    try:
+        from google.cloud import bigquery
+    except ImportError as error:
+        raise ConfigError(
+            "Install frontier-runner[bigquery] to open a BigQuery session",
+        ) from error
+    project = env_value("BIGQUERY_PROJECT", "GOOGLE_CLOUD_PROJECT") or settings.get("project")
+    dataset = (
+        env_value("BIGQUERY_DATASET")
+        or settings.get("dataset")
+        or settings.get("schema")
+    )
+    if not project:
+        raise ConfigError("BigQuery project is required (BIGQUERY_PROJECT or dbt profile)")
+    client = bigquery.Client(project=str(project))
+    return BigQueryAdapter(client, project=str(project), dataset=str(dataset) if dataset else None)

frontier/adapters/databricks.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from typing import Any
+
+from frontier.adapters.base import CursorAdapter
+from frontier.config import ConfigError, redact
+from frontier.warehouse import env_value, quote_identifier, sql_string
+
+
+class DatabricksAdapter(CursorAdapter):
+    warehouse_type = "databricks"
+    dialect = "databricks"
+
+    def __init__(
+        self,
+        connection: Any | None = None,
+        *,
+        catalog: str | None = None,
+        schema: str | None = None,
+        host: str | None = None,
+        http_path: str | None = None,
+    ):
+        self._connection = connection
+        self.catalog = catalog
+        self.schema = schema
+        self.host = host
+        self.http_path = http_path
+
+    def quote_identifier(self, value: str) -> str:
+        return quote_identifier(value, "`")
+
+    def get_query_history(self, run_id: str) -> list[dict[str, Any]]:
+        tagged = sql_string(run_id)
+        try:
+            rows = self.execute(
+                "select statement_id, status "
+                "from system.query.history "
+                f"where statement_text like '%' || {tagged} || '%' "
+                "order by start_time desc limit 50"
+            )
+        except Exception:
+            return []
+        return [{"query_id": row[0], "status": row[1]} for row in rows]
+
+    def describe(self) -> dict[str, Any]:
+        return redact(
+            {
+                "warehouse_type": self.warehouse_type,
+                "host": self.host,
+                "http_path": self.http_path,
+                "catalog": self.catalog,
+                "schema": self.schema,
+                "token": env_value("DATABRICKS_TOKEN"),
+            }
+        )
+
+
+def open_databricks_adapter(settings: dict[str, Any]) -> DatabricksAdapter:
+    try:
+        from databricks import sql as databricks_sql
+    except ImportError as error:
+        raise ConfigError(
+            "Install frontier-runner[databricks] to open a Databricks SQL session",
+        ) from error
+    host = env_value("DATABRICKS_SERVER_HOSTNAME", "DATABRICKS_HOST") or settings.get(
+        "host",
+    ) or settings.get("server_hostname")
+    http_path = env_value("DATABRICKS_HTTP_PATH") or settings.get("http_path")
+    token = env_value("DATABRICKS_TOKEN") or settings.get("token")
+    catalog = env_value("DATABRICKS_CATALOG") or settings.get("catalog")
+    schema = env_value("DATABRICKS_SCHEMA") or settings.get("schema")
+    if not host or not http_path or not token:
+        raise ConfigError(
+            "Databricks host, HTTP path, and token are required "
+            "(DATABRICKS_HOST / DATABRICKS_HTTP_PATH / DATABRICKS_TOKEN)",
+        )
+    connection = databricks_sql.connect(
+        server_hostname=str(host),
+        http_path=str(http_path),
+        access_token=str(token),
+        catalog=str(catalog) if catalog else None,
+        schema=str(schema) if schema else None,
+    )
+    return DatabricksAdapter(
+        connection,
+        catalog=str(catalog) if catalog else None,
+        schema=str(schema) if schema else None,
+        host=str(host),
+        http_path=str(http_path),
+    )

frontier/adapters/postgres.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from typing import Any
+
+from frontier.adapters.base import CursorAdapter
+from frontier.config import ConfigError, redact
+from frontier.warehouse import env_value, quote_identifier, sql_string
+
+
+class PostgresAdapter(CursorAdapter):
+    warehouse_type = "postgres"
+    dialect = "postgres"
+
+    def __init__(
+        self,
+        connection: Any | None = None,
+        *,
+        host: str | None = None,
+        database: str | None = None,
+        schema: str | None = None,
+        user: str | None = None,
+    ):
+        self._connection = connection
+        self.host = host
+        self.database = database
+        self.schema = schema
+        self.user = user
+
+    def quote_identifier(self, value: str) -> str:
+        return quote_identifier(value, '"')
+
+    def get_query_history(self, run_id: str) -> list[dict[str, Any]]:
+        tagged = sql_string(f"%{run_id}%")
+        try:
+            rows = self.execute(
+                "select queryid::text, calls "
+                "from pg_stat_statements "
+                f"where query like {tagged} "
+                "order by last_exec_at desc nulls last limit 50"
+            )
+        except Exception:
+            return []
+        return [{"query_id": row[0], "calls": row[1]} for row in rows]
+
+    def describe(self) -> dict[str, Any]:
+        return redact(
+            {
+                "warehouse_type": self.warehouse_type,
+                "host": self.host,
+                "database": self.database,
+                "schema": self.schema,
+                "user": self.user,
+                "password": env_value("FRONTIER_POSTGRES_PASSWORD", "PGPASSWORD"),
+            }
+        )
+
+
+def open_postgres_adapter(settings: dict[str, Any]) -> PostgresAdapter:
+    try:
+        import psycopg
+    except ImportError as error:
+        raise ConfigError(
+            "Install frontier-runner[postgres] to open a PostgreSQL session",
+        ) from error
+    host = env_value("FRONTIER_POSTGRES_HOST", "PGHOST") or settings.get("host")
+    user = env_value("FRONTIER_POSTGRES_USER", "PGUSER") or settings.get("user")
+    database = (
+        env_value("FRONTIER_POSTGRES_DB", "PGDATABASE")
+        or settings.get("dbname")
+        or settings.get("database")
+    )
+    port = env_value("FRONTIER_POSTGRES_PORT", "PGPORT") or settings.get("port") or 5432
+    password = env_value("FRONTIER_POSTGRES_PASSWORD", "PGPASSWORD") or settings.get("password")
+    schema = env_value("FRONTIER_POSTGRES_SCHEMA") or settings.get("schema") or "public"
+    if not host or not user or not database:
+        raise ConfigError(
+            "PostgreSQL host, user, and database are required "
+            "(FRONTIER_POSTGRES_* or dbt profile)",
+        )
+    connection = psycopg.connect(
+        host=str(host),
+        user=str(user),
+        dbname=str(database),
+        port=int(port),
+        password=str(password) if password else None,
+    )
+    return PostgresAdapter(
+        connection,
+        host=str(host),
+        database=str(database),
+        schema=str(schema),
+        user=str(user),
+    )

frontier/adapters/redshift.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from typing import Any
+
+from frontier.adapters.base import CursorAdapter
+from frontier.config import ConfigError, redact
+from frontier.warehouse import env_value, quote_identifier, sql_string
+
+
+class RedshiftAdapter(CursorAdapter):
+    warehouse_type = "redshift"
+    dialect = "redshift"
+
+    def __init__(
+        self,
+        connection: Any | None = None,
+        *,
+        host: str | None = None,
+        database: str | None = None,
+        schema: str | None = None,
+        user: str | None = None,
+    ):
+        self._connection = connection
+        self.host = host
+        self.database = database
+        self.schema = schema
+        self.user = user
+
+    def quote_identifier(self, value: str) -> str:
+        return quote_identifier(value, '"')
+
+    def get_query_history(self, run_id: str) -> list[dict[str, Any]]:
+        tagged = sql_string(f"%{run_id}%")
+        try:
+            rows = self.execute(
+                "select query::text, status "
+                "from stl_query "
+                f"where querytxt like {tagged} "
+                "order by starttime desc limit 50"
+            )
+        except Exception:
+            return []
+        return [{"query_id": row[0], "status": row[1]} for row in rows]
+
+    def describe(self) -> dict[str, Any]:
+        return redact(
+            {
+                "warehouse_type": self.warehouse_type,
+                "host": self.host,
+                "database": self.database,
+                "schema": self.schema,
+                "user": self.user,
+                "password": env_value("REDSHIFT_PASSWORD"),
+            }
+        )
+
+
+def open_redshift_adapter(settings: dict[str, Any]) -> RedshiftAdapter:
+    try:
+        import redshift_connector
+    except ImportError as error:
+        raise ConfigError(
+            "Install frontier-runner[redshift] to open a Redshift session",
+        ) from error
+    host = env_value("REDSHIFT_HOST") or settings.get("host")
+    user = env_value("REDSHIFT_USER") or settings.get("user")
+    database = env_value("REDSHIFT_DATABASE") or settings.get("dbname") or settings.get("database")
+    port = env_value("REDSHIFT_PORT") or settings.get("port") or 5439
+    password = env_value("REDSHIFT_PASSWORD") or settings.get("password")
+    schema = env_value("REDSHIFT_SCHEMA") or settings.get("schema") or "public"
+    if not host or not user or not database or not password:
+        raise ConfigError(
+            "Redshift host, user, database, and password are required "
+            "(REDSHIFT_* or dbt profile)",
+        )
+    connection = redshift_connector.connect(
+        host=str(host),
+        database=str(database),
+        user=str(user),
+        password=str(password),
+        port=int(port),
+    )
+    return RedshiftAdapter(
+        connection,
+        host=str(host),
+        database=str(database),
+        schema=str(schema),
+        user=str(user),
+    )