hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/models/file_sorter_source_config.py

@@ -0,0 +1,40 @@
+# this file is @generated
+from __future__ import annotations
+
+import typing as t
+
+from ..serialization import Discriminator, UnknownVariant
+from .file_sorter_source_config_data_container_variant import (
+    FileSorterSourceConfigDataContainerVariant,
+)
+from .file_sorter_source_config_harbor_bucket_variant import (
+    FileSorterSourceConfigHarborBucketVariant,
+)
+
+FileSorterSourceConfig: t.TypeAlias = t.Annotated[
+    FileSorterSourceConfigDataContainerVariant
+    | FileSorterSourceConfigHarborBucketVariant
+    | UnknownVariant,
+    Discriminator(
+        "type",
+        {
+            "data_container": FileSorterSourceConfigDataContainerVariant,
+            "harbor_bucket": FileSorterSourceConfigHarborBucketVariant,
+        },
+    ),
+]
+"""FileSorter source configuration (S3 bucket for unsorted files).
+
+Two variants are accepted:
+
+* **`DataContainer`** (legacy) — a `DataContainerBucket` UUID from Postgres.
+  The DataDock that owns the container is resolved automatically, and the
+  shared-RGW path is attempted first with a fallback to the legacy per-DataDock
+  Vault credentials.
+
+* **`HarborBucket`** (ADR-0008) — an `HFBucket` CRD name under a Harbor UUID.
+  The bucket must exist and be Ready in the cluster. **No legacy fallback** —
+  if the Harbor has no `HarborStorageBinding` pointing at a Ready `OrgStorage`,
+  the request fails immediately with a clear error.
+
+Told apart by `type`; a variant this SDK version does not know is an `UnknownVariant`."""

hyperfluid/models/file_sorter_source_config_data_container_variant.py

@@ -0,0 +1,21 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+from uuid import UUID
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class FileSorterSourceConfigDataContainerVariant(BaseModel):
+    """Legacy path: resolve via DataContainerBucket UUID."""
+
+    data_container_id: UUID
+    """Data Container ID for the source bucket (DataDock is resolved automatically)"""
+
+    type: t.Literal["data_container"] = "data_container"
+
+    folder_prefix: str | None | Unset = UNSET
+    """Optional folder prefix within the bucket"""

hyperfluid/models/file_sorter_source_config_harbor_bucket_variant.py

@@ -0,0 +1,24 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+from uuid import UUID
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class FileSorterSourceConfigHarborBucketVariant(BaseModel):
+    """ADR-0008 path: resolve via Harbor-scoped HFBucket CRD."""
+
+    bucket_name: str
+    """HFBucket CRD name (must be Ready)"""
+
+    harbor_id: UUID
+    """Harbor UUID that owns the bucket"""
+
+    type: t.Literal["harbor_bucket"] = "harbor_bucket"
+
+    folder_prefix: str | None | Unset = UNSET
+    """Optional folder prefix within the bucket"""

hyperfluid/models/finding.py

@@ -0,0 +1,27 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class Finding(BaseModel):
+    """The `Finding` object."""
+
+    id: str
+
+    installed_version: str
+
+    pkg_name: str
+
+    severity: str
+
+    target: str
+
+    fixed_version: str | None = None
+
+    primary_url: str | None = None
+
+    title: str | None = None

hyperfluid/models/fixable_counts.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 FixableCounts(BaseModel):
+    """The `FixableCounts` object."""
+
+    critical: int
+
+    high: int
+
+    total: int

hyperfluid/models/flow_direction.py

@@ -0,0 +1,15 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class FlowDirection(StrEnum):
+    """The values of `FlowDirection`; others are kept as received."""
+
+    INGRESS = "ingress"
+    EGRESS = "egress"
+
+
+FlowDirectionLiteral: t.TypeAlias = t.Literal["ingress", "egress"]
+"""The values of :class:`FlowDirection`, which arguments take as plain strings too."""

hyperfluid/models/flow_verdict.py

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

