hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/models/nextflow_head_request.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 NextflowHeadRequest(BaseModel):
+    """Head pod sizing. `None` fields resolve to the platform default."""
+
+    cpu: str | None | Unset = UNSET
+
+    memory: str | None | Unset = UNSET

hyperfluid/models/nextflow_pod_role.py

@@ -0,0 +1,20 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class NextflowPodRole(StrEnum):
+    """Role of a pod inside a Nextflow environment's task namespace (ADR-0050 §3),
+    the value of the `hyperfluid.nudibranches.tech/nextflow-role` pod label the
+    operator (head, cleanup) and the platform `k8s.pod` config (tasks) stamp.
+    A closed enum mapped to a static label value, so narrowing a Nextflow run's
+    logs to one role adds no user text to the LogsQL filter."""
+
+    HEAD = "head"
+    TASK = "task"
+    CLEANUP = "cleanup"
+
+
+NextflowPodRoleLiteral: t.TypeAlias = t.Literal["head", "task", "cleanup"]
+"""The values of :class:`NextflowPodRole`, which arguments take as plain strings too."""

hyperfluid/models/nextflow_response.py

@@ -0,0 +1,54 @@
+# 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 .nextflow_run_counts_response import NextflowRunCountsResponse
+
+
+@dataclasses.dataclass(kw_only=True)
+class NextflowResponse(BaseModel):
+    """The `NextflowResponse` object."""
+
+    accepts_runs: bool
+    """Whether the environment may currently accept a new run: not in
+    `Error` phase, and (when known - the CR is only read on the
+    single-item paths, never per row on the list) not being deleted."""
+
+    created_at: datetime
+
+    description: str
+
+    harbor_id: UUID
+
+    id: UUID
+
+    name: str
+
+    organization_id: UUID
+
+    run_counts: NextflowRunCountsResponse
+
+    slug: str
+
+    status: str
+
+    tags: list[str]
+
+    updated_at: datetime
+
+    resolved_runtime_image: str | None = None
+
+    runtime_image: str | None = None
+
+    storage_size: str | None = None
+
+    task_namespace: str | None = None
+
+    work_volume_capacity: str | None = None

hyperfluid/models/nextflow_run_counts_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 NextflowRunCountsResponse(BaseModel):
+    """Aggregate run counts on a `NextflowResponse` - always from the same
+    `LEFT JOIN`/subquery the row itself came from, never a follow-up query."""
+
+    active: int
+    """Runs in `Pending` or `Running`."""
+
+    total: int

hyperfluid/models/nextflow_run_detail_response.py

@@ -0,0 +1,67 @@
+# 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 NextflowRunDetailResponse(BaseModel):
+    """A run's DB row plus the fields only the CR carries: the spec's
+    pipeline-execution parameters (never mirrored to the DB) and the status
+    fields the operator writes as the head progresses (read straight off the
+    CR here for the freshest value, ahead of the internal API's next call)."""
+
+    created_at: datetime
+
+    harbor_id: UUID
+
+    id: UUID
+
+    name: str
+
+    nextflow_id: UUID
+
+    organization_id: UUID
+
+    pipeline: str
+
+    profiles: list[str]
+
+    status: str
+
+    updated_at: datetime
+
+    cleanup: bool | None = None
+    """Delete intermediate work files on success (CR-only)."""
+
+    exit_code: int | None = None
+
+    finished_at: datetime | None = None
+
+    head_job: str | None = None
+    """Head Job name."""
+
+    launch_root: str | None = None
+    """Root of the resume chain: the run whose launch directory this run uses."""
+
+    launched_by: str | None = None
+
+    message: str | None = None
+
+    params: str | None = None
+    """Pipeline parameters as a JSON object (CR-only, not mirrored to the DB)."""
+
+    resume_from: str | None = None
+
+    revision: str | None = None
+
+    session_id: str | None = None
+
+    started_at: datetime | None = None
+
+    timeout_minutes: int | None = None
+    """Wall-clock ceiling of the head, in minutes (CR-only)."""

hyperfluid/models/nextflow_run_response.py

