hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/models/git_image_source.py

@@ -0,0 +1,54 @@
+# 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 .git_provider import GitProvider
+    from .git_ref import GitRef
+    from .secret_manager_ref import SecretManagerRef
+    from .sync_policy import SyncPolicy
+
+
+@dataclasses.dataclass(kw_only=True)
+class GitImageSource(BaseModel):
+    """A repository file (`hyperfluid.toml`) that declares the app's image.
+
+    Every optional field is a platform default when absent, resolved at
+    reconcile and never written into the spec."""
+
+    _JSON_KEYS: t.ClassVar[t.Mapping[str, str]] = {
+        "base_url": "baseUrl",
+        "interval_seconds": "intervalSeconds",
+        "sync_policy": "syncPolicy",
+    }
+
+    credential: SecretManagerRef
+
+    provider: GitProvider
+
+    repository: str
+    """Repository path on the provider, e.g. `acme/orders-api` (GitLab: the
+    full group path)."""
+
+    base_url: str | None | Unset = UNSET
+    """API base URL of a self-hosted provider (GitHub Enterprise, self-managed
+    GitLab, external Forgejo). Absent means the provider's public host, or
+    the organization's own Forgejo."""
+
+    container: str | None | Unset = UNSET
+    """Key of the `[containers.<key>]` entry this app reads. Absent means the
+    ContainerApp's name."""
+
+    interval_seconds: int | None | Unset = UNSET
+    """Seconds between two checks, at least 300. Absent means 300."""
+
+    path: str | None | Unset = UNSET
+    """Path of the file in the repository. Absent means `hyperfluid.toml`."""
+
+    ref: GitRef | None | Unset = UNSET
+
+    sync_policy: SyncPolicy | None | Unset = UNSET

hyperfluid/models/git_provider.py

@@ -0,0 +1,16 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class GitProvider(StrEnum):
+    """Git hosting provider of an image source."""
+
+    GITHUB = "github"
+    GITLAB = "gitlab"
+    FORGEJO = "forgejo"
+
+
+GitProviderLiteral: t.TypeAlias = t.Literal["github", "gitlab", "forgejo"]
+"""The values of :class:`GitProvider`, which arguments take as plain strings too."""

hyperfluid/models/git_ref.py

@@ -0,0 +1,27 @@
+# this file is @generated
+from __future__ import annotations
+
+import typing as t
+
+from ..serialization import Discriminator, UnknownVariant
+from .git_ref_branch_variant import GitRefBranchVariant
+from .git_ref_tag_variant import GitRefTagVariant
+
+GitRef: t.TypeAlias = t.Annotated[
+    GitRefBranchVariant | GitRefTagVariant | UnknownVariant,
+    Discriminator(
+        "type",
+        {
+            "Branch": GitRefBranchVariant,
+            "Tag": GitRefTagVariant,
+        },
+    ),
+]
+"""Which revision of the repository the file is read at.
+
+Serialized with a `type` discriminator (`{type: Branch, name}` /
+`{type: Tag, pattern}`). Its CRD schema is written by hand: the one schemars
+derives for a multi-variant tagged enum is a `oneOf` that kube cannot make
+structural.
+
+Told apart by `type`; a variant this SDK version does not know is an `UnknownVariant`."""

hyperfluid/models/git_ref_branch_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 GitRefBranchVariant(BaseModel):
+    """Follow the head of a branch."""
+
+    name: str
+
+    type: t.Literal["Branch"] = "Branch"

hyperfluid/models/git_ref_tag_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 GitRefTagVariant(BaseModel):
+    """Follow the highest tag matching a regex with a `version` named group."""
+
+    pattern: str
+
+    type: t.Literal["Tag"] = "Tag"

hyperfluid/models/git_repo_status.py

