hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/models/dev_workstation_response.py

@@ -0,0 +1,58 @@
+# 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 .dev_workstation_status_response import DevWorkstationStatusResponse
+    from .workstation_repository_response import WorkstationRepositoryResponse
+
+
+@dataclasses.dataclass(kw_only=True)
+class DevWorkstationResponse(BaseModel):
+    """The `DevWorkstationResponse` object."""
+
+    created_at: datetime
+
+    harbor_id: UUID
+
+    id: UUID
+
+    name: str
+
+    organization_id: UUID
+
+    owner_user_id: str
+
+    preview_ports: list[int]
+    """Dev-server ports this workstation *declares* for preview
+    (`spec.preview.ports`; empty by default — nothing is declared unless a
+    template pins it). It is the picker's fallback while the live call is in
+    flight, not the allowed set: the live set — declared plus whatever is
+    actually listening — comes from `GET /api/dev/workstations/{id}/ports`."""
+
+    repo_ref: str
+
+    repo_url: str
+    """Primary repository. Kept as a flat field for existing clients; it is
+    always `repositories[0]`."""
+
+    repositories: list[WorkstationRepositoryResponse]
+    """Every repository the workstation clones, primary first."""
+
+    status: DevWorkstationStatusResponse
+
+    inference_provider: str | None = None
+    """Inference provider from the live CR (`sapience` | `openrouter` |
+    `claude`). Populated on the detail GET only (the CR read is per-resource);
+    `null` in list responses. Drives provider-dependent UI such as the
+    Agents tab surface (opencode chat vs Claude Code terminals)."""
+
+    scm_secret_id: UUID | None = None
+    """Secret reference used to browse repositories with the workstation's
+    SCM credential. The credential value is never exposed."""

hyperfluid/models/dev_workstation_setup_report_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 .setup_outcome import SetupOutcome
+
+
+@dataclasses.dataclass(kw_only=True)
+class DevWorkstationSetupReportResponse(BaseModel):
+    """The `DevWorkstationSetupReportResponse` object."""
+
+    outcome: SetupOutcome
+
+    output_truncated: bool
+
+    script_output: list[str]
+    """The script's own output for the reported run, oldest first, with the
+    log prefix stripped. Capped; `output_truncated` says whether lines were
+    dropped."""
+
+    exit_code: int | None = None
+    """Exit code parsed from the failure marker, when the run failed."""
+
+    finished_at: str | None = None
+    """RFC3339 timestamp of the run's completion/failure marker."""
+
+    message: str | None = None
+    """The raw marker line the verdict was derived from."""
+
+    started_at: str | None = None
+    """RFC3339 timestamp of the run's start marker."""

hyperfluid/models/dev_workstation_status_response.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 DevWorkstationStatusResponse(BaseModel):
+    """The `DevWorkstationStatusResponse` object."""
+
+    phase: str
+
+    message: str | None = None
+
+    pod_name: str | None = None
+
+    pod_namespace: str | None = None
+
+    template_ref: str | None = None
+    """`WorkstationTemplate` name the workstation was created from. `None` =
+    platform default base."""

hyperfluid/models/dev_workstation_transcript_entry.py

@@ -0,0 +1,25 @@
+# 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
+
+
+@dataclasses.dataclass(kw_only=True)
+class DevWorkstationTranscriptEntry(BaseModel):
+    """One entry of a transcript. The event is the typed payload, so the console
+    renders an agent request and a terminal command differently without the
+    server flattening them into strings first."""
+
+    actor: UUID
+    """Keycloak subject of the person who did this."""
+
+    event: dict[str, t.Any]
+
+    id: UUID
+
+    recorded_at: datetime

hyperfluid/models/discard_request.py

@@ -0,0 +1,14 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class DiscardRequest(BaseModel):
+    """The `DiscardRequest` object."""
+
+    path: str
+    """Repo-relative path to revert (`git checkout -- <path>`)."""

hyperfluid/models/domain_verification_response.py

