hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/models/pipeline_field_reference.py

@@ -0,0 +1,44 @@
+# this file is @generated
+from __future__ import annotations
+
+import typing as t
+
+from ..serialization import Discriminator, UnknownVariant
+from .pipeline_field_reference_bucket_variant import PipelineFieldReferenceBucketVariant
+from .pipeline_field_reference_credential_variant import (
+    PipelineFieldReferenceCredentialVariant,
+)
+from .pipeline_field_reference_shared_model_variant import (
+    PipelineFieldReferenceSharedModelVariant,
+)
+from .pipeline_field_reference_table_variant import PipelineFieldReferenceTableVariant
+
+PipelineFieldReference: t.TypeAlias = t.Annotated[
+    PipelineFieldReferenceBucketVariant
+    | PipelineFieldReferenceSharedModelVariant
+    | PipelineFieldReferenceTableVariant
+    | PipelineFieldReferenceCredentialVariant
+    | UnknownVariant,
+    Discriminator(
+        "kind",
+        {
+            "bucket": PipelineFieldReferenceBucketVariant,
+            "shared_model": PipelineFieldReferenceSharedModelVariant,
+            "table": PipelineFieldReferenceTableVariant,
+            "credential": PipelineFieldReferenceCredentialVariant,
+        },
+    ),
+]
+"""The Hyperfluid resource a detail field's value refers to, so the console can
+link to it instead of printing a dead string.
+
+Resolved on this side rather than by sniffing the rendered value: the console
+would otherwise have to re-derive from a display string (`s3://bucket/prefix`,
+`catalog.schema.table`) what is known exactly here, and would follow the
+wrong link the first time a rendering changed.
+
+Every variant carries what the console's route needs, already resolved — a
+table names its data container by id, because that is what the catalog page
+is addressed by, even though the executor spec only ever names its catalog.
+
+Told apart by `kind`; a variant this SDK version does not know is an `UnknownVariant`."""

hyperfluid/models/pipeline_field_reference_bucket_variant.py

@@ -0,0 +1,16 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class PipelineFieldReferenceBucketVariant(BaseModel):
+    """An object-storage bucket, by name — which is how its page is addressed."""
+
+    kind: t.Literal["bucket"] = "bucket"
+
+    name: str

hyperfluid/models/pipeline_field_reference_credential_variant.py

@@ -0,0 +1,28 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .credential_location import CredentialLocation
+
+
+@dataclasses.dataclass(kw_only=True)
+class PipelineFieldReferenceCredentialVariant(BaseModel):
+    """A credential the row is *about* but must never carry: where it lives,
+    never what it is (#3691, #4002, #4237).
+
+    The row's `value` is empty for this kind — there is deliberately nothing
+    to show — and the console renders the sentence for [`CredentialLocation`]
+    from its own locale file. #4002 put those sentences in `value` as
+    backend-authored English, which an i18next console rendered verbatim; a
+    discriminator is what the console can actually translate, and it does not
+    grow a fourth hardcoded sentence the next time a credential takes this
+    path."""
+
+    kind: t.Literal["credential"] = "credential"
+
+    location: CredentialLocation

hyperfluid/models/pipeline_field_reference_shared_model_variant.py

@@ -0,0 +1,16 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class PipelineFieldReferenceSharedModelVariant(BaseModel):
+    """A model served by the LLM Gateway, by catalog name."""
+
+    kind: t.Literal["shared_model"] = "shared_model"
+
+    name: str

hyperfluid/models/pipeline_field_reference_table_variant.py

@@ -0,0 +1,21 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class PipelineFieldReferenceTableVariant(BaseModel):
+    """One Iceberg table, in the data container its catalog belongs to."""
+
+    data_container_id: UUID
+
+    kind: t.Literal["table"] = "table"
+
+    schema: str
+
+    table: str

hyperfluid/models/pipeline_metadata.py

@@ -0,0 +1,49 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class PipelineMetadata(BaseModel):
+    """Pipeline metadata configuration (common to all pipeline types)"""
+
+    harbor_id: UUID
+    """The harbor the pipeline belongs to; the pipeline runs in that harbor's
+    namespace."""
+
+    name: str
+    """Pipeline name"""
+
+    organization_id: UUID
+    """Organization ID"""
+
+    organization_slug: str
+    """Organization slug (used for Keycloak realm)"""
+
+    enabled: bool | None = None
+    """Whether the pipeline is enabled. A disabled pipeline is created
+    suspended and runs nothing until it is resumed."""
+
+    max_duration_minutes: int | None | Unset = UNSET
+    """Wall-clock budget for one run, in minutes (1..=1440).
+
+    Omit it — the default — to let the run's budget follow its own cadence:
+    three times the schedule's interval, clamped into 15 minutes ..= 6 hours.
+    Set it for the run that genuinely needs longer than its cadence suggests,
+    such as a bulk ingest on a tight polling schedule."""
+
+    schedule: str | None | Unset = UNSET
+    """Cron expression (5-field) or "one_off" for a one-time run.
+
+    Omit it to get the pipeline type's own default cadence — every ten
+    minutes for most, every six hours for the context enricher — which is
+    the value each of them used to apply. Send `"one_off"` explicitly to ask
+    for a single run."""
+
+    trigger_immediate_run: bool | None = None
+    """When true, spawn an immediate Job in addition to the CronJob on creation.
+    Only meaningful for scheduled (non-one_off), enabled pipelines."""