@@ -0,0 +1,49 @@
+# 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 NextflowRunResponse(BaseModel):
+    """The `NextflowRunResponse` object."""
+
+    created_at: datetime
+
+    harbor_id: UUID
+
+    id: UUID
+
+    name: str
+
+    nextflow_id: UUID
+
+    organization_id: UUID
+
+    pipeline: str
+
+    profiles: list[str]
+
+    status: str
+
+    updated_at: datetime
+
+    exit_code: int | None = None
+
+    finished_at: datetime | None = None
+
+    launched_by: str | None = None
+
+    message: str | None = None
+
+    resume_from: str | None = None
+
+    revision: str | None = None
+
+    session_id: str | None = None
+
+    started_at: datetime | None = None

hyperfluid/models/nextflow_run_task_response.py

@@ -0,0 +1,43 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from datetime import datetime
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class NextflowRunTaskResponse(BaseModel):
+    """One task pod of a `NextflowRun` - a pod `nf-k8s` created for one process
+    invocation, labelled with the run (ADR-0050 §3)."""
+
+    name: str
+
+    phase: str
+    """Pod phase, or `Terminating` while a deletion is pending."""
+
+    exit_code: int | None = None
+    """Exit status of the task's container, once it has terminated."""
+
+    finished_at: datetime | None = None
+
+    message: str | None = None
+    """Termination message, same fallback as `reason` (for `Unschedulable`,
+    the scheduler's own message), capped at [`MAX_TASK_MESSAGE_BYTES`]."""
+
+    node: str | None = None
+
+    process: str | None = None
+    """`nextflow.io/processName`, when the pod carries it."""
+
+    reason: str | None = None
+    """Brief termination reason (`OOMKilled`, `Error`, …) from the
+    container's own terminated state, or - when the container never ran
+    at all - from the pod's own status (`DeadlineExceeded`, `Evicted`).
+    A Pending pod the scheduler cannot place reports `Unschedulable`."""
+
+    started_at: datetime | None = None
+
+    task_name: str | None = None
+    """`nextflow.io/taskName`, when the pod carries it."""

hyperfluid/models/nextflow_scm_platform.py

@@ -0,0 +1,20 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class NextflowScmPlatform(StrEnum):
+    """Git hosting platforms Nextflow's SCM file knows. Serialised lowercase,
+    which is also the spelling Nextflow expects in `platform = '…'`."""
+
+    GITHUB = "github"
+    GITLAB = "gitlab"
+    GITEA = "gitea"
+    BITBUCKET = "bitbucket"
+
+
+NextflowScmPlatformLiteral: t.TypeAlias = t.Literal[
+    "github", "gitlab", "gitea", "bitbucket"
+]
+"""The values of :class:`NextflowScmPlatform`, which arguments take as plain strings too."""

hyperfluid/models/nextflow_scm_request.py

@@ -0,0 +1,26 @@
+# 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 .nextflow_scm_platform import NextflowScmPlatform
+
+
+@dataclasses.dataclass(kw_only=True)
+class NextflowScmRequest(BaseModel):
+    """Private Git provider the head pulls pipelines from (ADR-0050 §7)."""
+
+    platform: NextflowScmPlatform
+
+    token_secret: str
+    """Name of a plaintext secret-manager entry holding the access token."""
+
+    server: str | None | Unset = UNSET
+    """Base URL of a self-hosted server. `None` means the platform's public
+    service."""
+
+    user: str | None | Unset = UNSET

hyperfluid/models/nextflow_storage_request.py

@@ -0,0 +1,20 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class NextflowStorageRequest(BaseModel):
+    """The environment's shared work volume (ADR-0050 §2). Omitted fields resolve
+    to the platform defaults."""
+
+    size: str | None | Unset = UNSET
+    """Requested size of the work volume, as a Kubernetes quantity (`500Gi`).
+    May grow; a PATCH that would shrink it is refused with a 400."""
+
+    storage_class_name: str | None | Unset = UNSET
+    """`ReadWriteMany` StorageClass. Immutable once bound: a PATCH that would
+    change it away from an already-set value is refused with a 400."""