@@ -0,0 +1,61 @@
+# 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 .app_usage_ref import AppUsageRef
+    from .domain_verification_state_dto import DomainVerificationStateDto
+
+
+@dataclasses.dataclass(kw_only=True)
+class DomainVerificationResponse(BaseModel):
+    """The `DomainVerificationResponse` object."""
+
+    _JSON_KEYS: t.ClassVar[t.Mapping[str, str]] = {
+        "apps_using": "appsUsing",
+        "created_at": "createdAt",
+        "expected_txt_record": "expectedTxtRecord",
+        "expected_txt_value": "expectedTxtValue",
+        "last_check_error": "lastCheckError",
+        "last_checked_at": "lastCheckedAt",
+        "organization_id": "organizationId",
+        "verified_at": "verifiedAt",
+    }
+
+    apex: str
+    """Apex domain being verified, e.g. `acme.com`."""
+
+    created_at: datetime
+
+    expected_txt_record: str
+    """Pre-computed DNS record name where the user must place the TXT challenge,
+    e.g. `_hyperfluid-challenge.acme.com`."""
+
+    expected_txt_value: str
+    """Pre-computed TXT value the user must publish, e.g.
+    `hyperfluid-domain-verification=ABCD1234...`."""
+
+    id: UUID
+
+    organization_id: UUID
+
+    state: DomainVerificationStateDto
+
+    apps_using: list[AppUsageRef] | None = None
+    """ContainerApps in the same org that have a `customDomain` falling under this apex.
+    Always empty in list responses to avoid N+1 K8s calls — populated on detail only."""
+
+    last_check_error: str | None = None
+    """Error from the most recent failed poll. Cleared on success."""
+
+    last_checked_at: datetime | None = None
+    """Timestamp of the most recent poll attempt (regardless of outcome)."""
+
+    verified_at: datetime | None = None
+    """Timestamp at which ownership was successfully verified."""

hyperfluid/models/domain_verification_state_dto.py

@@ -0,0 +1,15 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class DomainVerificationStateDto(StrEnum):
+    """The values of `DomainVerificationStateDto`; others are kept as received."""
+
+    PENDING = "pending"
+    VERIFIED = "verified"
+
+
+DomainVerificationStateDtoLiteral: t.TypeAlias = t.Literal["pending", "verified"]
+"""The values of :class:`DomainVerificationStateDto`, which arguments take as plain strings too."""

hyperfluid/models/downgrade_offer.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 DowngradeOffer(BaseModel):
+    """A lower tag than the running one, deployed only on an explicit request."""
+
+    running: str
+    """The tag the app runs, no longer the highest match."""
+
+    tag: str
+    """The highest tag that still matches."""

hyperfluid/models/download_service_account_response.py

@@ -0,0 +1,50 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class DownloadServiceAccountResponse(BaseModel):
+    """Resolved OAuth credentials for a service account, plus the contextual
+    fields (`org`, `org_id`, `api_url`) required by
+    `hfctl auth login --service-account`.
+
+    This is the ONE wire shape for service-account credentials in this crate —
+    shared, verbatim, by two handlers:
+    - `download_service_account_handler` (user-facing, `GET
+      /api/v1/orgs/{organization_id}/service-accounts/{service_account_id}/download`)
+    - `dev_workstations::internal_handlers::get_workstation_service_account_credentials`
+      (operator-only, `GET
+      /internal/orgs/{organization_id}/service-accounts/{service_account_id}/credentials`)
+
+    Both routes appear in different OpenAPI documents (external vs internal)
+    but reference this same Rust type, so their schemas can never drift from
+    each other. `hf_bin_cli::commands::auth::ServiceAccountFile` is the CLI's
+    parse target for the JSON this struct serializes to (either downloaded by
+    hand from the console, or materialized into a dev workstation by the
+    operator) — see the compile-time shape guard next to that struct."""
+
+    api_url: str
+    """Console API base URL the CLI should target (same value used to generate
+    the install script)."""
+
+    auth_uri: str
+
+    client_id: str
+
+    client_secret: str
+
+    issuer: str
+
+    org: str
+    """Organization slug — lets `hfctl auth login --service-account` configure
+    the org automatically, no manual `hfctl config set` needed."""
+
+    org_id: UUID
+    """Organization UUID — cached client-side so hfctl skips the slug→id lookup."""
+
+    token_uri: str

hyperfluid/models/duplicate_dashboard_request.py

@@ -0,0 +1,14 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class DuplicateDashboardRequest(BaseModel):
+    """The `DuplicateDashboardRequest` object."""
+
+    name: str | None | Unset = UNSET
+    """Name for the copy; defaults to "Copy of <name>"."""

hyperfluid/models/dynamic_label.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 .dynamic_label_placeholder import DynamicLabelPlaceholder
+
+
+@dataclasses.dataclass(kw_only=True)
+class DynamicLabel(BaseModel):
+    """Dynamic label configuration with format string and placeholders.
+    The format string contains placeholders like {year}, {date}, {name} that
+    get replaced with extracted values."""
+
+    format: str
+    """Format string with placeholders (e.g., "TRAVAUX/{year}/{date}-{work_name}")"""
+
+    placeholders: list[DynamicLabelPlaceholder]
+    """Placeholders to extract from the document"""

