hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/models/service_link_kind.py

@@ -0,0 +1,35 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class ServiceLinkKind(StrEnum):
+    """The kind of a service participating in a link. Constrained to the kinds the
+    ServiceLink controller knows how to resolve into a pod selector + port.
+
+    Object storage (shared Ceph/RGW) and the Hyperfluid platform control plane
+    are deliberately NOT link kinds: both are effectively always-reachable
+    (object storage is internet-exposed; the platform is a hard runtime
+    dependency), so their egress lives unconditionally in every workload's
+    baseline policy rather than being declared per-link (ADR-0021 §6–§7)."""
+
+    AIRFLOW = "Airflow"
+    CONTAINER_APP = "ContainerApp"
+    HF_KEY_VALUE_CACHE = "HfKeyValueCache"
+    MANAGED_POSTGRE_SQL = "ManagedPostgreSQL"
+    TRINO = "Trino"
+    KAFKA = "Kafka"
+    PIPELINE = "Pipeline"
+
+
+ServiceLinkKindLiteral: t.TypeAlias = t.Literal[
+    "Airflow",
+    "ContainerApp",
+    "HfKeyValueCache",
+    "ManagedPostgreSQL",
+    "Trino",
+    "Kafka",
+    "Pipeline",
+]
+"""The values of :class:`ServiceLinkKind`, which arguments take as plain strings too."""

hyperfluid/models/service_link_port.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 ServiceLinkPort(BaseModel):
+    """A `(port, protocol)` pair a link opens on its target. `protocol` is the L4
+    protocol spelled as Kubernetes does — `TCP`, `UDP`, or `SCTP`."""
+
+    port: int
+
+    protocol: str

hyperfluid/models/service_link_response.py

@@ -0,0 +1,34 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .harbor_ref import HarborRef
+    from .service_link_port import ServiceLinkPort
+    from .service_ref import ServiceRef
+
+
+@dataclasses.dataclass(kw_only=True)
+class ServiceLinkResponse(BaseModel):
+    """A service link as surfaced to the console UI. Built directly from the CRD —
+    there is no database row (links are pure custom resources)."""
+
+    consumer: ServiceRef
+
+    harbor: HarborRef
+
+    name: str
+    """The CRD object name (also the link's identifier within a harbor)."""
+
+    ports: list[ServiceLinkPort]
+    """The `(port, protocol)` pairs the operator opened for this link; empty
+    until it has reconciled."""
+
+    ready: bool
+    """Aggregate readiness from the CRD status conditions."""
+
+    target: ServiceRef

hyperfluid/models/service_ref.py

@@ -0,0 +1,20 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .service_link_kind import ServiceLinkKind
+
+
+@dataclasses.dataclass(kw_only=True)
+class ServiceRef(BaseModel):
+    """One endpoint of a link: a service of a known kind, referenced by name within
+    the harbor namespace the link lives in (both endpoints live there)."""
+
+    kind: ServiceLinkKind
+
+    name: str

hyperfluid/models/session_summary.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 .session_workspace import SessionWorkspace
+
+
+@dataclasses.dataclass(kw_only=True)
+class SessionSummary(BaseModel):
+    """A session row for the chat session rail. `title` is whatever opencode
+    stored at create time — for our sessions that is the agent preset name
+    (e.g. "Code Helper"), so the rail reads as a list of named conversations
+    instead of opaque ids."""
+
+    created_at: str
+    """ISO-8601 created timestamp from opencode's `time.created` (epoch ms)."""
+
+    id: str
+    """Opencode session id (`ses_...`)."""
+
+    title: str
+    """Human title set at create time; empty if opencode had none."""
+
+    directory: str | None = None
+
+    parent_id: str | None = None
+    """Parent session id when this is a `task` sub-agent's child session
+    (opencode's `parentID`). Lets the frontend scope prompts to a session's
+    family and keep child sessions out of the rail."""
+
+    workspace: SessionWorkspace | None = None

hyperfluid/models/session_workspace.py

@@ -0,0 +1,19 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class SessionWorkspace(BaseModel):
+    """The `SessionWorkspace` object."""
+
+    branch: str
+
+    directory: str
+
+    repo: str
+
+    worktree: bool

hyperfluid/models/session_workspace_request.py

