hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/models/hf_key_value_cache_response.py

@@ -0,0 +1,47 @@
+# 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 HfKeyValueCacheResponse(BaseModel):
+    """The `HfKeyValueCacheResponse` object."""
+
+    created_at: datetime
+
+    harbor_id: UUID
+
+    id: UUID
+
+    image: str
+
+    name: str
+
+    organization_id: UUID
+
+    slug: str
+
+    tags: list[str]
+
+    updated_at: datetime
+
+    credentials_secret_name: str | None = None
+
+    description: str | None = None
+
+    host: str | None = None
+
+    maxmemory: str | None = None
+
+    maxmemory_policy: str | None = None
+
+    message: str | None = None
+
+    phase: str | None = None
+
+    port: int | None = None

hyperfluid/models/hf_table.py

@@ -0,0 +1,26 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .hf_collumn import HfCollumn
+
+
+@dataclasses.dataclass(kw_only=True)
+class HfTable(BaseModel):
+    """The `HfTable` object."""
+
+    catalog_name: str
+
+    columns: list[HfCollumn]
+
+    schema_name: str
+
+    table_name: str
+
+    is_view: bool | None = None
+    """The relation is a view, not a base table."""

hyperfluid/models/histogram_bucket_dto.py

@@ -0,0 +1,20 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class HistogramBucketDto(BaseModel):
+    """A single volume-histogram bucket — a line count for one fixed time bucket.
+    Powers the logs explorer's volume-over-time bar chart above the entries
+    (ADR-0020). Unlike the sources facet, the histogram DOES reflect the active
+    search/level/pod/container filters and the query window."""
+
+    count: int
+    """Number of matching log lines in this bucket."""
+
+    ts: int
+    """Bucket start (unix epoch seconds)."""

hyperfluid/models/iceberg_column_definition.py

@@ -0,0 +1,19 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class IcebergColumnDefinition(BaseModel):
+    """Column definition for table creation"""
+
+    data_type: str
+
+    name: str
+
+    nullable: bool
+
+    comment: str | None | Unset = UNSET

hyperfluid/models/iceberg_connector_data_container.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 IcebergConnectorDataContainer(BaseModel):
+    """The `IcebergConnectorDataContainer` object."""
+
+    data_dock_id: UUID
+
+    id: UUID
+
+    name: str
+
+    s3_bucket: str

hyperfluid/models/iceberg_health_report.py

@@ -0,0 +1,24 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .health_thresholds import HealthThresholds
+    from .iceberg_health_summary import IcebergHealthSummary
+    from .iceberg_table_health import IcebergTableHealth
+
+
+@dataclasses.dataclass(kw_only=True)
+class IcebergHealthReport(BaseModel):
+    """The health list, plus the verdict of the catalog as a whole."""
+
+    summary: IcebergHealthSummary
+
+    tables: list[IcebergTableHealth]
+    """Worst first, then stalest — the order someone reading top-down wants."""
+
+    thresholds: HealthThresholds

hyperfluid/models/iceberg_health_scan.py

@@ -0,0 +1,35 @@
+# 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 IcebergHealthScan(BaseModel):
+    """One sweep of a catalog."""
+
+    data_container_id: UUID
+
+    id: UUID
+
+    started_at: datetime
+
+    status: str
+    """`running`, `Success`, `PartialFailure`, `Failed` or `Aborted`."""
+
+    tables_failed: int
+
+    tables_scanned: int
+
+    completed_at: datetime | None = None
+
+    error: str | None = None
+
+    tables_total: int | None = None
+    """`None` until the sweep has finished listing the catalog."""
+
+    triggered_by: UUID | None = None

hyperfluid/models/iceberg_health_summary.py