@@ -0,0 +1,35 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class GitRepoStatus(BaseModel):
+    """A workstation repository with the live state of its clone. This is what the
+    Source Control panel's repo switcher renders: one entry per repo, each with
+    enough state to show a badge without a round-trip per repo."""
+
+    branch: str
+    """Current branch. Empty when not cloned."""
+
+    cloned: bool
+    """False when the directory is not (yet) a git clone in the pod: the
+    workstation was just created, the clone failed, or the repo was added
+    while the pod was down."""
+
+    dir: str
+    """Clone directory under `/workspace` — the value to pass back as `repo`."""
+
+    dirty: bool
+    """Whether the working tree has uncommitted changes."""
+
+    is_primary: bool
+
+    url: str
+
+    id: UUID | None = None
+    """`null` for the primary repository, which cannot be removed."""

hyperfluid/models/github_connection_credential_dto.py

@@ -0,0 +1,36 @@
+# this file is @generated
+from __future__ import annotations
+
+import typing as t
+
+from ..serialization import Discriminator, UnknownVariant
+from .github_connection_credential_dto_github_app_variant import (
+    GithubConnectionCredentialDtoGithubAppVariant,
+)
+from .github_connection_credential_dto_pat_variant import (
+    GithubConnectionCredentialDtoPatVariant,
+)
+
+GithubConnectionCredentialDto: t.TypeAlias = t.Annotated[
+    GithubConnectionCredentialDtoPatVariant
+    | GithubConnectionCredentialDtoGithubAppVariant
+    | UnknownVariant,
+    Discriminator(
+        "kind",
+        {
+            "pat": GithubConnectionCredentialDtoPatVariant,
+            "github_app": GithubConnectionCredentialDtoGithubAppVariant,
+        },
+    ),
+]
+"""Credential payload for a new `GithubConnection`. Stored as an org-scoped
+user-secret in the platform secret store; never returned by any read
+endpoint.
+
+Deliberately **not** `Serialize` (nothing serializes an inbound credential —
+the stored document is built from the domain type) and its [`fmt::Debug`] is
+hand-written to redact the secret material: a derived `Debug` puts the raw
+PAT or App private key one `{:?}` — an axum rejection log, a `dbg!`, a
+`tracing` field — away from the log pipeline.
+
+Told apart by `kind`; a variant this SDK version does not know is an `UnknownVariant`."""

hyperfluid/models/github_connection_credential_dto_github_app_variant.py

@@ -0,0 +1,31 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class GithubConnectionCredentialDtoGithubAppVariant(BaseModel):
+    """GitHub App installation — org scope needs only
+    `Self-hosted runners: read & write` + `Metadata: read`."""
+
+    app_id: str
+    """App id (or client id) as shown on the App's settings page."""
+
+    kind: t.Literal["github_app"] = "github_app"
+
+    private_key: str
+    """PEM-encoded App private key."""
+
+    installation_id: str | None | Unset = UNSET
+    """**Optional.** The installation this connection is pinned to.
+
+    Left out, Hyperfluid asks GitHub (`GET /app/installations`, signed
+    with the key below) and fills it in — which is the whole point: the
+    installation id is otherwise a number the user has to dig out of
+    the tail of a `…/settings/installations/<id>` URL. It is only
+    required when the App is installed on more than one account, and
+    the 400 in that case names every candidate with its id."""

hyperfluid/models/github_connection_credential_dto_pat_variant.py

@@ -0,0 +1,19 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class GithubConnectionCredentialDtoPatVariant(BaseModel):
+    """Fine-grained or classic PAT. Escape hatch — GitHub App installs are
+    preferred (narrower permissions)."""
+
+    kind: t.Literal["pat"] = "pat"
+
+    token: str
+    """The token. Org-scoped pools need `manage_runners:org` (classic:
+    `admin:org`); repo-scoped pools need repo admin."""

hyperfluid/models/github_connection_response.py

