hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/models/query_history_page.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 .query_history_entry import QueryHistoryEntry
+
+
+@dataclasses.dataclass(kw_only=True)
+class QueryHistoryPage(BaseModel):
+    """One page of `GET /api/v1/tiny-query/history`. Shape mirrors
+    `SavedQueriesPage`/`PipelinesPage`."""
+
+    data: list[QueryHistoryEntry]
+
+    limit: int
+
+    page: int
+
+    total: int

hyperfluid/models/query_result.py

@@ -0,0 +1,30 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .query_result_column import QueryResultColumn
+
+
+@dataclasses.dataclass(kw_only=True)
+class QueryResult(BaseModel):
+    """The `QueryResult` object."""
+
+    columns: list[QueryResultColumn]
+
+    execution_time_ms: int
+
+    has_more: bool
+
+    query_id: UUID
+
+    rows: list[list[t.Any]]
+
+    total_rows: int
+
+    trino_query_id: str | None = None

hyperfluid/models/query_result_column.py

@@ -0,0 +1,15 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class QueryResultColumn(BaseModel):
+    """The `QueryResultColumn` object."""
+
+    data_type: str
+
+    name: str

hyperfluid/models/query_run.py

@@ -0,0 +1,30 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .query_result import QueryResult
+    from .query_run_error import QueryRunError
+    from .query_run_status import QueryRunStatus
+
+
+@dataclasses.dataclass(kw_only=True)
+class QueryRun(BaseModel):
+    """The `QueryRun` object."""
+
+    query_id: UUID
+
+    status: QueryRunStatus
+
+    error: QueryRunError | None = None
+
+    result: QueryResult | None = None
+
+    timeout_seconds: int | None = None
+    """The timeout the run executes with, in seconds. Absent when this
+    console instance no longer tracks the run."""

hyperfluid/models/query_run_error.py

@@ -0,0 +1,16 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class QueryRunError(BaseModel):
+    """Why a run failed: the status and message `POST /api/v1/tiny-query/execute`
+    would have answered with."""
+
+    message: str
+
+    status: int

hyperfluid/models/query_run_status.py

@@ -0,0 +1,16 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class QueryRunStatus(StrEnum):
+    """Where a run started with `POST /api/v1/tiny-query/runs` stands."""
+
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+QueryRunStatusLiteral: t.TypeAlias = t.Literal["running", "completed", "failed"]
+"""The values of :class:`QueryRunStatus`, which arguments take as plain strings too."""

hyperfluid/models/question_info.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 .question_option import QuestionOption
+
+
+@dataclasses.dataclass(kw_only=True)
+class QuestionInfo(BaseModel):
+    """One question inside a pending question request."""
+
+    custom: bool
+    """True when a free-text custom answer is allowed (opencode defaults to
+    allowing it when the field is absent)."""
+
+    header: str
+    """Very short label (chip/tag) for the question."""
+
+    multiple: bool
+    """True when several options may be selected."""
+
+    options: list[QuestionOption]
+    """The available choices."""
+
+    question: str
+    """The complete question to ask the user."""

hyperfluid/models/question_option.py

@@ -0,0 +1,17 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class QuestionOption(BaseModel):
+    """One selectable choice of a question."""
+
+    description: str
+    """Explanation of what choosing this option means."""
+
+    label: str
+    """Display text (short, 1–5 words)."""

hyperfluid/models/question_reply_request.py

@@ -0,0 +1,16 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class QuestionReplyRequest(BaseModel):
+    """The `QuestionReplyRequest` object."""
+
+    answers: list[list[str]]
+    """User answers in the order of the request's questions. Each answer is
+    the list of selected option labels (or one custom free-text answer);
+    a single-select question sends a one-element list."""

hyperfluid/models/quota_capacity_dimension.py

@@ -0,0 +1,24 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class QuotaCapacityDimension(StrEnum):
+    """The dimensions that can be capacity-constrained.
+
+    Profile limits use integer columns (`max_vcpu` cores, `max_ram_gb` GiB,
+    `max_storage_gb` GiB, `max_gpus` devices). [`QuotaProfile::capacity_limit`]
+    converts them to the canonical units used throughout the enforcement path.
+
+    Not every dimension is measured the same way, and that difference is
+    load-bearing — see [`QuotaCapacityDimension::COMPUTE`]."""
+
+    VCPU = "vcpu"
+    RAM = "ram"
+    STORAGE = "storage"
+    GPU = "gpu"
+
+
+QuotaCapacityDimensionLiteral: t.TypeAlias = t.Literal["vcpu", "ram", "storage", "gpu"]
+"""The values of :class:`QuotaCapacityDimension`, which arguments take as plain strings too."""

hyperfluid/models/quota_profile_response.py

