hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/models/create_pipeline_request_v2_copy_variant.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 .create_copy_pipeline_request import CreateCopyPipelineRequest
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreatePipelineRequestV2CopyVariant(BaseModel):
+    """Copy: Import API source → S3 destination"""
+
+    _FLATTENED: t.ClassVar[tuple[str, ...]] = ("create_copy_pipeline_request",)
+
+    create_copy_pipeline_request: CreateCopyPipelineRequest
+
+    type: t.Literal["copy"] = "copy"

hyperfluid/models/create_pipeline_request_v2_file_router_variant.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 .create_file_router_pipeline_request import CreateFileRouterPipelineRequest
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreatePipelineRequestV2FileRouterVariant(BaseModel):
+    """FileRouter: S3-to-S3 routing based on labels"""
+
+    _FLATTENED: t.ClassVar[tuple[str, ...]] = ("create_file_router_pipeline_request",)
+
+    create_file_router_pipeline_request: CreateFileRouterPipelineRequest
+
+    type: t.Literal["file_router"] = "file_router"

hyperfluid/models/create_pipeline_request_v2_file_sorter_variant.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 .create_file_sorter_request import CreateFileSorterRequest
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreatePipelineRequestV2FileSorterVariant(BaseModel):
+    """FileSorter: PDF OCR + Classification + Routing"""
+
+    _FLATTENED: t.ClassVar[tuple[str, ...]] = ("create_file_sorter_request",)
+
+    create_file_sorter_request: CreateFileSorterRequest
+
+    type: t.Literal["file_sorter"] = "file_sorter"

hyperfluid/models/create_pipeline_request_v2_inbound_email_variant.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 .create_inbound_email_pipeline_request import CreateInboundEmailPipelineRequest
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreatePipelineRequestV2InboundEmailVariant(BaseModel):
+    """InboundEmail: extract attachments from incoming emails (IMAP, SMTP, etc.) and load into S3"""
+
+    _FLATTENED: t.ClassVar[tuple[str, ...]] = ("create_inbound_email_pipeline_request",)
+
+    create_inbound_email_pipeline_request: CreateInboundEmailPipelineRequest
+
+    type: t.Literal["inbound_email"] = "inbound_email"

hyperfluid/models/create_pipeline_request_v2_open_data_variant.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 .create_open_data_pipeline_request import CreateOpenDataPipelineRequest
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreatePipelineRequestV2OpenDataVariant(BaseModel):
+    """OpenData: download open data CSV and load into Iceberg table"""
+
+    _FLATTENED: t.ClassVar[tuple[str, ...]] = ("create_open_data_pipeline_request",)
+
+    create_open_data_pipeline_request: CreateOpenDataPipelineRequest
+
+    type: t.Literal["open_data"] = "open_data"

hyperfluid/models/create_pipeline_request_v2_page_splitter_variant.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 .create_page_splitter_pipeline_request import CreatePageSplitterPipelineRequest
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreatePipelineRequestV2PageSplitterVariant(BaseModel):
+    """PageSplitter: splits OCR'd documents by page number"""
+
+    _FLATTENED: t.ClassVar[tuple[str, ...]] = ("create_page_splitter_pipeline_request",)
+
+    create_page_splitter_pipeline_request: CreatePageSplitterPipelineRequest
+
+    type: t.Literal["page_splitter"] = "page_splitter"

hyperfluid/models/create_pipeline_request_v2_share_point_variant.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 .create_share_point_pipeline_request import CreateSharePointPipelineRequest
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreatePipelineRequestV2SharePointVariant(BaseModel):
+    """SharePoint: download files from a SharePoint document library into S3"""
+
+    _FLATTENED: t.ClassVar[tuple[str, ...]] = ("create_share_point_pipeline_request",)
+
+    create_share_point_pipeline_request: CreateSharePointPipelineRequest
+
+    type: t.Literal["share_point"] = "share_point"