hyperfluid/models/pipeline_response_data.py

@@ -0,0 +1,36 @@
+# 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 PipelineResponseData(BaseModel):
+    """The `PipelineResponseData` object."""
+
+    created_at: datetime
+
+    harbor_id: UUID
+    """The harbor the pipeline belongs to; the pipeline runs in that harbor's
+    namespace."""
+
+    id: UUID
+
+    name: str
+
+    org_id: UUID
+
+    status: bool
+    """`true` while the pipeline is scheduling runs — the inverse of
+    [`Self::suspended`], kept as the field older clients read."""
+
+    suspended: bool
+    """Whether the underlying CronJob is suspended (no new scheduled runs).
+    Read from the pipeline CRD, so it reflects what the cluster will do
+    rather than what the console last asked for."""
+
+    type: str

hyperfluid/models/pipeline_run.py

@@ -0,0 +1,62 @@
+# 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 .pipeline_run_status import PipelineRunStatus
+
+
+@dataclasses.dataclass(kw_only=True)
+class PipelineRun(BaseModel):
+    """The `PipelineRun` object."""
+
+    average_step_duration_millis: int
+
+    created_at: datetime
+
+    failures: int
+
+    files_processed: int
+
+    files_scanned: int
+
+    id: UUID
+
+    last_heartbeat_at: datetime
+
+    organization_id: UUID
+
+    pipeline_id: UUID
+
+    run_duration_millis: int
+
+    status: PipelineRunStatus
+
+    updated_at: datetime
+
+    heartbeat_lost: bool | None = None
+    """The run still says `Running` but stopped sending heartbeats long enough
+    ago that the console has given its in-flight references to someone
+    else.
+
+    Nothing ever flips such a row to a terminal status — a pod killed
+    outright simply stops beating — so without this a dead run is
+    indistinguishable from a working one. Computed on read, so it is true
+    of rows written long before this field existed. Always `false` for a
+    run that is not `Running`.
+
+    Optional on the wire: a client built from this spec must still be able
+    to read a console that predates the field, which is the normal state
+    during a rolling deploy, or whenever someone's CLI is newer than their
+    cluster. Absent means "no opinion", which reads the same as `false`."""
+
+    pod_name: str | None = None
+    """Name of the pod that executed the run, reported by the executor via the
+    downward API. Scopes the run's log query to that pod's collected stream
+    (ADR-0020); `None` falls back to the console-written stream."""

hyperfluid/models/pipeline_run_status.py

@@ -0,0 +1,19 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class PipelineRunStatus(StrEnum):
+    """The values of `PipelineRunStatus`; others are kept as received."""
+
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+PipelineRunStatusLiteral: t.TypeAlias = t.Literal[
+    "pending", "running", "completed", "failed"
+]
+"""The values of :class:`PipelineRunStatus`, which arguments take as plain strings too."""

hyperfluid/models/pipeline_stats.py

@@ -0,0 +1,21 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class PipelineStats(BaseModel):
+    """Aggregated statistics for a pipeline, derived from its run history."""
+
+    completed_runs: int
+
+    failed_runs: int
+
+    total_failures: int
+
+    total_runs: int
+
+    last_run_at: str | None = None

hyperfluid/models/pipeline_status_filter.py

@@ -0,0 +1,17 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class PipelineStatusFilter(StrEnum):
+    """Server-side status filter for `GET .../pipelines`, over the `suspended`
+    column (persisted from the CRD — see the `pipelines.suspended` migration)."""
+
+    ACTIVE = "active"
+    SUSPENDED = "suspended"
+    ALL = "all"
+
+
+PipelineStatusFilterLiteral: t.TypeAlias = t.Literal["active", "suspended", "all"]
+"""The values of :class:`PipelineStatusFilter`, which arguments take as plain strings too."""

hyperfluid/models/pipeline_type.py