@@ -0,0 +1,25 @@
+# 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 .workspace_mode import WorkspaceMode
+
+
+@dataclasses.dataclass(kw_only=True)
+class SessionWorkspaceRequest(BaseModel):
+    """The `SessionWorkspaceRequest` object."""
+
+    mode: WorkspaceMode
+
+    repo: str
+
+    branch: str | None | Unset = UNSET
+
+    create_worktree: bool | None = None
+
+    worktree: str | None | Unset = UNSET

hyperfluid/models/set_api_key_rate_limits_request.py

@@ -0,0 +1,18 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class SetApiKeyRateLimitsRequest(BaseModel):
+    """Replace this key's tenant-set rate ceilings. Sent whole, never merged: an
+    absent (or null) axis CLEARS that ceiling, because clearing one is exactly
+    the operation an admin performs to loosen a limit and a merge patch would
+    read it as "leave it alone" (the same rule ADR-0039 applies to policies)."""
+
+    max_llm_rpm: int | None | Unset = UNSET
+
+    max_llm_tpm: int | None | Unset = UNSET

hyperfluid/models/set_bindings_body.py

@@ -0,0 +1,15 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class SetBindingsBody(BaseModel):
+    """The `SetBindingsBody` object."""
+
+    channel_ids: list[UUID]
+    """Channels that receive this signal. Empty = every enabled channel."""

hyperfluid/models/set_key_budget_body.py

@@ -0,0 +1,27 @@
+# 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 .spend_window import SpendWindow
+
+
+@dataclasses.dataclass(kw_only=True)
+class SetKeyBudgetBody(BaseModel):
+    """Set one ceiling on one API key.
+
+    Organization-wide ceilings are deliberately NOT settable here: they bound
+    the platform's exposure and are the cockpit's to set. An org admin
+    allocates inside what was sold."""
+
+    api_key_id: UUID
+
+    credits: int
+    """Whole credits, as a human types them."""
+
+    window: SpendWindow

hyperfluid/models/set_org_settings_body.py

@@ -0,0 +1,13 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class SetOrgSettingsBody(BaseModel):
+    """The `SetOrgSettingsBody` object."""
+
+    scan_interval_hours: int | None | Unset = UNSET

hyperfluid/models/set_organization_logs_retention_request_body.py

@@ -0,0 +1,15 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class SetOrganizationLogsRetentionRequestBody(BaseModel):
+    """Body to set an org's per-org logs retention (ADR-0020 query-time visibility
+    clamp). `null` clears the clamp (the org sees the full global window); a
+    value must be within `1..=30` days."""
+
+    logs_retention_days: int | None | Unset = UNSET

hyperfluid/models/set_role_permissions_request_body.py

@@ -0,0 +1,17 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class SetRolePermissionsRequestBody(BaseModel):
+    """Replace a role's whole permission bundle in one request. The role editor
+    stages adds/removes locally and saves the final set here, so a save is one
+    round-trip + one projection refresh instead of one per toggle."""
+
+    permission_ids: list[UUID]
+    """The complete set of permission ids the role should hold after the save."""

hyperfluid/models/set_service_account_attributes_request.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 SetServiceAccountAttributesRequest(BaseModel):
+    """Replaces the account's whole attribute set."""
+
+    attributes: list[str]
+    """Attributes in `namespace::value` format.
+    Example: `["region::occitanie", "department::sales"]`"""

hyperfluid/models/set_thresholds_body.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 SetThresholdsBody(BaseModel):
+    """The `SetThresholdsBody` object."""
+
+    critical_pct: int
+
+    warning_pct: int

hyperfluid/models/set_user_attributes_request.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 SetUserAttributesRequest(BaseModel):
+    """Request to set all attributes for a user (replaces existing)."""
+
+    attributes: list[str]
+    """List of attributes in `namespace::value` format.
+    Example: `["region::occitanie", "department::sales"]`
+
+    Repeats are collapsed, so the limit applies to distinct attributes. The
+    namespaces `role`, `email`, `email_domain` and `client_id` are reserved —
+    the authorization bundles derive keys of those names from the principal's
+    own identity and roles, so an attribute using one is refused."""

hyperfluid/models/setup_outcome.py