hyperfluid/models/nextflow_task_quota_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 NextflowTaskQuotaRequest(BaseModel):
+    """Ceiling on the task namespace. `None` fields resolve to the platform
+    defaults."""
+
+    cpu: str | None | Unset = UNSET
+
+    max_pods: int | None | Unset = UNSET
+
+    memory: str | None | Unset = UNSET

hyperfluid/models/node_tier.py

@@ -0,0 +1,22 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class NodeTier(StrEnum):
+    """Predefined resource tiers for managed PostgreSQL instances.
+    Memory limits are always equal to memory requests."""
+
+    NANO = "nano"
+    MICRO = "micro"
+    SMALL = "small"
+    MEDIUM = "medium"
+    LARGE = "large"
+    XLARGE = "xlarge"
+
+
+NodeTierLiteral: t.TypeAlias = t.Literal[
+    "nano", "micro", "small", "medium", "large", "xlarge"
+]
+"""The values of :class:`NodeTier`, which arguments take as plain strings too."""

hyperfluid/models/normalized_message.py

@@ -0,0 +1,55 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .message_part import MessagePart
+    from .message_role import MessageRole
+
+
+@dataclasses.dataclass(kw_only=True)
+class NormalizedMessage(BaseModel):
+    """A chat message in the stable shape the React panel renders. The BFF
+    normalizes opencode's `{ info, parts }` envelope into this so the frontend
+    never has to know opencode's wire schema (and so an opencode upgrade can't
+    silently reshape the chat). `content` stays for a quick text-only render;
+    `parts` carries the full ordered agentic stream."""
+
+    completed: bool
+    """Whether opencode marked the message finished (`info.time.completed`).
+    `false` on the assistant message of a turn still streaming — the UI
+    uses this to decide which message hosts the live thinking indicator,
+    so a follow-up send can't briefly animate the PREVIOUS turn's message."""
+
+    content: str
+    """Concatenated text of every `text` part, in order."""
+
+    created_at: str
+    """ISO-8601 timestamp derived from opencode's `info.time.created` (epoch ms)."""
+
+    id: str
+    """Opencode message id (`msg_...`)."""
+
+    parts: list[MessagePart]
+    """Ordered agentic parts: prose, reasoning, tool calls, patches."""
+
+    role: MessageRole
+
+    session_id: str
+
+    cost: float | None = None
+    """Cost in USD for the turn, if reported."""
+
+    error: str | None = None
+    """Human-readable failure of the turn, when opencode aborted it
+    (`info.error`, e.g. a provider rejecting the API key). The UI renders it
+    as an error callout in the assistant bubble — without this, a failed
+    turn shows as an EMPTY assistant message and looks like a mystery
+    instead of an actionable error."""
+
+    tokens: int | None = None
+    """Total tokens for the turn, if opencode reported a step-finish."""

hyperfluid/models/notification_channel_dto.py

@@ -0,0 +1,36 @@
+# 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 .channel_kind import ChannelKind
+
+
+@dataclasses.dataclass(kw_only=True)
+class NotificationChannelDto(BaseModel):
+    """The `NotificationChannelDto` object."""
+
+    created_at: datetime
+
+    enabled: bool
+
+    id: UUID
+
+    kind: ChannelKind
+
+    name: str
+
+    recipients: list[str]
+    """Email channels only. Empty means "the organization's admins"."""
+
+    updated_at: datetime
+
+    url_masked: str | None = None
+    """Webhook channels only, and deliberately truncated — the full URL is a
+    credential."""

hyperfluid/models/object_delete_failure.py

@@ -0,0 +1,18 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class ObjectDeleteFailure(BaseModel):
+    """The `ObjectDeleteFailure` object."""
+
+    key: str
+
+    code: str | None = None
+    """The S3 error code, e.g. `AccessDenied`."""
+
+    message: str | None = None

hyperfluid/models/object_instance.py

