hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/models/container_app_crd_spec_response.py

@@ -0,0 +1,168 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .autoscaling_spec import AutoscalingSpec
+    from .bucket_ref_spec_response import BucketRefSpecResponse
+    from .container_app_metrics import ContainerAppMetrics
+    from .container_app_port_response import ContainerAppPortResponse
+    from .custom_domain_response import CustomDomainResponse
+    from .env_var_spec_response import EnvVarSpecResponse
+    from .file_mount_response import FileMountResponse
+    from .image_source import ImageSource
+    from .image_source_status import ImageSourceStatus
+    from .init_container_response import InitContainerResponse
+    from .persistence_response import PersistenceResponse
+    from .resource_mode import ResourceMode
+    from .resource_tier import ResourceTier
+    from .rightsizing_suggestion_response import RightsizingSuggestionResponse
+    from .secret_ref_spec_response import SecretRefSpecResponse
+
+
+@dataclasses.dataclass(kw_only=True)
+class ContainerAppCrdSpecResponse(BaseModel):
+    """The `ContainerAppCrdSpecResponse` object."""
+
+    bucket_refs: list[BucketRefSpecResponse]
+
+    custom_domains: list[CustomDomainResponse]
+
+    enabled: bool
+
+    env: list[EnvVarSpecResponse]
+
+    expose_to_internet: bool
+    """Whether internet-facing routes are enabled for this app. Reflects the live CRD
+    value so the edit dialog can prefill the current state."""
+
+    file_mounts: list[FileMountResponse]
+
+    image_pull_secrets: list[str]
+
+    image_repository: str
+
+    image_tag: str
+
+    persistence: list[PersistenceResponse]
+
+    ports: list[ContainerAppPortResponse]
+    """Every port the app publishes, with the deprecated single-`port` form
+    already folded in — an app that has never been edited since `ports`
+    landed still reports one entry here."""
+
+    replicas: int
+
+    resource_mode: ResourceMode
+
+    resource_version: str
+    """Opaque concurrency token for this object's **spec**, to be round-tripped
+    verbatim as `resource_version` in PATCH requests; the server returns 409
+    Conflict when someone else has edited the spec in the meantime.
+
+    It carries `metadata.generation`, not `metadata.resourceVersion`, and
+    the difference is the whole point: the operator writes `.status` on
+    every reconcile, which bumps `resourceVersion` without touching the
+    spec. Keying the check on `resourceVersion` meant a busy app — a
+    crashlooping one reconciles every few seconds — invalidated the token
+    between the read and the user pressing Save, so the edit was rejected
+    as a conflict with a change that had never happened. `generation`
+    advances only when `.spec` does, which is exactly the thing two editors
+    can race on. The field name is kept for wire compatibility; treat the
+    value as opaque."""
+
+    secret_refs: list[SecretRefSpecResponse]
+
+    tag_is_floating: bool
+    """Whether `image_tag` is a floating tag (`latest`, or a bare major or
+    major.minor tag like `15`/`15.0`) that the upstream image can re-push
+    under the same name. A tag like that never really pins a build: later
+    patches, security fixes included, can land under it silently.
+    Computed on the server, so clients never need their own copy of this
+    check."""
+
+    alert_on_sync_failure: bool | None = None
+    """With `image_source`: whether the default "Git sync failed" alert rule
+    is wanted."""
+
+    args: list[str] | None = None
+    """Main container arguments override. Empty = the image's CMD."""
+
+    autoscaling: AutoscalingSpec | None = None
+
+    bonus_cpu_millis: int | None = None
+    """The free burst above the sold envelope, in millicores
+    (`cpu_limit millis - entitlement_cpu_millis`), read directly off the live
+    `cpu_limit`/entitlement — not re-derived from `CaasTierConfig` ratios, which
+    would be undefined for a `resource_tier: null` app. `None` when the spec
+    renders no explicit CPU limit (nothing to compute a ceiling from) or failed
+    to parse."""
+
+    command: list[str] | None = None
+    """Main container entrypoint override. Empty = the image's ENTRYPOINT."""
+
+    cpu_limit: str | None = None
+
+    cpu_request: str | None = None
+
+    entitlement_cpu_millis: int | None = None
+    """What this app's live CRD spec sells, in millicores — `resources.entitlement.cpu`
+    via `footprint_from_spec` (ADR-0012 `× replicas`), with the same pre-#3628
+    fallback to `resources.requests.cpu` `footprint_from_spec` applies. Populated
+    even when `resource_tier` is `None` (a legacy CRD or a custom entitlement that
+    doesn't match any tier on the table exactly) — self-sufficient for the detail
+    screen so it never has to invent a sold number from the catalog (#3631).
+    `None` only when the live spec itself failed to parse."""
+
+    health_check_path: str | None = None
+
+    health_check_port: int | None = None
+
+    image_digest: str | None = None
+    """Digest the main image is pinned to, when there is one."""
+
+    image_source: ImageSource | None = None
+
+    image_source_status: ImageSourceStatus | None = None
+
+    init_containers: list[InitContainerResponse] | None = None
+    """Init containers, run to completion (in order) before the main
+    container starts. Defaults to empty so a newer hfctl (or any other
+    generated client) talking to a server that predates this field does
+    not fail to deserialize the response."""
+
+    memory_limit: str | None = None
+
+    memory_limit_bytes: int | None = None
+    """`memory_limit` as exact bytes — the ceiling a replica is killed at.
+    Equal to `memory_request_bytes` for every tier (RAM gets no burst
+    headroom: it is incompressible, so headroom above the reservation
+    would only make the pod evictable under pressure); reported separately
+    so a spec where the two do differ is shown as it is. `None` when the
+    spec declares no memory limit or the quantity failed to parse."""
+
+    memory_request: str | None = None
+
+    memory_request_bytes: int | None = None
+    """`memory_request` as exact bytes — what this replica is guaranteed, and
+    (under the tier model, where memory `limit == request`) what was sold.
+    Same rationale as `entitlement_cpu_millis`: the detail screen draws
+    live working-set bytes against this figure, so it is handed over in
+    the metric's own unit instead of as a `"256Mi"` string the frontend
+    would have to parse. `None` when the spec declares no memory request
+    or the quantity failed to parse."""
+
+    metrics: ContainerAppMetrics | None = None
+
+    port: int | None = None
+    """**Deprecated — read `ports`.** The primary port, or the raw
+    `network.port` for an app that predates `ports`. `null` once neither
+    exists — a raw TCP/UDP app has no port to single out."""
+
+    resource_tier: ResourceTier | None = None
+
+    rightsizing: RightsizingSuggestionResponse | None = None