@@ -0,0 +1,40 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class PipelineType(StrEnum):
+    """The values of `PipelineType`; others are kept as received."""
+
+    MARKITDOWN = "Markitdown"
+    HEPHAISTOS_PDFEED = "HephaistosPdfeed"
+    LABELIZER = "Labelizer"
+    FILE_ROUTER = "FileRouter"
+    COPY = "Copy"
+    FILE_SORTER = "FileSorter"
+    PAGE_SPLITTER = "PageSplitter"
+    OMNIFEED = "Omnifeed"
+    CONTEXT_ENRICHER = "ContextEnricher"
+    OPEN_DATA = "OpenData"
+    G_DRIVE_CONNECTOR = "GDriveConnector"
+    INBOUND_EMAIL = "InboundEmail"
+    SHARE_POINT_CONNECTOR = "SharePointConnector"
+
+
+PipelineTypeLiteral: t.TypeAlias = t.Literal[
+    "Markitdown",
+    "HephaistosPdfeed",
+    "Labelizer",
+    "FileRouter",
+    "Copy",
+    "FileSorter",
+    "PageSplitter",
+    "Omnifeed",
+    "ContextEnricher",
+    "OpenData",
+    "GDriveConnector",
+    "InboundEmail",
+    "SharePointConnector",
+]
+"""The values of :class:`PipelineType`, which arguments take as plain strings too."""

hyperfluid/models/pipeline_type_count.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 PipelineTypeCount(BaseModel):
+    """One pipeline type's share of the organization's pipelines, for the "types
+    in use" breakdown on the pipelines overview page."""
+
+    count: int
+    """Pipelines of this type, in the organization."""
+
+    type: str

hyperfluid/models/pipelines_page.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 .pipeline_response_data import PipelineResponseData
+
+
+@dataclasses.dataclass(kw_only=True)
+class PipelinesPage(BaseModel):
+    """One page of `GET /organizations/{organization_id}/pipelines`.
+
+    Shape mirrors `ManagedPostgresqlBackupsPage` (`data`/`total`/`page`/`limit`) —
+    same pagination contract, different resource."""
+
+    data: list[PipelineResponseData]
+
+    limit: int
+    """Page size actually served."""
+
+    page: int
+    """Zero-based page index actually served."""
+
+    total: int
+    """Total rows matching the filters, ignoring `page`/`limit` — for the
+    caller to compute page count."""

hyperfluid/models/pipelines_stats.py

@@ -0,0 +1,36 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .pipeline_response_data import PipelineResponseData
+    from .pipeline_type_count import PipelineTypeCount
+
+
+@dataclasses.dataclass(kw_only=True)
+class PipelinesStats(BaseModel):
+    """Response for `GET /organizations/{organization_id}/pipelines/stats` — every
+    number the pipelines overview page needs, aggregated in SQL rather than
+    derived client-side from a fetched page of rows (which silently undercounts
+    past the list endpoint's page-size ceiling)."""
+
+    active: int
+    """Pipelines currently scheduling runs (`suspended = false`)."""
+
+    by_type: list[PipelineTypeCount]
+    """Per-type counts, most common type first."""
+
+    recent: list[PipelineResponseData]
+    """The most recently created pipelines, newest first. Capped at 6 to match
+    `RECENT_LIMIT` in the console's `pipelines/overview.tsx`."""
+
+    suspended: int
+    """Pipelines with no new scheduled runs (`suspended = true`)."""
+
+    total: int
+    """Total pipelines matching the request's scope, across every type and
+    suspend state."""

hyperfluid/models/pitr_request.py

@@ -0,0 +1,38 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class PitrRequest(BaseModel):
+    """Opt in to point-in-time recovery, and choose how tight it is.
+
+    PostgreSQL ships its write-ahead log to object storage one 16 MiB segment at
+    a time, and a segment is archived only when it fills or when a timer forces
+    a switch. The interval is therefore the worst-case recovery point objective
+    for an *idle* database — a busy one fills segments and ships faster on its
+    own."""
+
+    enabled: bool
+    """Keep a bounded recovery point objective.
+
+    `false` does not stop WAL archiving — nothing can, while a backup target
+    is attached, because a base backup is not consistent without it. It
+    drops the forced segment switch, so WAL ships only when a segment fills:
+    the database stays restorable to its backups and to whatever WAL
+    happened to fill, but an idle hour may not be recoverable. That trades
+    a guarantee for the 16 MiB PUT a forced switch costs every interval."""
+
+    archive_interval_seconds: int | None | Unset = UNSET
+    """Seconds between forced WAL segment switches. Absent takes the platform's
+    recommended interval, resolved when the cluster is reconciled rather
+    than frozen into the resource now.
+
+    Five minutes is the recommended floor, not the enforced one: a shorter
+    interval is a legitimate choice for a database whose writes are worth
+    more than the segments. One minute is the hard floor, because below it
+    the cost of near-empty segments lands on the shared object store rather
+    than on the database that chose it."""