@@ -0,0 +1,24 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class ObjectInstance(BaseModel):
+    """One resolved row of an object type's backing table, keyed by property
+    `api_name` (not physical column) so the shape matches the semantic model."""
+
+    primary_key: t.Any
+    """Value of the primary-key column for this row — the handle used to fetch
+    this instance or traverse a link from it."""
+
+    properties: t.Any
+    """`property api_name -> value` for every source-column-mapped property."""
+
+    title: str | None = None
+    """The `is_title` property's value when the object type designates one — a
+    human label for the instance (e.g. a patient's name)."""

hyperfluid/models/object_storage_owner_key_revealed_log.py

@@ -0,0 +1,28 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class ObjectStorageOwnerKeyRevealedLog(BaseModel):
+    """Audit payload for a console-mediated reveal of a Ceph RGW tenant-owner
+    key. The actor is the enclosing request's `oauth_id`: the caller for an
+    externally-authenticated read, or a fixed system actor for the internal
+    router (see `handlers::secrets::read_secret_value`'s `SYSTEM_REVEAL_ACTOR`).
+
+    Never carries the secret's value, key id or any other secret material —
+    only what identifies which entry was revealed and, when resolvable, which
+    harbor it belongs to."""
+
+    secret_id: UUID
+    """Secret-Manager id of the revealed entry."""
+
+    harbor_id: UUID | None = None
+    """Parsed from the secret's `harbor-id=<uuid>` tag
+    (`harbor_binding_reconciler.rs`'s `owner_secret_id_tag`). `None` when
+    the tag is absent or unparsable — the reveal is still recorded, just
+    without a harbor attribution, rather than silently skipped."""

hyperfluid/models/object_storage_usage_collected_log.py

@@ -0,0 +1,34 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from datetime import datetime
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class ObjectStorageUsageCollectedLog(BaseModel):
+    """Audit payload for one usage sweep over one organization's buckets on one
+    backend. It names who read (the collector's principal), where (the
+    backend and its driver), how much (buckets read, and those whose read
+    failed) and when; never a bucket's content, key or credential."""
+
+    backend: str
+    """The `ObjectStorageBackend` (the zone id) the buckets live on."""
+
+    buckets_failed: int
+    """Buckets whose read failed (nothing recorded for them this sweep)."""
+
+    buckets_read: int
+    """Buckets whose usage was read and recorded."""
+
+    driver: str
+    """`cephRgw` or `s3`."""
+
+    finished_at: datetime
+
+    principal: str
+    """Always [`OBJECT_STORAGE_USAGE_COLLECTOR_PRINCIPAL`]."""
+
+    started_at: datetime

hyperfluid/models/object_type.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 ObjectType(BaseModel):
+    """A class of business entity (Customer, Invoice, Flight...), optionally
+    grounded to one Iceberg table (`backing_*`, all nullable — a type can be
+    authored as a pure concept first)."""
+
+    api_name: str
+    """Stable machine name, unique per org — the identity consumers/SDKs bind
+    to. Immutable after creation (mirrors why `Label.key`/`value` are
+    mutable but an Object Type's `api_name` is not: renaming it would
+    break every Link Type and external SDK reference to it)."""
+
+    created_at: datetime
+
+    creator_id: UUID
+
+    display_name: str
+
+    id: UUID
+
+    organization_id: UUID
+
+    updated_at: datetime
+
+    backing_catalog: str | None = None
+
+    backing_schema: str | None = None
+
+    backing_table: str | None = None
+
+    color: str | None = None
+
+    data_dock_id: UUID | None = None
+
+    description: str | None = None
+
+    icon: str | None = None
+
+    plural_display_name: str | None = None
+
+    primary_key_column: str | None = None

hyperfluid/models/object_type_with_properties.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 .object_type import ObjectType
+    from .property_definition import PropertyDefinition
+
+
+@dataclasses.dataclass(kw_only=True)
+class ObjectTypeWithProperties(BaseModel):
+    """[`ObjectType`] plus its [`PropertyDefinition`]s — what `get_object_type`
+    returns, so a single call gets the whole shape of the type."""
+
+    object_type: ObjectType
+
+    properties: list[PropertyDefinition]