@@ -0,0 +1,47 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+from datetime import datetime
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .iceberg_health_scan import IcebergHealthScan
+
+
+@dataclasses.dataclass(kw_only=True)
+class IcebergHealthSummary(BaseModel):
+    """The catalog at a glance."""
+
+    delete_files_total: int
+
+    reclaimable_files: int
+    """Data files compaction could plausibly remove, summed over tables that
+    need it."""
+
+    small_files_total: int
+    """Small data files across the catalog — the raw size of the compaction
+    backlog."""
+
+    tables_critical: int
+
+    tables_healthy: int
+
+    tables_measured: int
+
+    tables_needing_attention_out_of_scope: int
+    """Tables that need attention and that the maintenance schedule does not
+    cover — work the nightly run will never do, however green it looks."""
+
+    tables_unknown: int
+
+    tables_warning: int
+
+    last_scan: IcebergHealthScan | None = None
+
+    newest_measured_at: datetime | None = None
+
+    oldest_measured_at: datetime | None = None
+    """Oldest measurement in the set: how far behind the whole picture is."""

hyperfluid/models/iceberg_optimize_config.py

@@ -0,0 +1,62 @@
+# 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 IcebergOptimizeConfig(BaseModel):
+    """The `IcebergOptimizeConfig` object."""
+
+    analyze_statistics_enabled: bool
+
+    compact_files_enabled: bool
+
+    created_at: datetime
+
+    data_container_id: UUID
+
+    exclude_patterns: list[str]
+    """Glob patterns excluded after `include_patterns` has been applied."""
+
+    expire_snapshots_enabled: bool
+
+    id: UUID
+
+    include_patterns: list[str]
+    """Glob patterns matched against `schema.table`. Empty means every table."""
+
+    max_parallel_tables: int
+    """How many tables the runner may optimize concurrently."""
+
+    remove_orphan_files_enabled: bool
+
+    schedule: str
+
+    skip_unchanged: bool
+    """Skip a table whose current snapshot is the one a previous run already
+    left it optimized at."""
+
+    suspend: bool
+
+    updated_at: datetime
+
+    compact_files_size_threshold: str | None = None
+
+    expire_snapshots_retention: str | None = None
+
+    last_run_at: datetime | None = None
+
+    last_run_status: str | None = None
+
+    max_duration_minutes: int | None = None
+    """Wall-clock budget for a run. `None` means unbounded, which is also what
+    every pre-existing config has."""
+
+    remove_orphan_files_retention: str | None = None
+
+    tables_optimized: int | None = None

hyperfluid/models/iceberg_optimize_run.py

@@ -0,0 +1,63 @@
+# 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
+
+
+@dataclasses.dataclass(kw_only=True)
+class IcebergOptimizeRun(BaseModel):
+    """The `IcebergOptimizeRun` object."""
+
+    created_at: datetime
+
+    id: UUID
+
+    optimize_config_id: UUID
+
+    started_at: datetime
+
+    status: str
+
+    trigger_source: str
+    """`scheduled` or `manual`."""
+
+    completed_at: datetime | None = None
+
+    duration_ms: int | None = None
+    """Wall-clock duration measured by the runner."""
+
+    error_details: t.Any = None
+
+    finished_reason: str | None = None
+    """Set when the terminal status did not come from the runner itself (today:
+    the stuck-run reaper)."""
+
+    job_name: str | None = None
+
+    log_output: str | None = None
+    """Raw log lines the runner reported, newest last. The pod's full output
+    lives in the log store and is read through the run's `/logs` route;
+    this is the summary the runner chose to persist."""
+
+    metrics: t.Any = None
+    """Run-level outcome totals — see [`OptimizeRunMetrics`]."""
+
+    namespace: str | None = None
+
+    pod_name: str | None = None
+    """Pod that executed the run, as it reported itself. Scopes the log query;
+    `None` means the run never got far enough to register."""
+
+    table_results: t.Any = None
+    """Per-table results — see [`OptimizeTableResult`]."""
+
+    tables_failed: int | None = None
+
+    tables_processed: int | None = None
+
+    tables_succeeded: int | None = None

hyperfluid/models/iceberg_optimize_runs_page.py