hyperfluid/models/forgejo_repo_entry.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 ForgejoRepoEntry(BaseModel):
+    """A repository in the org's in-cluster Forgejo."""
+
+    clone_url: str
+    """In-cluster git clone URL. Feed this directly to the workstation's
+    `repository.url` — it routes to the forge over the cluster network with
+    no external egress.
+
+    Shape: `http://ca-{forge_container_app}.{forge_namespace}.svc.cluster.local:3000/{full_name}.git`"""
+
+    default_branch: str
+    """Default branch — pre-fills the branch picker as a sensible starting point."""
+
+    full_name: str
+    """Canonical `owner/name` identifier (e.g. `default/my-service`)."""

hyperfluid/models/forgejo_runner_response.py

@@ -0,0 +1,57 @@
+# 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 .forgejo_runner_status_response import ForgejoRunnerStatusResponse
+    from .runner_flavor_dto import RunnerFlavorDto
+    from .runner_resources_dto import RunnerResourcesDto
+
+
+@dataclasses.dataclass(kw_only=True)
+class ForgejoRunnerResponse(BaseModel):
+    """Response DTO for a `ForgejoRunner` CR, including live status fields for
+    polling in the UI."""
+
+    allowlists: list[str]
+    """Names of the egress allow-lists attached to this runner."""
+
+    extra_egress_fqdns: list[str]
+    """Extra egress FQDNs as stored on the CR, including the platform registry
+    host the console injects at creation."""
+
+    flavor: RunnerFlavorDto
+
+    harbor_id: UUID
+    """Owning harbor UUID (from `spec.harbor_id`)."""
+
+    name: str
+    """CR `metadata.name`."""
+
+    organization_id: UUID
+    """Owning organization UUID (from `spec.organization_id`)."""
+
+    replicas: int
+    """Configured replica count (from `spec.replicas`)."""
+
+    resources: RunnerResourcesDto
+
+    status: ForgejoRunnerStatusResponse
+
+    generation: int | None = None
+    """`metadata.generation` of the CR; compare with
+    `status.egress_observed_generation` to detect a pending network change."""
+
+    labels: list[str] | None = None
+    """Runner registration labels (from `spec.labels`)."""
+
+    registry_host: str | None = None
+    """Platform OCI registry host CI jobs push to (from `spec.registry_host`)."""
+
+    runner_image: str | None = None
+    """Runner container image (from `spec.runner_image`)."""

hyperfluid/models/forgejo_runner_status_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 ForgejoRunnerStatusResponse(BaseModel):
+    """Lifecycle status of the Forgejo runner, derived from `ForgejoRunnerStatus`."""
+
+    effective_egress_fqdns: list[str]
+    """Every FQDN the runner's network policy currently allows: registry
+    hosts, extra FQDNs and the resolved allow-lists."""
+
+    registered: bool
+    """Whether the runner has successfully registered with its Forgejo instance."""
+
+    unresolved_allowlists: list[str]
+    """Names from `allowlists` that could not be resolved on the most recent
+    reconcile — a dangling reference (the `EgressAllowlist` was deleted or
+    never existed in this harbor). Non-empty means the runner's egress
+    policy is narrower than `allowlists` implies."""
+
+    egress_observed_generation: int | None = None
+    """CR generation the network policy was last rendered from."""
+
+    message: str | None = None
+    """Human-readable status message (last error or transition reason)."""
+
+    observed_pod: str | None = None
+    """Name of the Pod currently managed by the operator.  `null` before the
+    Pod is created or after it is deleted."""
+
+    phase: str | None = None
+    """Current lifecycle phase string
+    (`"Pending"`, `"Provisioning"`, `"Registering"`, `"Running"`, `"Failed"`).
+    `null` before the operator acts on the CR."""

hyperfluid/models/g_drive_extraction_config.py

@@ -0,0 +1,30 @@
+# 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 .g_drive_extraction_type import GDriveExtractionType
+    from .metadata_storage_config import MetadataStorageConfig
+    from .ocr_provider_config import OcrProviderConfig
+    from .secret_ref import SecretRef
+
+
+@dataclasses.dataclass(kw_only=True)
+class GDriveExtractionConfig(BaseModel):
+    """Optional extraction step appended after the Copy step in a GDrive pipeline"""
+
+    extraction_type: GDriveExtractionType
+
+    metadata_storage: MetadataStorageConfig
+
+    ocr_api_key: str | None | Unset = UNSET
+    """API key for Mistral OCR, as a literal. Required when `ocr_provider` is
+    Mistral (the default) and `ocr_api_key_secret` is not set."""
+
+    ocr_api_key_secret: SecretRef | None | Unset = UNSET
+
+    ocr_provider: OcrProviderConfig | None | Unset = UNSET

