hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/models/gpu_fleet_summary.py

@@ -0,0 +1,31 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class GpuFleetSummary(BaseModel):
+    """Fleet-wide GPU aggregates — always visible to any authenticated org member
+    (shared physical infra, ADR-0023 §5)."""
+
+    allocated: int
+    """GPUs currently claimed by scheduled workloads (Σ per-node `allocated`)."""
+
+    free: int
+    """GPUs free right now (Σ per-node `free`)."""
+
+    node_count: int
+    """Number of GPU nodes in the fleet."""
+
+    product_models: list[str]
+    """Distinct GPU product models present (e.g. "AMD_Radeon_AI_PRO_R9700"),
+    sorted, deduplicated."""
+
+    schedulable_count: int
+    """Number of nodes currently schedulable (Ready & not cordoned/tainted)."""
+
+    total: int
+    """Total schedulable GPUs across the fleet (Σ per-node `allocatable`)."""

hyperfluid/models/gpu_node_view.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 .gpu_consumer_view import GpuConsumerView
+
+
+@dataclasses.dataclass(kw_only=True)
+class GpuNodeView(BaseModel):
+    """One GPU node's inventory + allocation, projected from `GpuNode.status`."""
+
+    allocatable: int
+    """Allocatable GPUs (`Node.status.allocatable[key]`)."""
+
+    allocated: int
+    """GPUs claimed by scheduled workloads on this node."""
+
+    capacity: int
+    """Total GPUs on the node (`Node.status.capacity[key]`)."""
+
+    consumers: list[GpuConsumerView]
+    """Workloads consuming GPUs on this node, tenancy-redacted (see
+    [`GpuConsumerView`])."""
+
+    free: int
+    """Free GPUs (`allocatable − allocated`)."""
+
+    gpu_resource_key: str
+    """GPU extended-resource key, e.g. "amd.com/gpu"."""
+
+    node_name: str
+    """Node name (== `GpuNode` CR name)."""
+
+    schedulable: bool
+    """Node Ready & not cordoned / NoSchedule-tainted."""
+
+    taints: list[str]
+    """Node taints, e.g. ["chimera-hdi=true:NoSchedule"]."""
+
+    last_observed: str | None = None
+    """When the operator last observed this node (RFC3339)."""
+
+    product_name: str | None = None
+    """GPU product model (from the `*.product-name` label)."""
+
+    vendor: str | None = None
+    """Vendor: "amd" | "nvidia"."""
+
+    vram_per_device: str | None = None
+    """Per-device VRAM (from the `*.vram` label)."""

hyperfluid/models/gpu_resources_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 .gpu_fleet_summary import GpuFleetSummary
+    from .gpu_node_view import GpuNodeView
+
+
+@dataclasses.dataclass(kw_only=True)
+class GpuResourcesResponse(BaseModel):
+    """Cluster GPU inventory + allocation for the AI Gateway Resources tab."""
+
+    nodes: list[GpuNodeView]
+    """Per-node inventory + allocation, one entry per `GpuNode` CR."""
+
+    summary: GpuFleetSummary

hyperfluid/models/grant.py

@@ -0,0 +1,47 @@
+# 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 Grant(BaseModel):
+    """A persisted authorization grant. Exactly one of `role_id` / `permission_id`
+    is set (role-bundle grant vs fine-grained grant). The resource *type* is not
+    stored: it is derived from each permission's family at projection time, so a
+    grant can't drift from the permission it gates."""
+
+    effect: str
+    """`"allow"` | `"deny"`."""
+
+    id: UUID
+
+    organization_id: UUID
+
+    principal_id: UUID
+
+    principal_type: str
+    """`"user"` | `"service_account"`."""
+
+    condition: t.Any = None
+    """Optional principal-attribute condition (JSONB), echoed verbatim."""
+
+    permission_id: UUID | None = None
+
+    resource_uuid: UUID | None = None
+    """Two-tier key. `Some` = ATTACHED tier: bound to one concrete resource by
+    its immutable DB id, so it survives a slug rename and is cascade-GC'd by
+    exact uuid match on that resource's delete (and `scope_path` is that
+    resource's exact path, never a wildcard). `None` = PATTERN tier: keyed
+    only by `scope_path`. Never enters the OPA projection — GC/identity only."""
+
+    role_id: UUID | None = None
+
+    scope_path: str | None = None
+    """A path in the org's resource tree the grant is scoped to: exact, an
+    ancestor folder (matches descendants), or a `*`-suffixed wildcard. `None`
+    = org-wide. The enforcement key the OPA projection composes into an HRN."""

