hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/api/dev_workstations_metrics.py

@@ -0,0 +1,118 @@
+# this file is @generated
+"""Dev workstations metrics API."""
+
+from __future__ import annotations
+
+import typing as t
+from uuid import UUID
+
+from .. import models as _models
+from ..models import (
+    DevWorkstationMetrics,
+)
+from ..serialization import UNSET, Unset
+from ._response import async_to_raw_response_wrapper, to_raw_response_wrapper
+from .common import (
+    ApiBaseAsync,
+    ApiBaseSync,
+    ApiRequest,
+    Timeout,
+    decode_response,
+    encode_path_param,
+)
+
+
+class AsyncDevWorkstationsMetrics(ApiBaseAsync):
+    """Dev workstations metrics API, for asyncio."""
+
+    @property
+    def with_raw_response(self) -> AsyncDevWorkstationsMetricsWithRawResponse:
+        """These methods, returning an :class:`APIResponse` with the status and headers."""
+        return AsyncDevWorkstationsMetricsWithRawResponse(self)
+
+    async def list_dev_workstation_metrics(
+        self,
+        id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> DevWorkstationMetrics:
+        """`GET /api/dev/workstations/{id}/metrics`."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/dev/workstations/{id}/metrics",
+                path_params={
+                    "id": encode_path_param("id", id, "simple", False),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, DevWorkstationMetrics)
+
+
+class AsyncDevWorkstationsMetricsWithRawResponse:
+    """The methods of :class:`AsyncDevWorkstationsMetrics`, returning an :class:`APIResponse`."""
+
+    def __init__(self, resource: AsyncDevWorkstationsMetrics) -> None:
+        self.list_dev_workstation_metrics = async_to_raw_response_wrapper(
+            resource.list_dev_workstation_metrics
+        )
+
+
+class DevWorkstationsMetrics(ApiBaseSync):
+    """Dev workstations metrics API."""
+
+    @property
+    def with_raw_response(self) -> DevWorkstationsMetricsWithRawResponse:
+        """These methods, returning an :class:`APIResponse` with the status and headers."""
+        return DevWorkstationsMetricsWithRawResponse(self)
+
+    def list_dev_workstation_metrics(
+        self,
+        id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> DevWorkstationMetrics:
+        """`GET /api/dev/workstations/{id}/metrics`."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/dev/workstations/{id}/metrics",
+                path_params={
+                    "id": encode_path_param("id", id, "simple", False),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, DevWorkstationMetrics)
+
+
+class DevWorkstationsMetricsWithRawResponse:
+    """The methods of :class:`DevWorkstationsMetrics`, returning an :class:`APIResponse`."""
+
+    def __init__(self, resource: DevWorkstationsMetrics) -> None:
+        self.list_dev_workstation_metrics = to_raw_response_wrapper(
+            resource.list_dev_workstation_metrics
+        )

hyperfluid/api/dev_workstations_preview_ports.py

@@ -0,0 +1,118 @@
+# this file is @generated
+"""Dev workstations preview ports API."""
+
+from __future__ import annotations
+
+import typing as t
+from uuid import UUID
+
+from .. import models as _models
+from ..models import (
+    PreviewPortsResponse,
+)
+from ..serialization import UNSET, Unset
+from ._response import async_to_raw_response_wrapper, to_raw_response_wrapper
+from .common import (
+    ApiBaseAsync,
+    ApiBaseSync,
+    ApiRequest,
+    Timeout,
+    decode_response,
+    encode_path_param,
+)
+
+
+class AsyncDevWorkstationsPreviewPorts(ApiBaseAsync):
+    """Dev workstations preview ports API, for asyncio."""
+
+    @property
+    def with_raw_response(self) -> AsyncDevWorkstationsPreviewPortsWithRawResponse:
+        """These methods, returning an :class:`APIResponse` with the status and headers."""
+        return AsyncDevWorkstationsPreviewPortsWithRawResponse(self)
+
+    async def list_dev_workstation_ports(
+        self,
+        id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> PreviewPortsResponse:
+        """`GET /api/dev/workstations/{id}/ports`."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/dev/workstations/{id}/ports",
+                path_params={
+                    "id": encode_path_param("id", id, "simple", False),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, PreviewPortsResponse)
+
+
+class AsyncDevWorkstationsPreviewPortsWithRawResponse:
+    """The methods of :class:`AsyncDevWorkstationsPreviewPorts`, returning an :class:`APIResponse`."""
+
+    def __init__(self, resource: AsyncDevWorkstationsPreviewPorts) -> None:
+        self.list_dev_workstation_ports = async_to_raw_response_wrapper(
+            resource.list_dev_workstation_ports
+        )
+
+
+class DevWorkstationsPreviewPorts(ApiBaseSync):
+    """Dev workstations preview ports API."""
+
+    @property
+    def with_raw_response(self) -> DevWorkstationsPreviewPortsWithRawResponse:
+        """These methods, returning an :class:`APIResponse` with the status and headers."""
+        return DevWorkstationsPreviewPortsWithRawResponse(self)
+
+    def list_dev_workstation_ports(
+        self,
+        id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> PreviewPortsResponse:
+        """`GET /api/dev/workstations/{id}/ports`."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/dev/workstations/{id}/ports",
+                path_params={
+                    "id": encode_path_param("id", id, "simple", False),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, PreviewPortsResponse)
+
+
+class DevWorkstationsPreviewPortsWithRawResponse:
+    """The methods of :class:`DevWorkstationsPreviewPorts`, returning an :class:`APIResponse`."""
+
+    def __init__(self, resource: DevWorkstationsPreviewPorts) -> None:
+        self.list_dev_workstation_ports = to_raw_response_wrapper(
+            resource.list_dev_workstation_ports
+        )

hyperfluid/api/dev_workstations_preview_proxy.py

@@ -0,0 +1,120 @@
+# this file is @generated
+"""Dev workstations preview proxy API."""
+
+from __future__ import annotations
+
+import typing as t
+from uuid import UUID
+
+from .. import models as _models
+from ..models import (
+    AuthorizePreviewResponse,
+)
+from ..serialization import UNSET, Unset
+from ._response import async_to_raw_response_wrapper, to_raw_response_wrapper
+from .common import (
+    ApiBaseAsync,
+    ApiBaseSync,
+    ApiRequest,
+    Timeout,
+    decode_response,
+    encode_path_param,
+)
+
+
+class AsyncDevWorkstationsPreviewProxy(ApiBaseAsync):
+    """Dev workstations preview proxy API, for asyncio."""
+
+    @property
+    def with_raw_response(self) -> AsyncDevWorkstationsPreviewProxyWithRawResponse:
+        """These methods, returning an :class:`APIResponse` with the status and headers."""
+        return AsyncDevWorkstationsPreviewProxyWithRawResponse(self)
+
+    async def authorize_preview(
+        self,
+        id: UUID,
+        port: int,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> AuthorizePreviewResponse:
+        """`POST /api/dev/workstations/{id}/preview-authorize/{port}`."""
+        response = await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/dev/workstations/{id}/preview-authorize/{port}",
+                path_params={
+                    "id": encode_path_param("id", id, "simple", False),
+                    "port": encode_path_param("port", port, "simple", False),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, AuthorizePreviewResponse)
+
+
+class AsyncDevWorkstationsPreviewProxyWithRawResponse:
+    """The methods of :class:`AsyncDevWorkstationsPreviewProxy`, returning an :class:`APIResponse`."""
+
+    def __init__(self, resource: AsyncDevWorkstationsPreviewProxy) -> None:
+        self.authorize_preview = async_to_raw_response_wrapper(
+            resource.authorize_preview
+        )
+
+
+class DevWorkstationsPreviewProxy(ApiBaseSync):
+    """Dev workstations preview proxy API."""
+
+    @property
+    def with_raw_response(self) -> DevWorkstationsPreviewProxyWithRawResponse:
+        """These methods, returning an :class:`APIResponse` with the status and headers."""
+        return DevWorkstationsPreviewProxyWithRawResponse(self)
+
+    def authorize_preview(
+        self,
+        id: UUID,
+        port: int,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> AuthorizePreviewResponse:
+        """`POST /api/dev/workstations/{id}/preview-authorize/{port}`."""
+        response = self._request(
+            ApiRequest(
+                method="post",
+                path="/api/dev/workstations/{id}/preview-authorize/{port}",
+                path_params={
+                    "id": encode_path_param("id", id, "simple", False),
+                    "port": encode_path_param("port", port, "simple", False),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, AuthorizePreviewResponse)
+
+
+class DevWorkstationsPreviewProxyWithRawResponse:
+    """The methods of :class:`DevWorkstationsPreviewProxy`, returning an :class:`APIResponse`."""
+
+    def __init__(self, resource: DevWorkstationsPreviewProxy) -> None:
+        self.authorize_preview = to_raw_response_wrapper(resource.authorize_preview)

hyperfluid/api/dev_workstations_repositories.py

@@ -0,0 +1,284 @@
+# this file is @generated
+"""Dev workstations repositories API."""
+
+from __future__ import annotations
+
+import typing as t
+from uuid import UUID
+
+from .. import models as _models
+from ..models import (
+    AddWorkstationRepositoryResponse,
+    WorkstationRepositoryInput,
+    WorkstationRepositoryResponse,
+)
+from ..serialization import UNSET, Unset, to_json_value
+from ._response import async_to_raw_response_wrapper, to_raw_response_wrapper
+from .common import (
+    ApiBaseAsync,
+    ApiBaseSync,
+    ApiRequest,
+    Timeout,
+    decode_response,
+    encode_path_param,
+)
+
+
+class AsyncDevWorkstationsRepositories(ApiBaseAsync):
+    """Dev workstations repositories API, for asyncio."""
+
+    @property
+    def with_raw_response(self) -> AsyncDevWorkstationsRepositoriesWithRawResponse:
+        """These methods, returning an :class:`APIResponse` with the status and headers."""
+        return AsyncDevWorkstationsRepositoriesWithRawResponse(self)
+
+    async def list_dev_workstation_repositories(
+        self,
+        id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> list[WorkstationRepositoryResponse]:
+        """`GET /api/dev/workstations/{id}/repositories`."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/dev/workstations/{id}/repositories",
+                path_params={
+                    "id": encode_path_param("id", id, "simple", False),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, list[WorkstationRepositoryResponse])
+
+    async def create_dev_workstation_repository(
+        self,
+        id: UUID,
+        *,
+        url: str,
+        provider: str | None | Unset = UNSET,
+        repo_ref: str | None | Unset = UNSET,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> AddWorkstationRepositoryResponse:
+        """`POST /api/dev/workstations/{id}/repositories`.
+
+        :param provider: SCM provider: `github`, `gitlab` or `forgejo`. Must match the workstation's primary provider — the in-pod git credential helper is host-blind, so a single token has to work for every repository. With `gitlab` that means the same instance too, self-managed or not.
+        :param repo_ref: Branch/tag to check out. Defaults to `main`.
+        :param url: http(s) clone URL."""
+        response = await self._request(
+            ApiRequest(
+                method="post",
+                path="/api/dev/workstations/{id}/repositories",
+                path_params={
+                    "id": encode_path_param("id", id, "simple", False),
+                },
+                json_body=to_json_value(
+                    WorkstationRepositoryInput(
+                        provider=provider,
+                        repo_ref=repo_ref,
+                        url=url,
+                    ),
+                    WorkstationRepositoryInput,
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, AddWorkstationRepositoryResponse)
+
+    async def delete_dev_workstation_repository(
+        self,
+        id: UUID,
+        repo_id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> None:
+        """`DELETE /api/dev/workstations/{id}/repositories/{repo_id}`."""
+        await self._request(
+            ApiRequest(
+                method="delete",
+                path="/api/dev/workstations/{id}/repositories/{repo_id}",
+                path_params={
+                    "id": encode_path_param("id", id, "simple", False),
+                    "repo_id": encode_path_param("repo_id", repo_id, "simple", False),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+
+
+class AsyncDevWorkstationsRepositoriesWithRawResponse:
+    """The methods of :class:`AsyncDevWorkstationsRepositories`, returning an :class:`APIResponse`."""
+
+    def __init__(self, resource: AsyncDevWorkstationsRepositories) -> None:
+        self.list_dev_workstation_repositories = async_to_raw_response_wrapper(
+            resource.list_dev_workstation_repositories
+        )
+        self.create_dev_workstation_repository = async_to_raw_response_wrapper(
+            resource.create_dev_workstation_repository
+        )
+        self.delete_dev_workstation_repository = async_to_raw_response_wrapper(
+            resource.delete_dev_workstation_repository
+        )
+
+
+class DevWorkstationsRepositories(ApiBaseSync):
+    """Dev workstations repositories API."""
+
+    @property
+    def with_raw_response(self) -> DevWorkstationsRepositoriesWithRawResponse:
+        """These methods, returning an :class:`APIResponse` with the status and headers."""
+        return DevWorkstationsRepositoriesWithRawResponse(self)
+
+    def list_dev_workstation_repositories(
+        self,
+        id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> list[WorkstationRepositoryResponse]:
+        """`GET /api/dev/workstations/{id}/repositories`."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/dev/workstations/{id}/repositories",
+                path_params={
+                    "id": encode_path_param("id", id, "simple", False),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, list[WorkstationRepositoryResponse])
+
+    def create_dev_workstation_repository(
+        self,
+        id: UUID,
+        *,
+        url: str,
+        provider: str | None | Unset = UNSET,
+        repo_ref: str | None | Unset = UNSET,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> AddWorkstationRepositoryResponse:
+        """`POST /api/dev/workstations/{id}/repositories`.
+
+        :param provider: SCM provider: `github`, `gitlab` or `forgejo`. Must match the workstation's primary provider — the in-pod git credential helper is host-blind, so a single token has to work for every repository. With `gitlab` that means the same instance too, self-managed or not.
+        :param repo_ref: Branch/tag to check out. Defaults to `main`.
+        :param url: http(s) clone URL."""
+        response = self._request(
+            ApiRequest(
+                method="post",
+                path="/api/dev/workstations/{id}/repositories",
+                path_params={
+                    "id": encode_path_param("id", id, "simple", False),
+                },
+                json_body=to_json_value(
+                    WorkstationRepositoryInput(
+                        provider=provider,
+                        repo_ref=repo_ref,
+                        url=url,
+                    ),
+                    WorkstationRepositoryInput,
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, AddWorkstationRepositoryResponse)
+
+    def delete_dev_workstation_repository(
+        self,
+        id: UUID,
+        repo_id: UUID,
+        *,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> None:
+        """`DELETE /api/dev/workstations/{id}/repositories/{repo_id}`."""
+        self._request(
+            ApiRequest(
+                method="delete",
+                path="/api/dev/workstations/{id}/repositories/{repo_id}",
+                path_params={
+                    "id": encode_path_param("id", id, "simple", False),
+                    "repo_id": encode_path_param("repo_id", repo_id, "simple", False),
+                },
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+
+
+class DevWorkstationsRepositoriesWithRawResponse:
+    """The methods of :class:`DevWorkstationsRepositories`, returning an :class:`APIResponse`."""
+
+    def __init__(self, resource: DevWorkstationsRepositories) -> None:
+        self.list_dev_workstation_repositories = to_raw_response_wrapper(
+            resource.list_dev_workstation_repositories
+        )
+        self.create_dev_workstation_repository = to_raw_response_wrapper(
+            resource.create_dev_workstation_repository
+        )
+        self.delete_dev_workstation_repository = to_raw_response_wrapper(
+            resource.delete_dev_workstation_repository
+        )