@@ -0,0 +1,29 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .iceberg_optimize_run import IcebergOptimizeRun
+
+
+@dataclasses.dataclass(kw_only=True)
+class IcebergOptimizeRunsPage(BaseModel):
+    """One page of `GET /data-containers/{data_container_id}/optimize/history`.
+
+    Same pagination contract as `PipelinesPage` (`data`/`total`/`page`/`limit`)."""
+
+    data: list[IcebergOptimizeRun]
+    """Newest first."""
+
+    limit: int
+    """Page size actually served."""
+
+    page: int
+    """Zero-based page index actually served."""
+
+    total: int
+    """Every run of this catalog, ignoring `page`/`limit`."""

hyperfluid/models/iceberg_optimize_summary.py

@@ -0,0 +1,51 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from datetime import datetime
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class IcebergOptimizeSummary(BaseModel):
+    """Rolling outcome of a catalog's maintenance, over the summary window.
+
+    Everything here is derived from runs the console recorded, not from the
+    metrics store: the runner is a batch pod that is gone by the time anyone
+    looks, so its outcome numbers are reported to us and kept, rather than
+    scraped."""
+
+    bytes_reclaimed: int
+    """Storage the window's runs handed back, i.e. sum of `bytes_before -
+    bytes_after` over runs where both were measured. Can be negative:
+    compaction rewrites files and a run can legitimately end up larger."""
+
+    files_removed: int
+    """Files merged away, same basis as `bytes_reclaimed`."""
+
+    runs_failed: int
+
+    runs_running: int
+    """Runs still in flight (or never terminated) at read time."""
+
+    runs_succeeded: int
+
+    runs_total: int
+
+    snapshots_expired: int
+
+    window_days: int
+    """Length of the window these totals cover."""
+
+    avg_duration_ms: int | None = None
+    """Median-free on purpose: the average is what a capacity conversation
+    uses, and a single run's outlier is visible in the history right below."""
+
+    last_run_at: datetime | None = None
+
+    last_run_status: str | None = None
+
+    last_success_at: datetime | None = None
+
+    tables_last_run: int | None = None

hyperfluid/models/iceberg_schema_metadata.py

@@ -0,0 +1,46 @@
+# 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 .crd_status_snapshot import CrdStatusSnapshot
+    from .resource_source import ResourceSource
+
+
+@dataclasses.dataclass(kw_only=True)
+class IcebergSchemaMetadata(BaseModel):
+    """The `IcebergSchemaMetadata` object."""
+
+    cdc_enabled: bool
+
+    created_at: datetime
+
+    creator_id: UUID
+
+    data_container_id: UUID
+
+    id: UUID
+
+    location: str
+
+    medallion_tier: str
+
+    schema_name: str
+
+    updated_at: datetime
+
+    annotations: dict[str, str] | None = None
+    """Annotations mirrored from the `TrinoSchema` CRD metadata when
+    `source = Crd`. Empty otherwise."""
+
+    description: str | None = None
+
+    source: ResourceSource | None = None
+
+    status: CrdStatusSnapshot | None = None

hyperfluid/models/iceberg_table_health.py