@@ -0,0 +1,61 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class QuotaProfileResponse(BaseModel):
+    """The `QuotaProfileResponse` object."""
+
+    id: UUID
+
+    max_api_calls_daily: int
+
+    max_api_keys: int
+
+    max_data_docks: int
+
+    max_gpus: int
+    """GPUs the org may hold at once, across every workload kind (#3708)."""
+
+    max_harbors: int
+
+    max_kafka_services: int
+
+    max_llm_rpm: int
+    """Inference requests per minute allowed through the LLM gateway
+    (ADR-0039). `-1` = unlimited, in which case the platform's
+    `InferencePolicy` defaults apply instead."""
+
+    max_llm_tokens_monthly: int
+
+    max_llm_tpm: int
+    """Inference tokens per minute, same contract as `max_llm_rpm`."""
+
+    max_model_servings: int
+
+    max_nextflow_environments: int
+
+    max_pipeline_runs_monthly: int
+
+    max_pipelines: int
+
+    max_ram_gb: int
+
+    max_service_accounts: int
+
+    max_storage_gb: int
+
+    max_users: int
+
+    max_vcpu: int
+
+    name: str
+
+    slug: str
+
+    description: str | None = None

hyperfluid/models/quota_resource_type.py

@@ -0,0 +1,34 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class QuotaResourceType(StrEnum):
+    """The values of `QuotaResourceType`; others are kept as received."""
+
+    HARBOR = "harbor"
+    DATA_DOCK = "data_dock"
+    PIPELINE = "pipeline"
+    MODEL_SERVING = "model_serving"
+    USER = "user"
+    API_KEY = "api_key"
+    SERVICE_ACCOUNT = "service_account"
+    KAFKA_SERVICE = "kafka_service"
+    NEXTFLOW_ENVIRONMENT = "nextflow_environment"
+    VIRTUAL_MACHINE = "virtual_machine"
+
+
+QuotaResourceTypeLiteral: t.TypeAlias = t.Literal[
+    "harbor",
+    "data_dock",
+    "pipeline",
+    "model_serving",
+    "user",
+    "api_key",
+    "service_account",
+    "kafka_service",
+    "nextflow_environment",
+    "virtual_machine",
+]
+"""The values of :class:`QuotaResourceType`, which arguments take as plain strings too."""

hyperfluid/models/quota_status.py

@@ -0,0 +1,16 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class QuotaStatus(StrEnum):
+    """The values of `QuotaStatus`; others are kept as received."""
+
+    OK = "ok"
+    WARNING = "warning"
+    EXCEEDED = "exceeded"
+
+
+QuotaStatusLiteral: t.TypeAlias = t.Literal["ok", "warning", "exceeded"]
+"""The values of :class:`QuotaStatus`, which arguments take as plain strings too."""

hyperfluid/models/quota_usage_item_response.py

@@ -0,0 +1,27 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .quota_resource_type import QuotaResourceType
+    from .quota_status import QuotaStatus
+
+
+@dataclasses.dataclass(kw_only=True)
+class QuotaUsageItemResponse(BaseModel):
+    """The `QuotaUsageItemResponse` object."""
+
+    current: int
+
+    limit: int
+
+    percentage: float
+    """Usage percentage (0-100+), -1 if unlimited"""
+
+    resource_type: QuotaResourceType
+
+    status: QuotaStatus

hyperfluid/models/ref.py

@@ -0,0 +1,49 @@
+# 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 .ref_status import RefStatus
+
+
+@dataclasses.dataclass(kw_only=True)
+class Ref(BaseModel):
+    """A reference to a file in a storage bucket
+    This reference is created upon scanning a bucket and is used to track the
+    status of the file through the pipeline."""
+
+    attempts: int
+
+    created_at: datetime
+
+    key: str
+
+    pipeline_checksum: str
+
+    pipeline_id: UUID
+
+    status: RefStatus
+
+    updated_at: datetime
+
+    error_message: str | None = None
+
+    labels: list[str] | None = None
+    """ARN-style metadata accumulated per step for this ref. Append-only.
+    Format `hf:pipelines:{kind}[:{qualifier}]::{value}` — see
+    `crate::models::labels` for builders. Used by retriable steps to skip
+    already-completed work and by routing steps to record produced paths."""
+
+    locked_at: datetime | None = None
+
+    locked_by: UUID | None = None
+    """The ID of the pipeline run that locked the reference
+    This is used to track the progress of the pipeline run
+    If the pipeline run is unhealthy (missed a heartbeat), the reference
+    will be unlocked and the pipeline run will be considered failed."""

hyperfluid/models/ref_status.py

@@ -0,0 +1,17 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class RefStatus(StrEnum):
+    """The values of `RefStatus`; others are kept as received."""
+
+    PENDING = "pending"
+    DONE = "done"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+
+
+RefStatusLiteral: t.TypeAlias = t.Literal["pending", "done", "failed", "skipped"]
+"""The values of :class:`RefStatus`, which arguments take as plain strings too."""