@@ -0,0 +1,19 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class SetupOutcome(StrEnum):
+    """Verdict on the LATEST template-setup run of the workstation's pod."""
+
+    SUCCEEDED = "succeeded"
+    FAILED = "failed"
+    RUNNING = "running"
+    UNKNOWN = "unknown"
+
+
+SetupOutcomeLiteral: t.TypeAlias = t.Literal[
+    "succeeded", "failed", "running", "unknown"
+]
+"""The values of :class:`SetupOutcome`, which arguments take as plain strings too."""

hyperfluid/models/sha256_hash_deduping_strategy.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 Sha256HashDedupingStrategy(BaseModel):
+    """The `Sha256HashDedupingStrategy` object."""
+
+    flatten: bool
+    """Whether to flatten directory structure (true) or preserve it (false)"""
+
+    length: int
+    """Number of characters from SHA256 hash to use as suffix"""

hyperfluid/models/share_point_source_config.py

@@ -0,0 +1,58 @@
+# 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 .secret_ref import SecretRef
+
+
+@dataclasses.dataclass(kw_only=True)
+class SharePointSourceConfig(BaseModel):
+    """SharePoint source configuration.
+
+    The connector authenticates as an Entra ID (Azure AD) **application**, not as
+    a user: the client-credentials grant against the tenant's token endpoint,
+    exchanged for a Microsoft Graph token. That is the only shape that survives
+    an unattended nightly run, since it involves no refresh token to expire and
+    no user whose password rotation stops the pipeline.
+
+    The app registration needs the `Sites.Read.All` application permission with
+    tenant admin consent — or, better scoped, `Sites.Selected` plus a per-site
+    grant on just the libraries being ingested."""
+
+    client_id: str
+    """Application (client) ID of the app registration."""
+
+    site_url: str
+    """The site to read, as its browser URL:
+    `https://contoso.sharepoint.com/sites/Documents`.
+
+    Taken as a URL rather than a Graph site id because the URL is what a user
+    can copy out of their address bar, and the id is what no one can find.
+    The connector resolves one to the other at run time."""
+
+    tenant_id: str
+    """Entra ID tenant, as a GUID or a verified domain (`contoso.onmicrosoft.com`)."""
+
+    client_secret: str | None | Unset = UNSET
+    """The application's client secret, as a literal.
+
+    Optional, and mutually exclusive with `client_secret_secret`: exactly one
+    of the two is required. Present at all only so a caller with no secret
+    manager entry can still create a connector; the reference form is the one
+    the console sends, and the only one that keeps the credential out of the
+    pipeline document."""
+
+    client_secret_secret: SecretRef | None | Unset = UNSET
+
+    drive_name: str | None | Unset = UNSET
+    """Document library to ingest, by its display name ("Documents", "Dossiers
+    patients"). Omit it for the site's default library."""
+
+    prefix: str | None | Unset = UNSET
+    """Folder path within the library, e.g. `"Imagerie/2026"`. Omit it for the
+    whole library."""

hyperfluid/models/shared_model_response.py