@@ -0,0 +1,23 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from datetime import datetime
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class GithubConnectionResponse(BaseModel):
+    """Metadata for a stored `GithubConnection` (never includes the credential)."""
+
+    base_url: str
+    """GitHub base URL (`https://github.com` unless GHES)."""
+
+    created_at: datetime
+
+    kind: str
+    """`"pat"` or `"github_app"`."""
+
+    name: str
+    """Connection name (leaf, as used in `CreateGithubRunnerRequest.connection`)."""

hyperfluid/models/github_connection_target.py

@@ -0,0 +1,40 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .github_connection_target_kind import GithubConnectionTargetKind
+
+
+@dataclasses.dataclass(kw_only=True)
+class GithubConnectionTarget(BaseModel):
+    """One place a stored `GithubConnection` can register a runner pool, as GitHub
+    itself reports it.
+
+    This is what makes the pool-create form self-filling: `login` is the value
+    `scope` needs, and `installation_id` is the number the user used to copy out
+    of an installation settings URL by hand."""
+
+    can_manage_runners: bool
+    """Whether the credential really carries runner-management rights here.
+
+    For an App, derived from the installation's permissions
+    (`organization_self_hosted_runners: write`, or the broader
+    `administration: write`) — a `false` here is why a pool would otherwise
+    come up and then fail to register. For a PAT this is `true` by
+    assumption: GitHub does not report a token's scopes on these endpoints."""
+
+    kind: GithubConnectionTargetKind
+
+    login: str
+    """Organization or user login, e.g. `nudibranches-tech`. Validated against
+    the GitHub login character set before being echoed."""
+
+    installation_id: int | None = None
+    """The App installation id backing this target. Always set for a
+    `github_app` connection (and always the one the connection is pinned
+    to); always `null` for a `pat` connection, which has no installation."""

hyperfluid/models/github_connection_target_kind.py

@@ -0,0 +1,15 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class GithubConnectionTargetKind(StrEnum):
+    """Whether a discovered target is a GitHub organization or a user account."""
+
+    ORGANIZATION = "organization"
+    USER = "user"
+
+
+GithubConnectionTargetKindLiteral: t.TypeAlias = t.Literal["organization", "user"]
+"""The values of :class:`GithubConnectionTargetKind`, which arguments take as plain strings too."""

hyperfluid/models/github_runner_egress_mode_dto.py

@@ -0,0 +1,16 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class GithubRunnerEgressModeDto(StrEnum):
+    """How the pool's `CiliumNetworkPolicy` treats egress the built-in preset and
+    the allow-list do not cover."""
+
+    ALLOWLIST = "allowlist"
+    UNRESTRICTED = "unrestricted"
+
+
+GithubRunnerEgressModeDtoLiteral: t.TypeAlias = t.Literal["allowlist", "unrestricted"]
+"""The values of :class:`GithubRunnerEgressModeDto`, which arguments take as plain strings too."""

hyperfluid/models/github_runner_pool_egress_flows_response.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 .egress_flow_summary_dto import EgressFlowSummaryDto
+
+
+@dataclasses.dataclass(kw_only=True)
+class GithubRunnerPoolEgressFlowsResponse(BaseModel):
+    """Aggregated egress flows for one CI Farm runner pool, forwarded and blocked.
+
+    Scoped to the pool the same way the logs are — by the
+    `hyperfluid.io/github-runner` pod label — because runner pods are ephemeral
+    (ARC replaces them after every job) and every pool of a harbor shares one
+    namespace, so neither the pod name nor the namespace identifies a pool.
+
+    Best-effort by construction: Hubble Relay keeps a bounded in-memory ring
+    buffer, so this answers "what happened in the last few minutes", never "what
+    has this pool ever dialled". That is the right shape for the job it does —
+    a user reads it right after a workflow step failed, and the destination they
+    need is the one that was just blocked."""
+
+    flows: list[EgressFlowSummaryDto]
+
+    resource_id: str
+    """`"{harbor_id}/{pool_name}"` — see [`pool_resource_id`]."""
+
+    resource_type: str
+
+    window_secs: int
+    """Effective lookback window this response covers, in seconds."""