@@ -0,0 +1,91 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+from datetime import datetime
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .table_health_finding import TableHealthFinding
+    from .table_health_severity import TableHealthSeverity
+
+
+@dataclasses.dataclass(kw_only=True)
+class IcebergTableHealth(BaseModel):
+    """One table, measured and graded.
+
+    The raw measurement travels with the verdict on purpose: a badge nobody can
+    check is a badge nobody believes, and the numbers are what make "compact
+    this" an argument rather than an instruction."""
+
+    findings: list[TableHealthFinding]
+
+    in_maintenance_scope: bool
+    """Whether the catalog's maintenance schedule would touch this table.
+
+    A fragmented table its own schedule excludes is the finding nobody goes
+    looking for: the maintenance page says everything succeeded, because
+    everything it was allowed to touch did."""
+
+    measured_at: datetime
+
+    measured_by: str
+    """`scan` (an on-demand sweep) or `run` (a maintenance run reporting the
+    state it left the table in)."""
+
+    partial_measurement: bool
+    """True when only the basic `$files` aggregate could be read, so
+    file-content-dependent findings could not be evaluated at all. The
+    severity then covers less than it appears to, and the UI says so."""
+
+    schema_name: str
+
+    severity: TableHealthSeverity
+
+    short_name: str
+    """Bare table name, split out so the UI does not have to parse the FQN."""
+
+    table_name: str
+    """`catalog.schema.table` — the same string a maintenance run reports."""
+
+    avg_data_file_bytes: int | None = None
+    """Mean data file size — the number the compaction target is set against."""
+
+    compacted_file_estimate: int | None = None
+    """Roughly how few data files compaction could leave behind. A floor, not
+    a promise: Iceberg will not merge across partitions."""
+
+    data_bytes: int | None = None
+
+    data_file_count: int | None = None
+
+    delete_bytes: int | None = None
+
+    delete_file_count: int | None = None
+
+    file_count: int | None = None
+
+    last_commit_at: datetime | None = None
+
+    max_data_file_bytes: int | None = None
+
+    min_data_file_bytes: int | None = None
+
+    oldest_snapshot_at: datetime | None = None
+
+    record_count: int | None = None
+
+    small_data_file_count: int | None = None
+
+    small_file_ratio: float | None = None
+    """Share of data files below the threshold, `0..1`."""
+
+    small_file_threshold_bytes: int | None = None
+    """The threshold this measurement's small-file count was taken against.
+    Shown so a reader can tell a stale grading from a current one."""
+
+    snapshot_count: int | None = None
+
+    total_bytes: int | None = None

hyperfluid/models/iceberg_table_metadata.py

@@ -0,0 +1,27 @@
+# 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 IcebergTableMetadata(BaseModel):
+    """Iceberg table metadata stored in Hyperfluid"""
+
+    created_at: datetime
+
+    creator_id: UUID
+
+    ddl_statement: str
+
+    id: UUID
+
+    schema_id: UUID
+
+    table_name: str
+
+    updated_at: datetime

hyperfluid/models/iceberg_table_response_data.py

@@ -0,0 +1,47 @@
+# 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 .crd_status_snapshot import CrdStatusSnapshot
+    from .resource_source import ResourceSource
+
+
+@dataclasses.dataclass(kw_only=True)
+class IcebergTableResponseData(BaseModel):
+    """The `IcebergTableResponseData` object."""
+
+    annotations: dict[str, str]
+    """Metadata annotations copied from the CRD when `source = Crd`. The UI
+    surfaces well-known keys (e.g. `hyperfluid.nudibranches.tech/source`,
+    `hyperfluid.nudibranches.tech/pipeline`) as coloured badges."""
+
+    created_at: datetime
+
+    creator_id: UUID
+
+    data_container_id: UUID
+
+    ddl_statement: str
+
+    id: UUID
+
+    medallion_tier: str
+
+    schema_id: UUID
+
+    schema_name: str
+
+    source: ResourceSource
+
+    table_name: str
+
+    updated_at: datetime
+
+    status: CrdStatusSnapshot | None = None

hyperfluid/models/identity_provider.py

@@ -0,0 +1,30 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .identity_provider_kind import IdentityProviderKind
+
+
+@dataclasses.dataclass(kw_only=True)
+class IdentityProvider(BaseModel):
+    """A brokered identity provider as returned to API callers. The client secret
+    is deliberately absent — it is write-only and lives only in Keycloak."""
+
+    alias: str
+    """Stable identifier and Keycloak alias (e.g. `github`)."""
+
+    client_id: str
+
+    display_name: str
+
+    enabled: bool
+
+    kind: IdentityProviderKind
+
+    oidc_base_url: str | None = None
+    """Issuer/base URL, present only for a custom OIDC provider."""