@@ -0,0 +1,99 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .model_protocol import ModelProtocol
+
+
+@dataclasses.dataclass(kw_only=True)
+class SharedModelResponse(BaseModel):
+    """The `SharedModelResponse` object."""
+
+    cpu: str
+    """CPU resources"""
+
+    gpu: int
+    """GPU count — one container's limit, so a per-pod figure. Multiply by
+    `replicas` for what the model occupies cluster-wide."""
+
+    kind: str
+    """`"model"` for a raw shared model, `"flavor"` for a platform-owned
+    `ModelFlavor` binding (ADR-0032). Existing entries carry `kind:
+    "model"` and `None` for the fields below, so this stays
+    backward-compatible for callers that don't know about flavors yet."""
+
+    memory: str
+    """Memory resources"""
+
+    model_type: str
+    """Model type (generation, embedding, ocr)"""
+
+    name: str
+    """InferenceService name (or external-model name), or a flavor's public
+    routing name when `kind == "flavor"`"""
+
+    phase: str
+    """Current phase (Ready, Provisioning, Failed) — or a flavor's phase
+    (Bound, Degraded, Unbound) when `kind == "flavor"`"""
+
+    runtime: str
+    """Inference engine (`vllm`, `sglang`, `tgi`, …), `external` for a model
+    hosted off-cluster, or `unknown` when the serving's spec names none."""
+
+    active_model: str | None = None
+    """Flavor-only: the highest-weight ready target's shared-model name (the
+    one shown to users as "active")."""
+
+    context_tokens: int | None = None
+    """Flavor-only: the active target's served context window."""
+
+    endpoint: str | None = None
+    """Endpoint URL"""
+
+    max_replicas: int | None = None
+    """Autoscaler ceiling (`spec.scaling.maxReplicas`, or a classic
+    InferenceService's `predictor.maxReplicas`); `null` when the pod count
+    is fixed."""
+
+    protocol: ModelProtocol | None = None
+
+    replicas: int | None = None
+    """Pods behind the serving: `1` for the ordinary single-pod serving, `0`
+    for one scaled to zero, the autoscaler's floor when `max_replicas` is
+    set. `null` when there is no serving to measure — an externally-hosted
+    model, or a `kind: "flavor"` row, which names a binding rather than a
+    deployment."""
+
+    servable: bool | None = None
+    """Whether the platform can actually serve traffic to this model.
+
+    The default is `true`, NOT `serde`'s default for a `bool`. This struct
+    also parses the gateway's catalog JSON, and during a rollout the
+    gateway may still be a build that predates the field: defaulting to
+    `false` there would mark every model unservable at once and empty every
+    picker in the console. "Assume usable unless told otherwise" is the
+    only safe direction for a compatibility default.
+
+    This is a read-only response DTO, not a CRD spec — the platform rule
+    against persisting a default into a `spec` does not apply: nothing here
+    is ever written back to Kubernetes."""
+
+    served_model_name: str | None = None
+    """Served model name (the OpenAI `model` id)"""
+
+    tool_calling: bool | None = None
+    """Flavor-only: whether the active target advertises tool calling."""
+
+    unservable_detail: str | None = None
+    """Free-text detail for an administrator, when the platform has something
+    specific to add beyond the code. `null` unless the gateway filled it in."""
+
+    unservable_reason: str | None = None
+    """Stable machine code for why not (`unsupported_protocol` /
+    `unknown_protocol`), `null` when `servable`. The console translates the
+    code; the operator branches on it."""

hyperfluid/models/sheet_preview.py

@@ -0,0 +1,39 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .imported_column import ImportedColumn
+
+
+@dataclasses.dataclass(kw_only=True)
+class SheetPreview(BaseModel):
+    """The `SheetPreview` object."""
+
+    columns: list[ImportedColumn]
+    """The columns the table would get."""
+
+    rows: list[list[str | None]]
+    """The first data rows, one value per column, as displayed text."""
+
+    total_rows: int
+    """Data rows in total."""
+
+    error: str | None = None
+    """Why this sheet cannot be imported (empty, header row out of range…).
+    The other fields are empty when set."""
+
+    first_row: int | None = None
+    """1-based rows spanned by the sheet: the valid values of `header_row`."""
+
+    header_row: int | None = None
+    """1-based row number of the header, detected or as sent."""
+
+    last_row: int | None = None
+
+    name: str | None = None
+    """The sheet name; `null` for a CSV."""

hyperfluid/models/sign_compute_dock_ssh_key_request.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 SignComputeDockSshKeyRequest(BaseModel):
+    """The `SignComputeDockSshKeyRequest` object."""
+
+    public_key: str
+    """The caller's SSH **public** key in OpenSSH authorized-keys format
+    (e.g. `ssh-ed25519 AAAA... user@host`). Never a private key."""

hyperfluid/models/sign_compute_dock_ssh_key_response.py

@@ -0,0 +1,22 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class SignComputeDockSshKeyResponse(BaseModel):
+    """The `SignComputeDockSshKeyResponse` object."""
+
+    certificate: str
+    """The signed OpenSSH user certificate (`ssh-...-cert-v01@openssh.com ...`),
+    to be written next to the caller's private key as `*-cert.pub`."""
+
+    principal: str
+    """The single principal the certificate is valid for — derived from the
+    authenticated caller, never from the request."""
+
+    ttl_seconds: int
+    """Certificate lifetime in seconds (3h). The certificate cannot be renewed."""

hyperfluid/models/signal_bindings_dto.py

@@ -0,0 +1,16 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class SignalBindingsDto(BaseModel):
+    """The `SignalBindingsDto` object."""
+
+    channel_ids: list[UUID]
+
+    signal: str