hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/models/custom_metrics_query_request.py

@@ -0,0 +1,21 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .metrics_range import MetricsRange
+
+
+@dataclasses.dataclass(kw_only=True)
+class CustomMetricsQueryRequest(BaseModel):
+    """Body of a custom-metrics query."""
+
+    query: str
+    """A PromQL expression, at most 2000 characters. Every series selector in
+    it is confined, server-side, to this app's own series."""
+
+    range: MetricsRange

hyperfluid/models/custom_metrics_query_response.py

@@ -0,0 +1,31 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .custom_metric_series_dto import CustomMetricSeriesDto
+
+
+@dataclasses.dataclass(kw_only=True)
+class CustomMetricsQueryResponse(BaseModel):
+    """The `CustomMetricsQueryResponse` object."""
+
+    end: int
+
+    range: str
+
+    resource_id: str
+
+    series: list[CustomMetricSeriesDto]
+
+    start: int
+
+    step_seconds: int
+
+    truncated: bool
+    """`true` when more series matched than the cap and the rest were dropped:
+    aggregate (`sum by (…)`) to see them all."""

hyperfluid/models/custom_resource_input.py

@@ -0,0 +1,27 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class CustomResourceInput(BaseModel):
+    """Explicit CPU + memory for a "custom" flavor (#4275) — the alternative to
+    `resource_tier` for a customer whose workload sits between two catalog
+    tiers. Mutually exclusive with `resource_tier` on the request body: a
+    request setting both is rejected by [`resolve_resource_requirements`]."""
+
+    cpu_millis: int
+    """Sold/billed CPU entitlement, in millicores. Bounded by
+    [`CUSTOM_CPU_MILLIS_MIN`]..=[`CUSTOM_CPU_MILLIS_MAX`] — the same span
+    the tier catalog itself covers. Request and limit are derived from
+    this value exactly like a tier's sold number (see
+    [`custom_resource_requirements`])."""
+
+    memory_mib: int
+    """Memory, in MiB. Bounded by
+    [`CUSTOM_MEMORY_MIB_MIN`]..=[`CUSTOM_MEMORY_MIB_MAX`]. Request and
+    limit are both set to this value — memory never gets a burst ceiling,
+    the same rule every tier follows."""

hyperfluid/models/dashboard.py

@@ -0,0 +1,51 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+from datetime import datetime
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .dashboard_status import DashboardStatus
+    from .dashboard_variable import DashboardVariable
+    from .dashboard_widget import DashboardWidget
+
+
+@dataclasses.dataclass(kw_only=True)
+class Dashboard(BaseModel):
+    """The `Dashboard` object."""
+
+    created_at: datetime
+
+    created_by: UUID
+
+    id: UUID
+
+    name: str
+
+    organization_id: UUID
+
+    spec_version: int
+
+    status: DashboardStatus
+
+    updated_at: datetime
+
+    widgets: list[DashboardWidget]
+
+    container_app_id: UUID | None = None
+    """The Container App this dashboard belongs to, when it charts its custom
+    metrics (issue #4727)."""
+
+    description: str | None = None
+
+    harbor_id: UUID | None = None
+
+    refresh_interval_seconds: int | None = None
+    """Auto-refresh cadence in seconds; `None` = manual only (issue #2958)."""
+
+    variables: list[DashboardVariable] | None = None
+    """Dashboard-level filters (issue #2948)."""

hyperfluid/models/dashboard_status.py

@@ -0,0 +1,16 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class DashboardStatus(StrEnum):
+    """Draft dashboards are visible to their author and org editors only;
+    published ones to everyone with read access (issue #2952)."""
+
+    DRAFT = "draft"
+    PUBLISHED = "published"
+
+
+DashboardStatusLiteral: t.TypeAlias = t.Literal["draft", "published"]
+"""The values of :class:`DashboardStatus`, which arguments take as plain strings too."""

hyperfluid/models/dashboard_summary.py

@@ -0,0 +1,42 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+from datetime import datetime
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .dashboard_status import DashboardStatus
+
+
+@dataclasses.dataclass(kw_only=True)
+class DashboardSummary(BaseModel):
+    """List-item projection — widgets omitted so the list page stays light."""
+
+    created_at: datetime
+
+    created_by: UUID
+
+    id: UUID
+
+    name: str
+
+    organization_id: UUID
+
+    status: DashboardStatus
+
+    updated_at: datetime
+
+    widget_count: int
+
+    container_app_id: UUID | None = None
+
+    deleted_at: datetime | None = None
+    """Set on trash listings only."""
+
+    description: str | None = None
+
+    harbor_id: UUID | None = None

hyperfluid/models/dashboard_variable.py