hyperfluid/models/container_app_image_synced_log.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 ContainerAppImageSyncedLog(BaseModel):
+    """Audit payload for an image a Git source rolled out. Written by the console
+    when it resolves the change, so the actor is the platform (`oauth_id` nil);
+    the person behind it is the commit author, as the provider reports it."""
+
+    container_app_id: UUID
+
+    image: str
+
+    repository: str
+    """`<provider>:<repository>`."""
+
+    resource_id: str
+    """`<harbor_slug>/<app_slug>`, named `resource_id` so the audit-log API's
+    `event->'data'->>'resource_id'` filter reaches this event."""
+
+    revision: str
+
+    commit_author: str | None = None
+
+    git_ref: str | None = None
+    """Branch, or the tag the pattern selected."""
+
+    previous_image: str | None = None
+    """Image reference that ran before, `None` for the first sync."""

hyperfluid/models/container_app_metrics.py

@@ -0,0 +1,22 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class ContainerAppMetrics(BaseModel):
+    """Where a `ContainerApp` serves its Prometheus metrics."""
+
+    port: str
+    """Name of the `network.ports` entry serving the metrics endpoint
+    (e.g. `metrics`). Must be a declared port; the operator resolves it to
+    the container port number."""
+
+    path: str | None | Unset = UNSET
+    """HTTP path of the metrics endpoint. Absent means `/metrics`; the default
+    is resolved by the operator at reconcile time and never written into the
+    spec, so it can change without leaving existing apps frozen on the old
+    value. Must start with `/` and contain no whitespace."""

hyperfluid/models/container_app_platform_url_response.py

@@ -0,0 +1,24 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class ContainerAppPlatformUrlResponse(BaseModel):
+    """Where the platform serves an app of a given name in a given harbor."""
+
+    host: str
+    """The `spec.network.host` label the app would be created with."""
+
+    fqdn: str | None = None
+    """The hostname under the platform apps base domain. `None` when the
+    platform has not published its apps base domain to the console: the app
+    still gets a platform route, but its name is only known once the
+    operator reports it in `status.endpoint`."""
+
+    url: str | None = None
+    """`https://<fqdn>` — the URL the app answers on with no custom domain.
+    `None` iff `fqdn` is."""

hyperfluid/models/container_app_pod_info.py