hyperfluid/models/group.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 Group(BaseModel):
+    """A named, org-scoped collection of principals. Binding an access level to a
+    group (a [`Grant`] with `principal_type = "group"` and `principal_id` = this
+    id) applies that access to every member, resolved through the OPA projection."""
+
+    id: UUID
+
+    member_count: int
+    """Number of principals (users + service accounts) in the group. Computed by
+    every group-returning query via a correlated count, so it is always
+    populated — a query that omits it fails loudly in `FromRow` rather than
+    silently reporting 0."""
+
+    name: str
+
+    organization_id: UUID
+
+    description: str | None = None

hyperfluid/models/group_member.py

@@ -0,0 +1,23 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class GroupMember(BaseModel):
+    """One member of a [`Group`]: a polymorphic principal (a user or a service
+    account), keyed the same way `grants` keys a principal. Carries the
+    principal's human-readable name so the management UI can list members without
+    an N+1 lookup."""
+
+    principal_id: UUID
+
+    principal_name: str
+    """A user's email or a service account's name (falls back to the id)."""
+
+    principal_type: str
+    """`"user"` | `"service_account"`."""

hyperfluid/models/harbor.py

@@ -0,0 +1,30 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class Harbor(BaseModel):
+    """A harbor is a collection of [DataDocks](super::datadock::Datadock)
+    Each harbor belongs to an [Org](super::org::Org)
+    Each harbor has an owner who is a [User](super::user::User)"""
+
+    id: UUID
+
+    name: str
+
+    namespace: str
+    """The Kubernetes namespace the harbor's workloads are placed in
+    (`hf-{org}-{harbor}`, hash-truncated to 63 chars). The console derives
+    it once when it inserts the row and stores it in `harbors.namespace`;
+    every reader uses the stored value."""
+
+    organization_id: UUID
+
+    slug: str
+
+    owner_id: UUID | None = None

hyperfluid/models/harbor_network_isolation_response.py

@@ -0,0 +1,17 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .network_isolation_view import NetworkIsolationView
+
+
+@dataclasses.dataclass(kw_only=True)
+class HarborNetworkIsolationResponse(BaseModel):
+    """The `HarborNetworkIsolationResponse` object."""
+
+    network_isolation: NetworkIsolationView

hyperfluid/models/harbor_posture.py

@@ -0,0 +1,34 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class HarborPosture(BaseModel):
+    """Per-harbor posture rollup within one [`OrganizationWorkloadView`] — the
+    SAME field shape as [`OrgPosture`]'s scan-derived counts, scoped one level
+    narrower (harbor instead of org/platform/unattributed)."""
+
+    critical: int
+
+    exposed_with_critical: int
+
+    fixable: int
+
+    harbor_id: UUID
+
+    high: int
+
+    images: int
+
+    no_policy: int
+
+    stale_scans: int
+
+    workloads: int
+
+    harbor_slug: str | None = None

hyperfluid/models/harbor_ref.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 HarborRef(BaseModel):
+    """Reference to the harbor (environment/project) this link belongs to."""
+
+    name: str
+    """Name of the harbor."""
+
+    namespace: str | None = None
+    """Namespace of the referenced Harbor CR, the organization control plane
+    `hf-{org}`. The console always sets it; the operator refuses to reconcile
+    a CR without it."""

hyperfluid/models/harbor_storage_binding_view.py

@@ -0,0 +1,54 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+from datetime import datetime
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .condition_view import ConditionView
+
+
+@dataclasses.dataclass(kw_only=True)
+class HarborStorageBindingView(BaseModel):
+    """The `HarborStorageBindingView` object."""
+
+    harbor_slug: str
+
+    name: str
+
+    namespace: str
+
+    owner_user_ensured: bool
+
+    quota_gb: int
+
+    ready: bool
+
+    tenant: str
+
+    tenant_ensured: bool
+
+    zone_id: str
+    """Storage zone this tenant lives in (`"default"` for the primary)."""
+
+    conditions: list[ConditionView] | None = None
+    """Full set of `.status.conditions` from the HarborStorageBinding CRD,
+    surfaced to the UI so operators can see per-subsystem state
+    (OrgStorageReady, TenantEnsured, OwnerUserEnsured, StsRoleReady,
+    OwnerIamCapsRevoked)."""
+
+    last_message: str | None = None
+
+    last_transition_time: datetime | None = None
+
+    owner_credentials_secret_ref: str | None = None
+
+    rgw_user: str | None = None
+
+    sts_role_arn: str | None = None
+    """ARN of the per-Harbor STS IAM role registered in RGW. The console
+    uses this to call `AssumeRoleWithWebIdentity` on behalf of users;
+    surfacing it makes "is STS ready?" trivially diagnosable from the UI."""