hyperfluid/models/g_drive_extraction_type.py

@@ -0,0 +1,15 @@
+# this file is @generated
+import typing as t
+
+from ..serialization import StrEnum
+
+
+class GDriveExtractionType(StrEnum):
+    """Extraction step type for the GDrive connector"""
+
+    OMNIFEED = "omnifeed"
+    PDFEED = "pdfeed"
+
+
+GDriveExtractionTypeLiteral: t.TypeAlias = t.Literal["omnifeed", "pdfeed"]
+"""The values of :class:`GDriveExtractionType`, which arguments take as plain strings too."""

hyperfluid/models/g_drive_source_config.py

@@ -0,0 +1,33 @@
+# 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 .secret_ref import SecretRef
+
+
+@dataclasses.dataclass(kw_only=True)
+class GDriveSourceConfig(BaseModel):
+    """GDrive source configuration"""
+
+    service_account_email: str
+    """Service account email for GDrive connector authentication"""
+
+    prefix: str | None | Unset = UNSET
+    """Optional folder prefix within the bucket"""
+
+    private_key: str | None | Unset = UNSET
+    """The service account's PEM-encoded private key, as a literal.
+
+    Optional since #4002: a caller may send `private_key_secret` instead, and
+    exactly one of the two is required. It stays a plain string so every
+    client written before the secret form keeps working unchanged — and it
+    remains the only form an already-created pipeline has."""
+
+    private_key_secret: SecretRef | None | Unset = UNSET
+
+    shared_drive_id: str | None | Unset = UNSET

hyperfluid/models/gc_status_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 GcStatusResponse(BaseModel):
+    """GC schedule and last-run status for a harbor's registry."""
+
+    schedule: str
+    """Active cron schedule (5-field). Falls back to `"0 3 * * *"` when not
+    set on the spec — matches the operator default."""
+
+    suspended: bool
+    """Whether the daily GC CronJob is suspended. `false` when not set on the spec."""
+
+    last_gc_result: str | None = None
+    """Result of the most-recent GC job: `"Running"`, `"Succeeded"`, or
+    `"Failed"`. `null` until the first GC run is recorded."""
+
+    last_gc_time: str | None = None
+    """RFC3339 timestamp of the most-recent GC job's completion (or creation
+    time if still running). `null` until the first GC run completes."""

hyperfluid/models/generate_ontology_request.py

@@ -0,0 +1,36 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class GenerateOntologyRequest(BaseModel):
+    """Body for `POST /ontology/generate` — points the copilot at a Data Dock
+    (and optionally narrows the grounding to one catalog/schema/table set)."""
+
+    data_dock_id: UUID
+    """Data Dock whose schema grounds the generation (fetched with the
+    caller's own JWT — same trust boundary as the dashboard copilot and
+    the SQL editor)."""
+
+    catalog: str | None | Unset = UNSET
+    """Narrow grounding to one catalog (defaults to every catalog visible
+    through the dock)."""
+
+    instructions: str | None | Unset = UNSET
+    """Free-form extra guidance appended to the system prompt ("skip the
+    audit_* tables", "prefer plural display names in French"...)."""
+
+    model: str | None | Unset = UNSET
+    """Model override; defaults to the platform's generation model."""
+
+    schema: str | None | Unset = UNSET
+    """Narrow grounding to one schema within `catalog`."""
+
+    tables: list[str] | None = None
+    """Narrow grounding to specific tables (by name, any schema/catalog
+    matched above). Empty means "every table in scope"."""

hyperfluid/models/get_console_config_response.py