@@ -0,0 +1,60 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class ContainerAppPodInfo(BaseModel):
+    """The `ContainerAppPodInfo` object."""
+
+    containers: list[str]
+    """Every container this pod actually has, app container first then init
+    containers in declared order (`pod_container_names`). The log-picker
+    UI builds its options from here, not from the CRD's current spec, so
+    an older or newer pod mid-rollout only ever offers containers it
+    really has."""
+
+    image: str
+    """The main container's image reference as Kubernetes resolved it. May
+    still be a tag rather than a digest. Empty until the container has
+    reported a status."""
+
+    name: str
+
+    phase: str
+
+    ready: bool
+
+    restarts: int
+
+    blocking_container: str | None = None
+    """Name of the container `status_reason`/`status_message` describe, when
+    it names an init container specifically (e.g. `Init:0/1` surfaces as
+    "blocked on init container `bootstrap-oidc`" rather than a bare
+    phase). `None` when the app has no init containers, every init
+    container has already completed, or the pod is ready."""
+
+    image_id: str | None = None
+    """The digest this pod is actually running (`sha256:...`), read from the
+    main container's live status. Absent while the container is still
+    being created or pulled, or if the reported value carries no digest
+    at all."""
+
+    started_at: str | None = None
+
+    starting: bool | None = None
+    """True = still starting up (no readiness verdict yet, e.g.
+    ContainerCreating / PodInitializing); False = container running but
+    probe actively failing / unready; None when `ready == true`."""
+
+    status_message: str | None = None
+    """Longer human-readable explanation (waiting.message / prior-termination
+    detail / Ready-condition message). None when `ready == true`."""
+
+    status_reason: str | None = None
+    """Short, machine-ish reason a non-ready instance is unhealthy, e.g.
+    "ContainerCreating", "CrashLoopBackOff", "ImagePullBackOff",
+    "ContainersNotReady". None when `ready == true`."""

hyperfluid/models/container_app_port_input.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
+
+if t.TYPE_CHECKING:
+    from .app_protocol import AppProtocol
+    from .port_protocol import PortProtocol
+
+
+@dataclasses.dataclass(kw_only=True)
+class ContainerAppPortInput(BaseModel):
+    """One port the container listens on."""
+
+    container_port: int
+    """Port the container listens on."""
+
+    name: str
+    """Name of the port, unique within the app, e.g. `http` or `metrics`.
+    DNS-1123 label, at most 15 characters (a Kubernetes `ServicePort.name`)."""
+
+    app_protocol: AppProtocol | None | Unset = UNSET
+
+    primary: bool | None = None
+    """Marks the port that public routes and the default health probe target.
+    Optional when the app declares a single port with an `app_protocol`."""
+
+    protocol: PortProtocol | None = None

hyperfluid/models/container_app_port_response.py

@@ -0,0 +1,29 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .app_protocol import AppProtocol
+    from .port_protocol import PortProtocol
+
+
+@dataclasses.dataclass(kw_only=True)
+class ContainerAppPortResponse(BaseModel):
+    """One port the container listens on, as returned to the UI."""
+
+    container_port: int
+
+    primary: bool
+    """Whether public routes and the default health probe target this port."""
+
+    protocol: PortProtocol
+
+    app_protocol: AppProtocol | None = None
+
+    name: str | None = None
+    """`null` for an app still on the deprecated single-`port` form, which
+    carries no name to report."""

hyperfluid/models/container_app_response.py

@@ -0,0 +1,72 @@
+# 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 .resource_origin import ResourceOrigin
+
+
+@dataclasses.dataclass(kw_only=True)
+class ContainerAppResponse(BaseModel):
+    """The `ContainerAppResponse` object."""
+
+    available_replicas: int
+
+    created_at: datetime
+
+    desired_replicas: int
+
+    harbor_id: UUID
+
+    id: UUID
+
+    name: str
+
+    organization_id: UUID
+
+    ram_mib: int
+
+    replicas: int
+
+    slug: str
+
+    storage_gib: int
+
+    tags: list[str]
+
+    updated_at: datetime
+
+    updated_ready_replicas: int
+
+    updated_replicas: int
+
+    vcpu_millis: int
+
+    conditions: t.Any = None
+
+    description: str | None = None
+
+    endpoint: str | None = None
+
+    endpoints: list[str] | None = None
+    """Every public URL this app answers on: the platform endpoint when it is still
+    advertised, plus each custom domain that is serving. Empty when the app has no
+    public route. Populated on list/get; the `From` impl leaves it empty because the
+    DB row alone does not know about custom domains."""
+
+    image: str | None = None
+    """The image reference the app runs, from its CRD: `spec.image`, or the
+    image its Git source resolved. Populated on list only. Absent when the
+    CRD could not be read, when a Git source has resolved nothing yet, and
+    for a freshly created app until the operator has written its console id
+    back to the CRD status (that id is what the CRD is matched on)."""
+
+    phase: str | None = None
+
+    source: ResourceOrigin | None = None

hyperfluid/models/container_app_usage_dto.py