hyperfluid/models/health_thresholds.py

@@ -0,0 +1,23 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class HealthThresholds(BaseModel):
+    """What "too small", "too many deletes" and "too much history" currently mean
+    for this catalog."""
+
+    from_schedule: bool
+    """True when these came from the catalog's own maintenance schedule rather
+    than from the defaults."""
+
+    small_file_threshold_bytes: int
+    """Derived from the schedule's `compact_files.file_size_threshold`, or the
+    platform default when no schedule exists."""
+
+    snapshot_retention_days: float
+    """Derived from `expire_snapshots.retention_threshold`, in days."""

hyperfluid/models/hf_bucket_detail.py

@@ -0,0 +1,110 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .resource_origin import ResourceOrigin
+
+
+@dataclasses.dataclass(kw_only=True)
+class HfBucketDetail(BaseModel):
+    """The `HFBucketDetail` object."""
+
+    created_at: str
+
+    freeze_writes: bool
+    """True when writes are administratively frozen on this bucket."""
+
+    harbor_name: str
+
+    name: str
+
+    quota_is_default: bool
+    """True when `quota_gb` reflects the org-wide default rather than an
+    explicit per-bucket override (the bucket has no `spec.quotaGb` and
+    inherits `OrgStorage.defaultPerBucketQuotaGb`). Lets the UI show the
+    inherited value without pinning it as an override on save."""
+
+    ready: bool
+
+    region: str
+    """S3-protocol region clients must sign with. This is the RGW zonegroup
+    `api_name` the backend signs SigV4 against (`"default"`), **not** a
+    physical location — surfaced so SDKs can be configured correctly."""
+
+    s3_gateway_enabled: bool
+    """True when this bucket's zone runs an S3 gateway, i.e. when a session
+    could actually be minted for it. Resolved with the SAME predicate the
+    session endpoint enforces, so the console cannot offer a credential the
+    server would refuse — nor hide one it would grant."""
+
+    zone_id: str
+    """Storage zone the bucket lives in (`"default"` for the primary)."""
+
+    bucket_name: str | None = None
+    """Tenant-prefixed bucket name materialized by the operator on RGW
+    (i.e. `.status.bucket_name`). Equals `name` for non-prefixed
+    deployments; surfaced separately so the UI can show what the
+    underlying object store actually sees. `None` while the operator
+    has not yet stamped the status field."""
+
+    deleting: bool | None = None
+    """True once the bucket is being deleted (the HFBucket has a
+    `deletionTimestamp`) and the operator's finalizer has not let it go
+    yet: whatever `ready` says, the bucket is on its way out."""
+
+    endpoint: str | None = None
+    """External HTTPS S3 endpoint URL clients use to reach this bucket."""
+
+    object_count: int | None = None
+    """Object count from the same reading. `None` likewise."""
+
+    quota_gb: int | None = None
+    """Effective per-bucket quota in GB actually enforced on RGW: an explicit
+    `spec.quotaGb` override if set, otherwise the org-wide default. `None`
+    means no quota is enforced (genuinely unlimited)."""
+
+    read_only: bool | None = None
+    """True when the bucket's grant on its backend is gone (ADR-0048 D4, the
+    HFBucket's `GrantRevoked` condition): the bucket is kept and readable,
+    but writes are refused and nothing new is created on it."""
+
+    read_only_reason: str | None = None
+    """Why the bucket is read-only: the `GrantRevoked` condition's message,
+    in the operator's words (it names CRD fields). Secondary detail: a
+    tenant-facing UI words `read_only_reason_code` instead."""
+
+    read_only_reason_code: str | None = None
+    """The `GrantRevoked` condition's reason, a stable code for why the
+    bucket is read-only: `NoGrant`, `HarborNotGranted`, `DuplicateGrant`,
+    `BackendNotFound`, `PlatformBackend`, `SharedIsolationNotAccepted`
+    (the operator's `GrantRefusal` reasons), or `GrantRevoked` when it
+    gave none."""
+
+    ready_reason: str | None = None
+    """The `Ready` condition's reason (`BucketProvisioned`, `NotGranted`,
+    `Conflict`, `BackendNotReady`, ...), so a caller can tell a refused
+    bucket from one still provisioning."""
+
+    size_bytes: int | None = None
+    """Bytes the bucket holds on its backend, unfinished multipart uploads
+    and noncurrent versions included, as the platform's usage sweep last
+    read it (every 15 minutes). `None` until the bucket has a reading less
+    than an hour old."""
+
+    source: ResourceOrigin | None = None
+
+    status_message: str | None = None
+
+    zone_name: str | None = None
+    """The zone's display name, from the backend catalogue — present even
+    while the zone is not granted (and so absent from the zone list).
+    `None` when no backend serves the zone any more."""
+
+    zone_tier: str | None = None
+    """The zone backend's free-form tier label (`spec.tier`), from the same
+    catalogue; `None` when it has none or no backend serves the zone."""