@@ -0,0 +1,29 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class DashboardVariable(BaseModel):
+    """A dashboard-level filter (issue #2948). Its value is substituted into
+    widget SQL wherever `{{name}}` appears; substitution happens client-side
+    with typed escaping, and Bifrost's SELECT-only validator is the security
+    backstop (a value that tries to inject non-SELECT is rejected at execution)."""
+
+    name: str
+    """Placeholder name; `{{name}}` in widget SQL is replaced by the value."""
+
+    var_type: str
+    """"text" | "number" | "date" | "date_range" | "select"."""
+
+    default: str | None | Unset = UNSET
+    """Default value (string form; date_range is "start,end")."""
+
+    label: str | None | Unset = UNSET
+    """Human label for the filter bar."""
+
+    options_sql: str | None | Unset = UNSET
+    """For `select`: a SELECT returning one column of options."""

hyperfluid/models/dashboard_version_summary.py

@@ -0,0 +1,23 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from datetime import datetime
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class DashboardVersionSummary(BaseModel):
+    """The `DashboardVersionSummary` object."""
+
+    created_at: datetime
+
+    created_by: UUID
+
+    name: str
+
+    version_no: int
+
+    widget_count: int

hyperfluid/models/dashboard_widget.py

@@ -0,0 +1,52 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+from uuid import UUID
+
+from ..serialization import UNSET, BaseModel, Unset
+
+if t.TYPE_CHECKING:
+    from .widget_chart import WidgetChart
+    from .widget_layout import WidgetLayout
+
+
+@dataclasses.dataclass(kw_only=True)
+class DashboardWidget(BaseModel):
+    """A widget takes its data from exactly one source (text widgets, which carry
+    markdown only, from none):
+    - SQL: `data_dock_id` + `sql`, run through Bifrost as the viewer;
+    - app metrics: `container_app_id` + `promql`, run against the app's own
+      custom metrics through the tenant-scoped monitoring API (ADR-0051).
+
+    The source is a set of optional fields rather than a tagged enum so every
+    widget already stored in `dashboards.widgets` (top-level `data_dock_id` and
+    `sql`) deserialises untouched, with no migration and no `#[serde(untagged)]`
+    fallback. [`DashboardWidget::source`] gives the typed view; `spec.rs`
+    enforces "exactly one source" on save."""
+
+    chart: WidgetChart
+
+    id: UUID
+
+    layout: WidgetLayout
+
+    title: str
+
+    container_app_id: UUID | None | Unset = UNSET
+    """Metrics source: the Container App whose custom metrics the widget
+    charts. Must belong to the dashboard's organization and Harbor."""
+
+    data_dock_id: UUID | None | Unset = UNSET
+    """SQL source: the Data Dock the widget's SQL runs against (via Bifrost,
+    as the viewer). Absent on metrics and text widgets."""
+
+    promql: str | None | Unset = UNSET
+    """Metrics source: a PromQL expression (at most 2000 characters), confined
+    server-side to the app's own series."""
+
+    sql: str | None = None
+    """SQL source: a single SELECT statement (Trino SQL). Validated at save AND
+    at execution — the widget of a shared dashboard must never run writes.
+    Empty on metrics and text widgets."""

hyperfluid/models/data_access_baseline.py

@@ -0,0 +1,17 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class DataAccessBaseline(StrEnum):
+    """Table verbs every authenticated principal holds on a data dock without a grant. Only `all` is accepted on update; unset means `all`."""
+
+    NONE = "none"
+    DESCRIBE = "describe"
+    SELECT = "select"
+    ALL = "all"
+
+
+DataAccessBaselineLiteral: t.TypeAlias = t.Literal["none", "describe", "select", "all"]
+"""The values of :class:`DataAccessBaseline`, which arguments take as plain strings too."""

hyperfluid/models/data_container_overview.py

@@ -0,0 +1,20 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class DataContainerOverview(BaseModel):
+    """A summary of a data container"""
+
+    data_dock_id: UUID
+
+    id: UUID
+
+    kind: str
+
+    name: str

hyperfluid/models/data_dock.py