hyperfluid/models/github_runner_response.py

@@ -0,0 +1,69 @@
+# 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 .github_runner_egress_mode_dto import GithubRunnerEgressModeDto
+    from .github_runner_status_response import GithubRunnerStatusResponse
+    from .runner_flavor_dto import RunnerFlavorDto
+    from .runner_resources_dto import RunnerResourcesDto
+
+
+@dataclasses.dataclass(kw_only=True)
+class GithubRunnerResponse(BaseModel):
+    """Response DTO for a `GithubRunner` pool CR, including live status for
+    polling in the UI."""
+
+    connection: str
+    """Leaf name of the `GithubConnection` backing this pool."""
+
+    egress_mode: GithubRunnerEgressModeDto
+
+    flavor: RunnerFlavorDto
+
+    github_config_url: str
+    """GitHub config URL the scale set registers against
+    (`https://github.com/<org>` or `https://github.com/<owner>/<repo>`)."""
+
+    harbor_id: UUID
+
+    max_runners: int
+
+    min_runners: int
+
+    name: str
+    """CR `metadata.name`. The `runs-on:` target is
+    `status.runner_scale_set_name`, which the operator derives from this."""
+
+    organization_id: UUID
+
+    resources: RunnerResourcesDto
+
+    status: GithubRunnerStatusResponse
+
+    extra_egress_fqdns: list[str] | None = None
+    """Destinations allowed for this pool ON TOP of the mandatory GitHub
+    Actions / registry preset every runner gets — the user-editable half of
+    the pool's egress policy.
+
+    Returned so a client can APPEND to it. Without it the only safe edit is
+    to replace the whole list, which means the user has to retype every
+    entry to add one — and makes the "allow this blocked destination"
+    action on the pool's network tab impossible to write correctly.
+    `null` when the pool has no extras, which is how it is stored."""
+
+    runner_group: str | None = None
+
+    runner_image: str | None = None
+
+    runs_on: str | None = None
+    """The `runs-on:` name this pool was explicitly given, or `null` when it
+    uses the derived one. This is the *configured* value — what a form
+    should round-trip; the name actually registered with GitHub is
+    `status.runner_scale_set_name`, which is set either way and is what a
+    workflow must use."""

hyperfluid/models/github_runner_scope.py

@@ -0,0 +1,22 @@
+# this file is @generated
+from __future__ import annotations
+
+import typing as t
+
+from ..serialization import Discriminator, UnknownVariant
+from .github_runner_scope_org_variant import GithubRunnerScopeOrgVariant
+from .github_runner_scope_repo_variant import GithubRunnerScopeRepoVariant
+
+GithubRunnerScope: t.TypeAlias = t.Annotated[
+    GithubRunnerScopeOrgVariant | GithubRunnerScopeRepoVariant | UnknownVariant,
+    Discriminator(
+        "kind",
+        {
+            "org": GithubRunnerScopeOrgVariant,
+            "repo": GithubRunnerScopeRepoVariant,
+        },
+    ),
+]
+"""Where the runner scale set registers on GitHub.
+
+Told apart by `kind`; a variant this SDK version does not know is an `UnknownVariant`."""

hyperfluid/models/github_runner_scope_org_variant.py

@@ -0,0 +1,18 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class GithubRunnerScopeOrgVariant(BaseModel):
+    """Register at the GitHub organization level — the preferred scope (the
+    GitHub App needs only `Self-hosted runners: read & write`)."""
+
+    kind: t.Literal["org"] = "org"
+
+    login: str
+    """GitHub organization login (e.g. `nudibranches-tech`)."""

hyperfluid/models/github_runner_scope_repo_variant.py