hyperfluid/models/hf_bucket_view.py

@@ -0,0 +1,70 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .resource_origin import ResourceOrigin
+
+
+@dataclasses.dataclass(kw_only=True)
+class HfBucketView(BaseModel):
+    """The `HFBucketView` object."""
+
+    harbor_name: str
+
+    name: str
+
+    namespace: str
+
+    ready: bool
+    """True when the operator has marked the bucket as Ready in `.status`."""
+
+    zone_id: str
+    """Storage zone the bucket lives in (`"default"` for the primary)."""
+
+    created_at: str | None = None
+    """RFC 3339 timestamp of when the HFBucket CR was created in the cluster."""
+
+    deleting: bool | None = None
+    """True once the bucket is being deleted (the HFBucket has a
+    `deletionTimestamp`) and the operator's finalizer has not let it go
+    yet: whatever `ready` says, the bucket is on its way out."""
+
+    read_only: bool | None = None
+    """True when the bucket's grant on its backend is gone (ADR-0048 D4, the
+    HFBucket's `GrantRevoked` condition): the bucket is kept and readable,
+    but writes are refused and nothing new is created on it."""
+
+    read_only_reason: str | None = None
+    """Why the bucket is read-only: the `GrantRevoked` condition's message,
+    in the operator's words (it names CRD fields). Secondary detail: a
+    tenant-facing UI words `read_only_reason_code` instead."""
+
+    read_only_reason_code: str | None = None
+    """The `GrantRevoked` condition's reason, a stable code for why the
+    bucket is read-only: `NoGrant`, `HarborNotGranted`, `DuplicateGrant`,
+    `BackendNotFound`, `PlatformBackend`, `SharedIsolationNotAccepted`
+    (the operator's `GrantRefusal` reasons), or `GrantRevoked` when it
+    gave none."""
+
+    ready_reason: str | None = None
+    """The `Ready` condition's reason (`BucketProvisioned`, `NotGranted`,
+    `Conflict`, `BackendNotReady`, ...), so a caller can tell a refused
+    bucket from one still provisioning."""
+
+    source: ResourceOrigin | None = None
+
+    status_message: str | None = None
+
+    zone_name: str | None = None
+    """The zone's display name, from the backend catalogue — present even
+    while the zone is not granted (and so absent from the zone list).
+    `None` when no backend serves the zone any more."""
+
+    zone_tier: str | None = None
+    """The zone backend's free-form tier label (`spec.tier`), from the same
+    catalogue; `None` when it has none or no backend serves the zone."""

hyperfluid/models/hf_collumn.py

@@ -0,0 +1,19 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .hf_data_type import HfDataType
+
+
+@dataclasses.dataclass(kw_only=True)
+class HfCollumn(BaseModel):
+    """The `HfCollumn` object."""
+
+    data_type: HfDataType
+
+    name: str

hyperfluid/models/hf_data_type.py

@@ -0,0 +1,23 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class HfDataType(StrEnum):
+    """The values of `HfDataType`; others are kept as received."""
+
+    INT = "Int"
+    STRING = "String"
+    FLOAT = "Float"
+    DOUBLE = "Double"
+    BOOLEAN = "Boolean"
+    DATE = "Date"
+    TIMESTAMP = "Timestamp"
+    STRING_ARRAY = "StringArray"
+
+
+HfDataTypeLiteral: t.TypeAlias = t.Literal[
+    "Int", "String", "Float", "Double", "Boolean", "Date", "Timestamp", "StringArray"
+]
+"""The values of :class:`HfDataType`, which arguments take as plain strings too."""

hyperfluid/models/hf_key_value_cache_crd_spec_response.py

@@ -0,0 +1,23 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .resource_requirements_spec import ResourceRequirementsSpec
+
+
+@dataclasses.dataclass(kw_only=True)
+class HfKeyValueCacheCrdSpecResponse(BaseModel):
+    """The `HfKeyValueCacheCrdSpecResponse` object."""
+
+    image: str
+
+    maxmemory: str | None = None
+
+    maxmemory_policy: str | None = None
+
+    resources: ResourceRequirementsSpec | None = None