hyperfluid/models/create_pipeline_request_v2_trino_variant.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 .create_trino_pipeline_request import CreateTrinoPipelineRequest
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreatePipelineRequestV2TrinoVariant(BaseModel):
+    """Trino-based pipelines: Markitdown, HephaistosPdfeed, Labelizer"""
+
+    _FLATTENED: t.ClassVar[tuple[str, ...]] = ("create_trino_pipeline_request",)
+
+    create_trino_pipeline_request: CreateTrinoPipelineRequest
+
+    type: t.Literal["trino"] = "trino"

hyperfluid/models/create_pipeline_request_v2g_drive_variant.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 .create_g_drive_pipeline_request import CreateGDrivePipelineRequest
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreatePipelineRequestV2gDriveVariant(BaseModel):
+    """GDrive: download files from GDrive and load into S3"""
+
+    _FLATTENED: t.ClassVar[tuple[str, ...]] = ("create_g_drive_pipeline_request",)
+
+    create_g_drive_pipeline_request: CreateGDrivePipelineRequest
+
+    type: t.Literal["g_drive"] = "g_drive"

hyperfluid/models/create_pipeline_request_v2s3_copy_variant.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 .create_s3_copy_pipeline_request import CreateS3CopyPipelineRequest
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreatePipelineRequestV2s3CopyVariant(BaseModel):
+    """S3Copy: S3 source → S3 destination"""
+
+    _FLATTENED: t.ClassVar[tuple[str, ...]] = ("create_s3_copy_pipeline_request",)
+
+    create_s3_copy_pipeline_request: CreateS3CopyPipelineRequest
+
+    type: t.Literal["s3_copy"] = "s3_copy"

hyperfluid/models/create_postgresql_data_container_request_body.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 CreatePostgresqlDataContainerRequestBody(BaseModel):
+    """The `CreatePostgresqlDataContainerRequestBody` object."""
+
+    data_dock_id: UUID
+
+    managed_postgresql_user_id: UUID
+    """Managed PostgreSQL user whose credentials back the catalog. Must be a
+    read-only (`viewer`) user of a DBaaS cluster in the same organization
+    — the console derives the connection secret from the user's CRD
+    status, so arbitrary secrets can no longer be linked."""
+
+    name: str
+    """Trino catalog name."""

hyperfluid/models/create_property_definition_request.py

@@ -0,0 +1,25 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreatePropertyDefinitionRequest(BaseModel):
+    """The `CreatePropertyDefinitionRequest` object."""
+
+    api_name: str
+
+    data_type: str
+
+    display_name: str
+
+    description: str | None | Unset = UNSET
+
+    is_primary_key: bool | None = None
+
+    is_title: bool | None = None
+
+    source_column: str | None | Unset = UNSET

hyperfluid/models/create_ref_request.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
+
+if t.TYPE_CHECKING:
+    from .ref_status import RefStatus
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreateRefRequest(BaseModel):
+    """The `CreateRefRequest` object."""
+
+    key: str
+
+    pipeline_checksum: str
+
+    pipeline_id: UUID
+
+    status: RefStatus | None | Unset = UNSET

hyperfluid/models/create_registry_project_request_body.py

@@ -0,0 +1,16 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreateRegistryProjectRequestBody(BaseModel):
+    """The `CreateRegistryProjectRequestBody` object."""
+
+    name: str
+    """The `<project>` path segment in `<harbor>/<project>/<image>`."""
+
+    description: str | None | Unset = UNSET

hyperfluid/models/create_s3_copy_pipeline_request.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 .copy_destination_config import CopyDestinationConfig
+    from .copy_s3_source_config import CopyS3SourceConfig
+    from .pipeline_metadata import PipelineMetadata
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreateS3CopyPipelineRequest(BaseModel):
+    """S3-to-S3 copy pipeline request"""
+
+    destination: CopyDestinationConfig
+
+    pipeline: PipelineMetadata
+
+    source: CopyS3SourceConfig