@@ -0,0 +1,72 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+from datetime import datetime
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .data_dock_kind import DataDockKind
+    from .data_dock_status import DataDockStatus
+    from .trino_metadata import TrinoMetadata
+
+
+@dataclasses.dataclass(kw_only=True)
+class DataDock(BaseModel):
+    """The `DataDock` object."""
+
+    description: str
+
+    harbor_id: UUID
+
+    host: str
+
+    id: UUID
+
+    kind: DataDockKind
+
+    name: str
+
+    port: int
+    """This is i16 to match the sqlx type for port but this should never be negative (constraints are already in place in the db)"""
+
+    refresh_interval: int
+
+    service_account_id: str
+
+    service_account_secret: str
+
+    slug: str
+
+    status: DataDockStatus
+
+    token_issuer_endpoint: str
+    """token issuer endpoint is the url to get
+    the token related to the service account"""
+
+    catalog: TrinoMetadata | None = None
+
+    internal_host: str | None = None
+    """internal_host and internal_port composes the address to reach the data dock from inside the cluster.
+    This is mainly used for introspection"""
+
+    internal_port: int | None = None
+
+    maintenance_identity_subject: str | None = None
+    """JWT `sub` of the dock's maintenance service account — the identity
+    Iceberg table maintenance authenticates as, and nothing else does.
+
+    The `sub` rather than the client id because that is what Trino makes the
+    principal, so it is what OPA matches on `input.context.identity.user`
+    and what a resource-group selector on `user` can name. `None` until the
+    operator has reconciled the dock since the identity was introduced."""
+
+    opa_uri: str | None = None
+
+    operator_identity_subject: str | None = None
+    """JWT `sub` of the dock's `<dock>-trino-oauth-sa`, written by the operator."""
+
+    refreshed_at: datetime | None = None

hyperfluid/models/data_dock_catalog_info.py

@@ -0,0 +1,30 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class DataDockCatalogInfo(BaseModel):
+    """CRD status summary for a single `TrinoCatalog`, as returned by
+    `GET /api/v1/data-docks/{data_dock_id}/catalogs`.
+
+    Carries the connector `kind` and the current operator reconcile `phase`
+    that the Trino metadata endpoint (`/catalog`) does not expose, letting the
+    SQL Engine Catalogs UI show type + status badges."""
+
+    kind: str
+    """Connector kind as a lowercase string (e.g. `"iceberg"`, `"tpch"`).
+    Derived from `spec.type` via [`TrinoCatalogType`]'s `Display` impl."""
+
+    name: str
+    """Catalog name (`spec.name` on the `TrinoCatalog` CR)."""
+
+    message: str | None = None
+    """Human-readable operator message (`status.message`), or `null`."""
+
+    phase: str | None = None
+    """Current reconcile phase (`status.phase`), or `null` if the operator
+    has not yet written a status (CR just applied, no reconcile yet)."""

hyperfluid/models/data_dock_catalog_kind.py

@@ -0,0 +1,36 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class DataDockCatalogKind(StrEnum):
+    """Connector kind — the non-blocking management-UI-facing catalog variants.
+
+    A `Postgresql` catalog takes exactly one credential source:
+
+    * `managed_postgresql_user_id` — a Hyperfluid-managed database. Only a
+      synced, read-only (`viewer`) user may back it, the same contract the
+      legacy `POST /data-containers/postgresql` endpoint enforces (see
+      `resolve_viewer_backed_secret`).
+    * `connection_secret_name` — a database Hyperfluid does not operate,
+      reached with a credential bundle the user supplied.
+
+    Every other bundle-configured connector takes `connection_secret_name`
+    only. In every case the CR carries a secret *reference*; the operator
+    resolves live credentials at reconcile time."""
+
+    ICEBERG = "Iceberg"
+    CLICKHOUSE = "Clickhouse"
+    MARIADB = "Mariadb"
+    MYSQL = "Mysql"
+    POSTGRESQL = "Postgresql"
+    TPCH = "Tpch"
+    TPCDS = "Tpcds"
+    FAKER = "Faker"
+
+
+DataDockCatalogKindLiteral: t.TypeAlias = t.Literal[
+    "Iceberg", "Clickhouse", "Mariadb", "Mysql", "Postgresql", "Tpch", "Tpcds", "Faker"
+]
+"""The values of :class:`DataDockCatalogKind`, which arguments take as plain strings too."""

hyperfluid/models/data_dock_external_response_data.py

@@ -0,0 +1,40 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+from datetime import datetime
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .data_dock_kind_external_response import DataDockKindExternalResponse
+    from .data_dock_status import DataDockStatus
+
+
+@dataclasses.dataclass(kw_only=True)
+class DataDockExternalResponseData(BaseModel):
+    """External API response — strips infra details (namespaces) from user-facing endpoints."""
+
+    connection_kind: DataDockKindExternalResponse
+
+    description: str
+
+    harbor_id: UUID
+
+    host: str
+
+    id: UUID
+
+    name: str
+
+    port: int
+
+    refresh_interval: int
+
+    slug: str
+
+    status: DataDockStatus
+
+    refreshed_at: datetime | None = None

hyperfluid/models/data_dock_internet_exposure_response.py