@@ -0,0 +1,21 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class GithubRunnerScopeRepoVariant(BaseModel):
+    """Register on a single repository. Requires the far broader
+    `Administration: read & write` App permission."""
+
+    kind: t.Literal["repo"] = "repo"
+
+    name: str
+    """Repository name."""
+
+    owner: str
+    """Repository owner (user or organization login)."""

hyperfluid/models/github_runner_status_response.py

@@ -0,0 +1,43 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class GithubRunnerStatusResponse(BaseModel):
+    """Lifecycle status of the pool, derived from the CR `.status` subresource."""
+
+    current_runners: int
+    """Total live runner pods (idle + busy)."""
+
+    failed_runners: int
+    """Runners in a failed state."""
+
+    pending_runners: int
+    """Runners still starting up."""
+
+    running_runners: int
+    """Runners currently executing a job."""
+
+    message: str | None = None
+    """Human-readable status message (last error or transition reason)."""
+
+    phase: str | None = None
+    """`"Pending"`, `"Provisioning"`, `"Running"`, `"Failed"`; `null` before
+    the operator acts on the CR.
+
+    Also `"Terminating"` — not a CR phase, but derived from
+    `metadata.deletionTimestamp`: a deleted pool stays listable until the
+    operator's finalizer releases, and reporting the phase it had before the
+    delete would render it as a healthy pool."""
+
+    runner_scale_set_name: str | None = None
+    """The scale-set name this pool is registered under with GitHub — the
+    exact value a workflow must put in `runs-on:`. Either the pool's
+    `runs_on` or, when that is unset, the name the operator derives (it is
+    namespace-scoped, so two harbors of one org can both run a pool called
+    `ci`). Published by the operator, so it is `null` until it has
+    reconciled the CR."""

hyperfluid/models/gpu_availability_response.py

@@ -0,0 +1,39 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class GpuAvailabilityResponse(BaseModel):
+    """What the deploy surface needs to decide whether to offer the form at all,
+    and how big a GPU count it may offer (#3710)."""
+
+    budget: int
+    """Effective `max_gpus` for the org; `-1` = unlimited."""
+
+    budget_remaining: int
+    """`budget - held`, floored at 0; `-1` when unlimited."""
+
+    entitled: bool
+    """`model_serving_enabled` for this org (deployment flag AND entitlement).
+    `false` → the surface explains custom models are not enabled here."""
+
+    fleet_allocatable: int
+    """Allocatable GPUs across the whole fleet, cordoned nodes included."""
+
+    fleet_free: int
+    """Free GPUs on SCHEDULABLE cluster nodes."""
+
+    fleet_schedulable_allocatable: int
+    """Allocatable GPUs on schedulable nodes — the denominator behind
+    "0 of 4 available"."""
+
+    held: int
+    """GPUs the org currently holds across every workload kind."""
+
+    max_grantable: int
+    """The largest GPU count that could be satisfied right now:
+    `min(budget_remaining, fleet_free)`. The dialog must never offer more."""

hyperfluid/models/gpu_consumer_view.py

@@ -0,0 +1,34 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class GpuConsumerView(BaseModel):
+    """A GPU consumer on a node. Attribution (workload name, namespace, org) is
+    present only when the caller may see it; otherwise `redacted` is `true` and
+    the identifying fields are `null` — the UI renders "in use by another
+    tenant". The `gpu_count` is always present so allocation totals balance."""
+
+    gpu_count: int
+    """GPUs this consumer holds on the node."""
+
+    redacted: bool
+    """`true` when this consumer belongs to another tenant and its attribution
+    has been redacted."""
+
+    namespace: str | None = None
+    """Consumer namespace — `null` when redacted."""
+
+    organization_id: str | None = None
+    """Owning organization id — `null` when redacted."""
+
+    owner_kind: str | None = None
+    """Owner kind (InferenceService | ModelServing | DevWorkstation |
+    Deployment | Pod) — `null` when redacted."""
+
+    owner_name: str | None = None
+    """Owner workload name — `null` when redacted."""