hyperfluid/models/create_saved_query_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 CreateSavedQueryRequest(BaseModel):
+    """The `CreateSavedQueryRequest` object."""
+
+    data_dock_id: UUID
+
+    sql_text: str
+
+    title: str
+
+    alert_on_failure: bool | None | Unset = UNSET
+    """Whether the schedule gets its default "keeps failing" alert rule.
+    Omitted means yes."""
+
+    description: str | None | Unset = UNSET
+
+    schedule: str | None | Unset = UNSET
+    """Cron expression. Omitted or `null` means the query only runs on demand."""
+
+    service_account_id: UUID | None | Unset = UNSET
+    """The service account the schedule runs as. Required whenever `schedule`
+    is set, ignored otherwise — an on-demand query runs on its caller's own
+    token and needs no standing identity."""
+
+    tags: list[str] | None | Unset = UNSET
+
+    visibility: str | None | Unset = UNSET

hyperfluid/models/create_secret_request_body.py

@@ -0,0 +1,35 @@
+# 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_scope import SecretScope
+    from .secret_type import SecretType
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreateSecretRequestBody(BaseModel):
+    """The `CreateSecretRequestBody` object."""
+
+    name: str
+    """Hierarchical name, `/`-separated (`prod/db`). Max 255 characters and 10
+    segments of at least 3 characters each.
+
+    With `scope: user` this is a **leaf**: the stored name becomes
+    `users/<your oidc sub>/<name>`, so the budget left for it is 212
+    characters and 8 segments. `users` is a reserved top-level segment and is
+    refused in either scope. Every response echoes the full stored name."""
+
+    secret_type: SecretType
+
+    value: t.Any
+
+    description: str | None | Unset = UNSET
+
+    scope: SecretScope | None | Unset = UNSET
+
+    tags: list[str] | None = None

hyperfluid/models/create_service_account_crd_request_body.py

@@ -0,0 +1,38 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreateServiceAccountCrdRequestBody(BaseModel):
+    """The Keycloak client settings that can be chosen up front.
+
+    All of them are optional and fall back to the confidential-machine-account
+    defaults this endpoint has always applied, so a caller that only sends
+    `client_id` gets exactly the account it used to get.
+
+    `public_client` is worth setting here rather than editing afterwards:
+    switching a confidential client to public later destroys its stored secret
+    and there is no way to recover the old one."""
+
+    client_id: str
+    """The Keycloak client id, also the name of the `ServiceAccount` resource:
+    lowercase letters, digits and hyphens. Clients usually derive it from
+    `display_name` as a slug."""
+
+    description: str | None | Unset = UNSET
+
+    display_name: str | None | Unset = UNSET
+    """Human-readable name shown in the console; any characters. Defaults to
+    `client_id`."""
+
+    enabled: bool | None | Unset = UNSET
+
+    public_client: bool | None | Unset = UNSET
+
+    redirect_uris: list[str] | None | Unset = UNSET
+
+    web_origins: list[str] | None | Unset = UNSET

hyperfluid/models/create_service_link_request_body.py

@@ -0,0 +1,24 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .service_link_port import ServiceLinkPort
+    from .service_ref import ServiceRef
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreateServiceLinkRequestBody(BaseModel):
+    """The `CreateServiceLinkRequestBody` object."""
+
+    consumer: ServiceRef
+
+    target: ServiceRef
+
+    target_ports: list[ServiceLinkPort] | None = None
+    """Specific target ports to open. Empty ⇒ the operator resolves the default
+    (a ContainerApp's primary port, or a fixed-port kind's known port)."""

hyperfluid/models/create_session_request.py

@@ -0,0 +1,20 @@
+# 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 .session_workspace_request import SessionWorkspaceRequest
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreateSessionRequest(BaseModel):
+    """The `CreateSessionRequest` object."""
+
+    catalog_id: str
+    """Id of a `CatalogItem` returned from the catalog endpoint."""
+
+    workspace: SessionWorkspaceRequest | None | Unset = UNSET

hyperfluid/models/create_session_response.py

@@ -0,0 +1,24 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+
+from ..serialization import BaseModel
+
+if t.TYPE_CHECKING:
+    from .session_workspace import SessionWorkspace
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreateSessionResponse(BaseModel):
+    """The `CreateSessionResponse` object."""
+
+    catalog_id: str
+
+    id: str
+    """Opencode session id (forwarded verbatim from the upstream response).
+    Named `id` so the frontend's `AgentSession` shape lines up with both
+    this create response and the normalized session list."""
+
+    workspace: SessionWorkspace | None = None