hyperfluid/models/dynamic_label_placeholder.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 DynamicLabelPlaceholder(BaseModel):
+    """Placeholder definition for dynamic labels.
+    Used to extract variable parts from documents (dates, names, etc.)"""
+
+    format: str
+    """Expected format (e.g., "YYYY", "YYMMDD", "Texte en majuscules")"""
+
+    id: str
+    """Unique identifier for this placeholder (e.g., "year", "employee_name")"""
+
+    source: str
+    """Instructions for the LLM on how to extract this value from the document"""
+
+    rules: list[str] | None = None
+    """Validation rules for the extracted value"""

hyperfluid/models/effect.py

@@ -0,0 +1,16 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class Effect(StrEnum):
+    """Whether a grant confers or withdraws access. Deny is evaluated with strict
+    precedence: any matching deny overrides every allow (see the Rego)."""
+
+    ALLOW = "allow"
+    DENY = "deny"
+
+
+EffectLiteral: t.TypeAlias = t.Literal["allow", "deny"]
+"""The values of :class:`Effect`, which arguments take as plain strings too."""

hyperfluid/models/effective_data_access_response.py

@@ -0,0 +1,28 @@
+# 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 .data_verb_decision import DataVerbDecision
+
+
+@dataclasses.dataclass(kw_only=True)
+class EffectiveDataAccessResponse(BaseModel):
+    """The `EffectiveDataAccessResponse` object."""
+
+    catalog: str
+
+    data_dock_id: UUID
+
+    schema: str
+
+    table: str
+
+    verbs: list[DataVerbDecision]
+    """One decision per verb, in the order describe, select, insert, update,
+    delete, annotate, alter, create, drop."""

hyperfluid/models/effective_security_settings_response.py

@@ -0,0 +1,43 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .data_access_baseline import DataAccessBaseline
+
+
+@dataclasses.dataclass(kw_only=True)
+class EffectiveSecuritySettingsResponse(BaseModel):
+    """Response for effective security settings."""
+
+    column_label_matching: bool
+
+    contextual_restrictions_enabled: bool
+
+    data_access_baseline: DataAccessBaseline
+
+    office_hours_enabled: bool
+
+    read_only_mode: bool
+
+    rls_enabled_catalogs: list[str]
+
+    rls_enabled_schemas: list[str]
+
+    rls_enabled_tables: list[str]
+
+    rls_label_column: str
+
+    sensitivity_enforcement: bool
+
+    table_label_matching: bool
+
+    zero_trust_mode: bool
+
+    office_hours_end_utc: str | None = None
+
+    office_hours_start_utc: str | None = None

hyperfluid/models/egress_allowlist_response.py

@@ -0,0 +1,26 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class EgressAllowlistResponse(BaseModel):
+    """An `EgressAllowlist` CR as returned by the harbor-scoped egress-allowlists API."""
+
+    fqdns: list[str]
+
+    name: str
+    """Kubernetes CRD name — the identifier referenced from
+    `DevWorkstation.spec.network.allowlists`."""
+
+    created_at: str | None = None
+    """RFC 3339 creation timestamp, straight off `metadata.creationTimestamp`
+    (same string-passthrough as `buckets::HFBucketView::created_at` — avoids
+    a `k8s_openapi::jiff` <-> `chrono` conversion for a display-only field)."""
+
+    description: str | None = None
+
+    display_name: str | None = None

hyperfluid/models/egress_destination_kind_dto.py

@@ -0,0 +1,16 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class EgressDestinationKindDto(StrEnum):
+    """The values of `EgressDestinationKindDto`; others are kept as received."""
+
+    FQDN = "fqdn"
+    POD = "pod"
+    IDENTITY = "identity"
+
+
+EgressDestinationKindDtoLiteral: t.TypeAlias = t.Literal["fqdn", "pod", "identity"]
+"""The values of :class:`EgressDestinationKindDto`, which arguments take as plain strings too."""

hyperfluid/models/egress_flow_summary_dto.py

@@ -0,0 +1,32 @@
+# 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 .egress_destination_kind_dto import EgressDestinationKindDto
+    from .egress_verdict_dto import EgressVerdictDto
+
+
+@dataclasses.dataclass(kw_only=True)
+class EgressFlowSummaryDto(BaseModel):
+    """One aggregated (destination, verdict, port) row."""
+
+    count: int
+
+    destination: str
+
+    kind: EgressDestinationKindDto
+
+    last_seen: datetime
+
+    verdict: EgressVerdictDto
+
+    port: int | None = None
+    """Destination port shared by every flow counted in this row — the same
+    host on two ports is two rows. `null` when the L4 protocol was neither
+    TCP nor UDP."""