@@ -0,0 +1,73 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .ceph_zone_response import CephZoneResponse
+    from .console_config_feature_flag import ConsoleConfigFeatureFlag
+    from .custom_domain_target_response import CustomDomainTargetResponse
+    from .managed_mail_config_response import ManagedMailConfigResponse
+
+
+@dataclasses.dataclass(kw_only=True)
+class GetConsoleConfigResponse(BaseModel):
+    """The `GetConsoleConfigResponse` object."""
+
+    app_version: str
+
+    bifrost_api_url: str
+
+    bifrost_sql_endpoint: str
+
+    ceph_zones: list[CephZoneResponse]
+    """Available Ceph zones for DataDock creation."""
+
+    console_base_domain: str
+    """The base domain for the console (e.g., "localhost" for dev, "hyperfluid.app" for prod)."""
+
+    console_public_url: str
+    """Full canonical public URL of the console (e.g. "https://console.hyperfluid.cloud").
+    Lets the frontend show canonical URLs (e.g. the CLI install command) instead
+    of the org-subdomain origin the user happens to be browsing."""
+
+    console_service_account_client_id: str
+
+    feature_flags: list[ConsoleConfigFeatureFlag]
+
+    llm_gateway_public_url: str
+    """Public ingress URL of the LLMaaS gateway, shown in copy-paste endpoint
+    snippets on model detail pages. Empty when the gateway has no public
+    ingress; the console then falls back to its own origin."""
+
+    managed_mail: ManagedMailConfigResponse
+
+    oidc_base_url: str
+
+    oidc_expected_audiences: list[str]
+
+    sapience_api_url: str
+
+    apps_base_domain: str | None = None
+    """Base domain under which ContainerApp workloads are served
+    (e.g. `"apps.192.168.121.100.nip.io"` in dev). `None` when the platform
+    has not configured a CaaS apps domain.
+
+    Platform information only: a client cannot derive a ContainerApp URL
+    from it, because the operator scopes the app's bare `network.host` label
+    with the org and harbor per a platform-wide host naming mode the client
+    never sees. The serving URL is `ContainerApp.status.endpoint`, or
+    `status.customDomains[]` for a bring-your-own domain."""
+
+    custom_domain_target: CustomDomainTargetResponse | None = None
+
+    preview_host_suffix: str | None = None
+    """Fixed DNS parent workstation previews are served under, e.g.
+    `"ws-preview.example.com"` — a preview is then
+    `p-{workstation_id}-{port}.<suffix>`. `null` means previews live one
+    label under the console host the browser is on, which is what a
+    single-host console uses; the frontend falls back to
+    `window.location.host` there."""

hyperfluid/models/get_faker_field_types_response.py

@@ -0,0 +1,20 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .faker_field_type import FakerFieldType
+    from .faker_table_template import FakerTableTemplate
+
+
+@dataclasses.dataclass(kw_only=True)
+class GetFakerFieldTypesResponse(BaseModel):
+    """The `GetFakerFieldTypesResponse` object."""
+
+    data: list[FakerFieldType]
+
+    templates: list[FakerTableTemplate]

hyperfluid/models/get_faker_schema_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 .faker_schema_overview import FakerSchemaOverview
+
+
+@dataclasses.dataclass(kw_only=True)
+class GetFakerSchemaResponse(BaseModel):
+    """The `GetFakerSchemaResponse` object."""
+
+    data: list[FakerSchemaOverview]

hyperfluid/models/get_faker_table_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 .faker_table_overview import FakerTableOverview
+
+
+@dataclasses.dataclass(kw_only=True)
+class GetFakerTableResponse(BaseModel):
+    """The `GetFakerTableResponse` object."""
+
+    data: FakerTableOverview

hyperfluid/models/get_faker_tables_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 .faker_table_overview import FakerTableOverview
+
+
+@dataclasses.dataclass(kw_only=True)
+class GetFakerTablesResponse(BaseModel):
+    """The `GetFakerTablesResponse` object."""
+
+    data: list[FakerTableOverview]

hyperfluid/models/get_run_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 .pipeline_run import PipelineRun
+
+
+@dataclasses.dataclass(kw_only=True)
+class GetRunResponse(BaseModel):
+    """The `GetRunResponse` object."""
+
+    run: PipelineRun

hyperfluid/models/git_diff.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 .git_file_status import GitFileStatus
+
+
+@dataclasses.dataclass(kw_only=True)
+class GitDiff(BaseModel):
+    """The `GitDiff` object."""
+
+    clean: bool
+    """True when the working tree has no changes."""
+
+    diff: str
+    """Full `git diff` (unstaged working-tree changes), capped."""
+
+    files: list[GitFileStatus]

hyperfluid/models/git_file_status.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 GitFileStatus(BaseModel):
+    """The `GitFileStatus` object."""
+
+    path: str
+    """Repo-relative path."""
+
+    status: str
+    """Two-char porcelain status (e.g. " M", "A ", "??")."""