hyperfluid/models/create_share_point_pipeline_request.py

@@ -0,0 +1,41 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+import typing as t
+from uuid import UUID
+
+from ..serialization import UNSET, BaseModel, Unset
+
+if t.TYPE_CHECKING:
+    from .g_drive_extraction_config import GDriveExtractionConfig
+    from .pipeline_metadata import PipelineMetadata
+    from .share_point_source_config import SharePointSourceConfig
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreateSharePointPipelineRequest(BaseModel):
+    """Create a SharePoint connector: copy files from a SharePoint document library
+    into an S3 bucket, optionally extracting their text into an Iceberg table.
+
+    The extraction block is [`GDriveExtractionConfig`], reused rather than
+    copied. Nothing in it is specific to Google Drive — it is "the extraction
+    step a file connector appends", with the same two variants and the same OCR
+    configuration — and the name lags for the reason [`api_key::ApiKey`]'s does:
+    renaming it would churn the OpenAPI schema, the generated console client and
+    the CLI's progenitor types for no behavioural gain."""
+
+    bucket_name: str
+    """HFBucket CRD name (must be Ready)"""
+
+    harbor_id: UUID
+    """Harbor UUID that owns the destination bucket"""
+
+    pipeline: PipelineMetadata
+
+    source: SharePointSourceConfig
+
+    destination_prefix: str | None | Unset = UNSET
+    """Optional prefix path within the destination bucket"""
+
+    extraction: GDriveExtractionConfig | None | Unset = UNSET

hyperfluid/models/create_signup_request_body.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 .intended_use import IntendedUse
+    from .requested_size import RequestedSize
+    from .requester_kind import RequesterKind
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreateSignupRequestBody(BaseModel):
+    """The `CreateSignupRequestBody` object."""
+
+    email: str
+
+    intended_use: IntendedUse
+
+    requested_size: RequestedSize
+
+    requester_kind: RequesterKind
+
+    use_case: str
+
+    organization_name: str | None | Unset = UNSET
+    """Company/institution name; expected (but not strictly required) when
+    `requester_kind` isn't `personal`."""

hyperfluid/models/create_signup_request_response.py

@@ -0,0 +1,14 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+from uuid import UUID
+
+from ..serialization import BaseModel
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreateSignupRequestResponse(BaseModel):
+    """The `CreateSignupRequestResponse` object."""
+
+    id: UUID

hyperfluid/models/create_skill_registry_request.py

@@ -0,0 +1,34 @@
+# 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 .create_skill_request import CreateSkillRequest
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreateSkillRegistryRequest(BaseModel):
+    """Create a harbor registry, optionally with its first skills in the same call."""
+
+    name: str
+    """Slug: `[a-z0-9][a-z0-9-]*`, at most 63 characters, and never containing
+    `--` (that pair separates registry from skill in the in-pod directory
+    name, so it must not appear inside either half)."""
+
+    auto_attach: bool | None = None
+    """Pre-check this registry in the workstation create wizard."""
+
+    description: str | None | Unset = UNSET
+
+    display_name: str | None | Unset = UNSET
+
+    root_doc: str | None | Unset = UNSET
+    """`REGISTRY.md` content."""
+
+    skills: list[CreateSkillRequest] | None = None
+    """Skills created together with the registry. A registry with only a root
+    doc is valid, so this may be empty."""

hyperfluid/models/create_skill_request.py

@@ -0,0 +1,21 @@
+# this file is @generated
+from __future__ import annotations
+
+import dataclasses
+
+from ..serialization import UNSET, BaseModel, Unset
+
+
+@dataclasses.dataclass(kw_only=True)
+class CreateSkillRequest(BaseModel):
+    """Add a skill to a registry."""
+
+    content: str
+    """Markdown body, without YAML front matter."""
+
+    name: str
+    """Slug, same rules as a registry name."""
+
+    description: str | None | Unset = UNSET
+    """One-line summary. The operator puts it in the rendered front matter, so
+    it is what an agent reads when deciding whether to load the skill."""