hyperfluid/models/refresh_credentials_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 RefreshCredentialsSummary(BaseModel):
+    """Summary returned by `PipelineCrdPublisher::refresh_pipeline_credentials`.
+    Lists which backing source supplied creds for each S3 connection that was
+    rewritten: always `s0`, the org's S3 gateway."""
+
+    pipeline_id: UUID
+
+    refreshed_at: datetime
+
+    sources: list[str]
+    """Backing source per refreshed S3 connection: `"s0"`. Duplicates are kept
+    so callers can see one entry per connection that was patched."""

hyperfluid/models/refresh_data_docks_response.py

@@ -0,0 +1,17 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class RefreshDataDocksResponse(BaseModel):
+    """The `RefreshDataDocksResponse` object."""
+
+    message: str
+
+    refreshed_count: int
+
+    total_count: int

hyperfluid/models/refusal_reason.py

@@ -0,0 +1,32 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class RefusalReason(StrEnum):
+    """Why the dock's policy refuses a request."""
+
+    GRANT = "grant"
+    READ_ONLY = "read_only"
+    EXPOSURE = "exposure"
+    SENSITIVITY = "sensitivity"
+    LABELS = "labels"
+    OFFICE_HOURS = "office_hours"
+    IMPERSONATION = "impersonation"
+    MAINTENANCE = "maintenance"
+    AGENT_SCOPE = "agent_scope"
+
+
+RefusalReasonLiteral: t.TypeAlias = t.Literal[
+    "grant",
+    "read_only",
+    "exposure",
+    "sensitivity",
+    "labels",
+    "office_hours",
+    "impersonation",
+    "maintenance",
+    "agent_scope",
+]
+"""The values of :class:`RefusalReason`, which arguments take as plain strings too."""

hyperfluid/models/register_invitation_request.py

@@ -0,0 +1,17 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class RegisterInvitationRequest(BaseModel):
+    """The `RegisterInvitationRequest` object."""
+
+    first_name: str
+
+    last_name: str
+
+    password: str

hyperfluid/models/registry_project_response.py

@@ -0,0 +1,25 @@
+# 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 RegistryProjectResponse(BaseModel):
+    """The `RegistryProjectResponse` object."""
+
+    created_at: datetime
+
+    id: UUID
+
+    name: str
+
+    registry_id: UUID
+
+    updated_at: datetime
+
+    description: str | None = None

hyperfluid/models/registry_project_usage_response.py

@@ -0,0 +1,25 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class RegistryProjectUsageResponse(BaseModel):
+    """Per-project usage rollup within the registry (counts + best-effort size)."""
+
+    approximate_size_bytes: int
+    """Best-effort sum of manifest sizes (`config + layers`) across this
+    project's tags, in bytes. **Approximate** — see
+    [`byte_usage_pending`](RegistryUsageResponse::byte_usage_pending)."""
+
+    project: str
+    """The `<project-name>` segment."""
+
+    repository_count: int
+    """Number of repositories under this project (the caller can pull from)."""
+
+    tag_count: int
+    """Total number of tags across this project's repositories."""

hyperfluid/models/registry_response.py

@@ -0,0 +1,51 @@
+# 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 RegistryResponse(BaseModel):
+    """The `registries` row returned by both the internal (operator) and external
+    (UI) registry routes. Defined once here to avoid the `RegistryResponse` /
+    `RegistryCrdResponse` split that previously existed across the bridge and
+    external create handlers — both structs had identical fields and identical
+    `From<domain::Registry>` impls.
+
+    `is_ready` and `external_endpoint` are operator-synced status fields
+    (persisted via the internal `update_registry_status` endpoint). External
+    read handlers (list, get) serve these from the DB — never from the K8s API
+    server (CLAUDE.md operator architecture rule).
+
+    Referenced in both `InternalRegistriesApi` and `ExternalRegistriesApi`
+    OpenAPI component schemas; utoipa deduplicates by schema name so the single
+    `RegistryResponse` definition is emitted once in each generated spec."""
+
+    created_at: datetime
+
+    harbor_id: UUID
+    """Harbor that owns this registry (one-per-harbor, ADR-0014 §Scoping)."""
+
+    id: UUID
+
+    is_ready: bool
+    """`true` once the Registry reconciler stamps `Ready=True`."""
+
+    name: str
+
+    organization_id: UUID
+
+    registry_base_domain: str
+
+    slug: str
+
+    updated_at: datetime
+
+    external_endpoint: str | None = None
+    """The external registry host once the reconciler reconciles the
+    Gateway/HTTPRoute — the per-org subdomain `<org>.rg.<base-domain>`
+    (ADR-0014 §Scoping amendment). `None` until ready."""