@@ -0,0 +1,33 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .internet_exposure_state import InternetExposureState
+
+
+@dataclasses.dataclass(kw_only=True)
+class DataDockInternetExposureResponse(BaseModel):
+    """The `DataDockInternetExposureResponse` object."""
+
+    desired_exposed: bool
+    """What the operator resolves that to — the REQUESTED state. An unset toggle
+    resolves to `true`, so every Data Dock created before the toggle existed
+    stays public. Never render a security claim off this alone: it says what
+    was asked for, not what exists."""
+
+    state: InternetExposureState
+
+    enforced_exposed: bool | None = None
+    """`DataDockStatus.exposed_to_internet`: what the operator's last successful
+    reconcile actually left in place. `null` on a dock that has not
+    reconciled since the field was introduced."""
+
+    expose_to_internet: bool | None = None
+    """The spec value as written: `null` when the toggle was never set.
+    Distinguishing "never set" from "set to true" is what lets the operator
+    keep a resolved default out of the spec."""

hyperfluid/models/data_dock_kind.py

@@ -0,0 +1,18 @@
+# this file is @generated
+from __future__ import annotations
+
+import typing as t
+
+from ..serialization import Discriminator, UnknownVariant
+from .data_dock_kind_trino_internal_variant import DataDockKindTrinoInternalVariant
+
+DataDockKind: t.TypeAlias = t.Annotated[
+    DataDockKindTrinoInternalVariant | UnknownVariant,
+    Discriminator(
+        "type",
+        {
+            "TrinoInternal": DataDockKindTrinoInternalVariant,
+        },
+    ),
+]
+"""Told apart by `type`; a variant this SDK version does not know is an `UnknownVariant`."""

hyperfluid/models/data_dock_kind_external_response.py

@@ -0,0 +1,20 @@
+# this file is @generated
+from __future__ import annotations
+
+import typing as t
+
+from ..serialization import Discriminator, UnknownVariant
+from .data_dock_kind_external_response_trino_internal_variant import (
+    DataDockKindExternalResponseTrinoInternalVariant,
+)
+
+DataDockKindExternalResponse: t.TypeAlias = t.Annotated[
+    DataDockKindExternalResponseTrinoInternalVariant | UnknownVariant,
+    Discriminator(
+        "type",
+        {
+            "TrinoInternal": DataDockKindExternalResponseTrinoInternalVariant,
+        },
+    ),
+]
+"""Told apart by `type`; a variant this SDK version does not know is an `UnknownVariant`."""

hyperfluid/models/data_dock_kind_external_response_trino_internal_variant.py

@@ -0,0 +1,19 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .trino_internal_config_response import TrinoInternalConfigResponse
+
+
+@dataclasses.dataclass(kw_only=True)
+class DataDockKindExternalResponseTrinoInternalVariant(BaseModel):
+    """The `DataDockKindExternalResponseTrinoInternalVariant` object."""
+
+    content: TrinoInternalConfigResponse
+
+    type: t.Literal["TrinoInternal"] = "TrinoInternal"

hyperfluid/models/data_dock_kind_request.py

@@ -0,0 +1,20 @@
+# this file is @generated
+from __future__ import annotations
+
+import typing as t
+
+from ..serialization import Discriminator, UnknownVariant
+from .data_dock_kind_request_trino_internal_variant import (
+    DataDockKindRequestTrinoInternalVariant,
+)
+
+DataDockKindRequest: t.TypeAlias = t.Annotated[
+    DataDockKindRequestTrinoInternalVariant | UnknownVariant,
+    Discriminator(
+        "type",
+        {
+            "TrinoInternal": DataDockKindRequestTrinoInternalVariant,
+        },
+    ),
+]
+"""Told apart by `type`; a variant this SDK version does not know is an `UnknownVariant`."""

hyperfluid/models/data_dock_kind_request_trino_internal_variant.py

@@ -0,0 +1,19 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .trino_internal_config import TrinoInternalConfig
+
+
+@dataclasses.dataclass(kw_only=True)
+class DataDockKindRequestTrinoInternalVariant(BaseModel):
+    """The `DataDockKindRequestTrinoInternalVariant` object."""
+
+    content: TrinoInternalConfig
+
+    type: t.Literal["TrinoInternal"] = "TrinoInternal"

hyperfluid/models/data_dock_kind_trino_internal_variant.py

@@ -0,0 +1,19 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .trino_internal_config import TrinoInternalConfig
+
+
+@dataclasses.dataclass(kw_only=True)
+class DataDockKindTrinoInternalVariant(BaseModel):
+    """The `DataDockKindTrinoInternalVariant` object."""
+
+    content: TrinoInternalConfig
+
+    type: t.Literal["TrinoInternal"] = "TrinoInternal"