hyperfluid/models/platform.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 Platform(BaseModel):
+    """An OS/architecture pair. Shared with the registry read views
+    ([`TagResponse`](crate::hf_console::inbound::http::handlers::registry_views::TagResponse)`::platforms`)
+    — a single `Platform` DTO rather than a second one per consumer."""
+
+    arch: str
+
+    os: str

hyperfluid/models/platform_admin_action_log.py

@@ -0,0 +1,23 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class PlatformAdminActionLog(BaseModel):
+    """Audit payload for a cockpit mutation. `actor` is the platform admin's
+    email (fallback: Keycloak sub); `action` is a stable machine key
+    (`quota_profile_assigned`, `custom_limits_updated`, `feature_override_set`,
+    `feature_override_cleared`); `details` carries the action-specific payload
+    as string key/values (new plan slug, the limits written, the flag…) —
+    stringly-typed so the event enum keeps its `Eq` derive."""
+
+    action: str
+
+    actor: str
+
+    details: dict[str, t.Any]

hyperfluid/models/policy_preset.py

@@ -0,0 +1,23 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class PolicyPreset(StrEnum):
+    """A named, one-click permission policy. `Default` mirrors the workstation's
+    provisioned policy (write-class → ask, read-class → allow); `AllowAll` is the
+    live equivalent of `WS_OPENCODE_AUTOAPPROVE` (skip every prompt); `ReadOnly`
+    denies all write-class tools while keeping reads silent. `Custom` is reported
+    (never sent) when the live per-tool policy matches none of the presets."""
+
+    DEFAULT = "default"
+    ALLOW_ALL = "allow_all"
+    READ_ONLY = "read_only"
+    CUSTOM = "custom"
+
+
+PolicyPresetLiteral: t.TypeAlias = t.Literal[
+    "default", "allow_all", "read_only", "custom"
+]
+"""The values of :class:`PolicyPreset`, which arguments take as plain strings too."""

hyperfluid/models/port_protocol.py

@@ -0,0 +1,16 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class PortProtocol(StrEnum):
+    """L4 protocol of a `ContainerApp` port, mapping 1:1 to `ServicePort.protocol`."""
+
+    TCP = "TCP"
+    UDP = "UDP"
+    SCTP = "SCTP"
+
+
+PortProtocolLiteral: t.TypeAlias = t.Literal["TCP", "UDP", "SCTP"]
+"""The values of :class:`PortProtocol`, which arguments take as plain strings too."""

hyperfluid/models/post_message_request.py

@@ -0,0 +1,32 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import UNSET, BaseModel, Unset
+
+if t.TYPE_CHECKING:
+    from .message_attachment import MessageAttachment
+
+
+@dataclasses.dataclass(kw_only=True)
+class PostMessageRequest(BaseModel):
+    """The `PostMessageRequest` object."""
+
+    content: str
+    """Raw user content; the BFF wraps it in the opencode message envelope."""
+
+    agent: str | None | Unset = UNSET
+    """opencode agent/mode to run this turn under (e.g. "build" or "plan").
+    Omitted → opencode uses the session default."""
+
+    attachments: list[MessageAttachment] | None = None
+    """Images attached to the turn (pasted / dropped / picked in the composer).
+    Each becomes a `data:` URL `file` part next to the text part. `content`
+    may be empty when at least one attachment is present."""
+
+    model: str | None | Unset = UNSET
+    """Model to run this turn on, as "providerID/modelID" (e.g.
+    "openrouter/<provider>/<model>"). Split on the FIRST slash.
+    Omitted → opencode uses the workstation default model."""

hyperfluid/models/postgresql_connector_detail.py

@@ -0,0 +1,33 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class PostgresqlConnectorDetail(BaseModel):
+    """Detail view of a PostgreSQL connector with the linked DBaaS context
+    resolved (cluster + user), as served to the catalog detail page."""
+
+    data_dock_id: UUID
+
+    id: UUID
+
+    name: str
+
+    secret_name: str
+
+    cluster_id: UUID | None = None
+
+    cluster_name: str | None = None
+
+    managed_postgresql_user_id: UUID | None = None
+
+    permission_level: str | None = None
+    """Permission level of the linked user (always `viewer` for non-legacy rows)."""
+
+    username: str | None = None
+    """Username of the linked managed PostgreSQL user."""

hyperfluid/models/pr_checks.py

@@ -0,0 +1,17 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class PrChecks(StrEnum):
+    """Rolled-up CI status for a PR, derived from GitHub's `statusCheckRollup`."""
+
+    NONE = "none"
+    PENDING = "pending"
+    SUCCESS = "success"
+    FAILURE = "failure"
+
+
+PrChecksLiteral: t.TypeAlias = t.Literal["none", "pending", "success", "failure"]
+"""The values of :class:`PrChecks`, which arguments take as plain strings too."""