hyperfluid/models/egress_verdict_dto.py

@@ -0,0 +1,15 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class EgressVerdictDto(StrEnum):
+    """The values of `EgressVerdictDto`; others are kept as received."""
+
+    FORWARDED = "forwarded"
+    DROPPED = "dropped"
+
+
+EgressVerdictDtoLiteral: t.TypeAlias = t.Literal["forwarded", "dropped"]
+"""The values of :class:`EgressVerdictDto`, which arguments take as plain strings too."""

hyperfluid/models/email_auth_policy.py

@@ -0,0 +1,19 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class EmailAuthPolicy(StrEnum):
+    """How the pipeline responds to email authentication failures (SPF/DKIM/DMARC).
+    Verdicts are always recorded in attachment metadata regardless of policy."""
+
+    PERMISSIVE = "permissive"
+    REJECT_ON_DMARC_FAIL = "reject_on_dmarc_fail"
+    REJECT_ON_ANY_AUTH_FAIL = "reject_on_any_auth_fail"
+
+
+EmailAuthPolicyLiteral: t.TypeAlias = t.Literal[
+    "permissive", "reject_on_dmarc_fail", "reject_on_any_auth_fail"
+]
+"""The values of :class:`EmailAuthPolicy`, which arguments take as plain strings too."""

hyperfluid/models/enable_sql_engine_request.py

@@ -0,0 +1,53 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class EnableSqlEngineRequest(BaseModel):
+    """Request body for `POST /api/v1/harbors/{harbor_id}/sql-engine/enable`.
+
+    Creates a TrinoInternal DataDock CRD and (optionally) a demo Iceberg
+    catalog + backing HFBucket in one declarative shot. Returns immediately;
+    the operator reconciles all three CRDs in dependency order without any
+    synchronous wait from the console."""
+
+    name: str
+    """Display name for the Trino cluster."""
+
+    slug: str
+    """K8s-safe slug (lowercase alphanumeric + hyphens). Used as the DataDock
+    CRD name and as the `data_dock_ref` in the TrinoCatalog."""
+
+    bucket_name: str | None = None
+    """Name of the HFBucket to create/reuse for the Iceberg warehouse
+    (only used when `seed_demo_catalog = true`). Defaults to
+    `"demo-iceberg"`."""
+
+    catalog_name: str | None = None
+    """Name of the Iceberg catalog to create (only used when
+    `seed_demo_catalog = true`). Defaults to `"demo_iceberg"`."""
+
+    expose_to_internet: bool | None | Unset = UNSET
+    """Whether the operator publishes an internet-facing Ingress in front of
+    the new cluster's Trino coordinator.
+
+    Absent (the default) leaves `spec.config.expose_to_internet` out of the
+    DataDock CR entirely, so the operator resolves the platform default —
+    exposed — at reconcile time and the resolved value is never frozen into
+    the spec (CLAUDE.md). `false` creates the cluster private: Trino is
+    reachable in-cluster only (Bifrost, Petite Requête, pipelines), with no
+    public route ever published, which is why this belongs on the create
+    call rather than a follow-up `PUT .../internet-exposure` that would race
+    the first reconcile. Flippable afterwards from that same endpoint."""
+
+    seed_demo_catalog: bool | None = None
+    """When true, also creates a demo HFBucket and an Iceberg TrinoCatalog
+    with medallion scaffold enabled. Both are idempotent (409 = already
+    exists is treated as success). Defaults to false."""
+
+    worker_replicas: int | None = None
+    """Number of Trino worker replicas. Clamped to ≥1. Defaults to 2."""

hyperfluid/models/enable_sql_engine_response.py

@@ -0,0 +1,29 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class EnableSqlEngineResponse(BaseModel):
+    """Response for `POST /api/v1/harbors/{harbor_id}/sql-engine/enable`.
+
+    Returned immediately after the CRDs are applied; the operator reconciles
+    asynchronously. `catalog_name` is `null` when `seed_demo_catalog` was
+    `false`."""
+
+    data_dock_slug: str
+    """Slug of the DataDock CRD that was created."""
+
+    catalog_name: str | None = None
+    """Name of the Iceberg catalog CRD that was created, or `null` when
+    `seed_demo_catalog` was `false`."""
+
+    demo_bucket_conflict: str | None = None
+    """ADR-0048 D6/P10: set when the demo bucket name is already taken by a
+    DIFFERENT (harbor, zone) — the slug of the harbor that actually owns
+    it. The demo catalog is skipped (no catalog, best-effort), but the
+    `/enable` call itself still succeeds. `null` on a clean create, or on
+    an idempotent re-run of this harbor's own `default`-zone demo bucket."""