@@ -0,0 +1,44 @@
+# 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 .instance_usage_dto import InstanceUsageDto
+    from .metric_point_dto import MetricPointDto
+
+
+@dataclasses.dataclass(kw_only=True)
+class ContainerAppUsageDto(BaseModel):
+    """The `ContainerAppUsageDto` object."""
+
+    app_id: UUID
+
+    cpu_allocation_millicores: int
+    """The vCPU sold per instance, in millicores: what a CPU percentage is
+    read against. The instance may burst a little above it."""
+
+    cpu_millicores: list[MetricPointDto]
+    """CPU in use, in millicores, summed over the app's instances. Every
+    container of an instance counts, sidecars included, as on the app's
+    own metrics panels."""
+
+    instances: list[InstanceUsageDto]
+    """Instances running at the end of the range, with their latest figures."""
+
+    memory_limit_mib: int
+    """The memory limit of each instance, in MiB. An instance that reaches it
+    is killed and restarted."""
+
+    memory_mib: list[MetricPointDto]
+    """Memory working set, in MiB, summed over the app's instances (every
+    container, sidecars included). Read against `memory_limit_mib`, the
+    app container's own limit, it slightly overstates how close the app
+    is to being killed when it runs a sidecar."""
+
+    restarts: int
+    """Container restarts over the range, replaced instances included."""

hyperfluid/models/container_app_volume_usage_dto.py

@@ -0,0 +1,38 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class ContainerAppVolumeUsageDto(BaseModel):
+    """One persistent volume of a container app with its current fill."""
+
+    claim_name: str
+    """The `PersistentVolumeClaim` backing it (`<app>-<name>`)."""
+
+    mount_path: str
+    """Absolute mount path inside the container."""
+
+    name: str
+    """`spec.persistence[*].name` — the volume's logical name within the app."""
+
+    size: str
+    """Requested size, the K8s quantity the app was created with (e.g. `10Gi`)."""
+
+    capacity_bytes: int | None = None
+    """The filesystem's capacity in bytes — a little under `size`, the
+    filesystem keeps its own overhead. `null` without a recent sample."""
+
+    storage_class: str | None = None
+    """StorageClass the claim was provisioned from; `null` when the cluster
+    default applies."""
+
+    usage_percent: float | None = None
+    """`used / capacity` in percent; `null` when either side is unknown."""
+
+    used_bytes: int | None = None
+    """Bytes in use on the volume's filesystem. `null` without a recent
+    sample — the kubelet only reports a volume while a pod has it mounted."""

hyperfluid/models/container_app_volumes_response.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 .container_app_volume_usage_dto import ContainerAppVolumeUsageDto
+
+
+@dataclasses.dataclass(kw_only=True)
+class ContainerAppVolumesResponse(BaseModel):
+    """The persistent volumes of a container app, one entry per
+    `spec.persistence` entry in spec order — an app without persistence gets
+    an empty list, not an error."""
+
+    resource_id: str
+
+    volumes: list[ContainerAppVolumeUsageDto]

hyperfluid/models/container_apps_usage_response.py

@@ -0,0 +1,26 @@
+# 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 .container_app_usage_dto import ContainerAppUsageDto
+
+
+@dataclasses.dataclass(kw_only=True)
+class ContainerAppsUsageResponse(BaseModel):
+    """Usage of every container app of an environment over a range."""
+
+    apps: list[ContainerAppUsageDto]
+    """One entry per app of the environment, in the order of the app list.
+    An app with no sample in the range (stopped, never started, or
+    metrics not collected yet) is present with empty series."""
+
+    harbor_id: UUID
+
+    range: str
+    """Wire form of the range (`"24h"`, …)."""

hyperfluid/models/container_row.py

@@ -0,0 +1,44 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class ContainerRow(BaseModel):
+    """A single scanned container in a `WorkloadDetail`."""
+
+    container: str
+
+    image_ref: str
+
+    init_container: bool
+
+    internal: bool
+    """Platform machinery rather than the organization's own container.
+    Always `false` in an organization-facing response (those rows are
+    filtered out, see [`Audience`]); the cockpit renders it as a badge."""
+
+    pod: str
+
+    pod_phase: str
+
+    ready: bool
+
+    restart_count: int
+
+    image_digest: str | None = None
+
+    last_termination_exit_code: int | None = None
+
+    last_termination_reason: str | None = None
+
+    node: str | None = None
+
+    pod_reason: str | None = None
+
+    runtime_class: str | None = None
+
+    waiting_reason: str | None = None

hyperfluid/models/context_provider_response.py

@@ -0,0 +1,37 @@
+# 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 ContextProviderResponse(BaseModel):
+    """Response for a context provider."""
+
+    created_at: datetime
+
+    enabled: bool
+
+    id: UUID
+
+    name: str
+
+    organization_id: UUID
+
+    provider_type: str
+
+    sync_interval_seconds: int
+
+    updated_at: datetime
+
+    last_sync_at: datetime | None = None
+
+    last_sync_error: str | None = None
+
+    last_sync_status: str | None = None
+
+    last_sync_user_count: int | None = None