unikraft-cloud-plugin-sandbox-api 1.1.0__tar.gz

unikraft_cloud_plugin_sandbox_api-1.1.0/LICENSE.md

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Unikraft GmbH.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

unikraft_cloud_plugin_sandbox_api-1.1.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: unikraft-cloud-plugin-sandbox-api
+Version: 1.1.0
+Summary: Generated Python client for the Unikraft Cloud `sandbox` plugin API
+Keywords: unikraft,unikraft-cloud,plugin,sandbox,sdk
+Author: Unikraft GmbH
+License-Expression: BSD-3-Clause
+License-File: LICENSE.md
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: pydantic>=2.7
+Requires-Dist: typing-extensions>=4.4
+Requires-Python: >=3.10
+Project-URL: Homepage, https://unikraft.com
+Project-URL: Repository, https://github.com/unikraft-cloud/plugins
+Description-Content-Type: text/markdown
+
+# unikraft-cloud-plugin-sandbox-api
+
+The generated client for the Unikraft Cloud `sandbox` plugin API.
+openapi-gen generates it from the plugin's OpenAPI specification, so **do not
+edit it by hand**.
+
+This package is the raw ("plumbing") layer. Each method carries the name of its
+`operationId` and returns the response envelope exactly as the specification
+describes it. If you want the idiomatic layer, use
+[`unikraft-cloud`](https://pypi.org/project/unikraft-cloud/), which wraps this
+package and resolves the instance for you.
+
+## Install
+
+```sh
+pip install unikraft-cloud-plugin-sandbox-api
+```
+
+The package depends on pydantic and typing_extensions only. Each generated
+class takes a `Transport`,
+an object with `request()`, `request_no_content()`, `request_bytes()` and
+`stream()`. The `ApiClient` of `unikraft-cloud`
+0.2.0 or later is one. If you want to use it as the transport, install
+the SDK.
+
+## Usage
+
+The plugin runs inside a single instance and answers on that instance's plugin
+route, so `base_url` is the full plugin endpoint rather than a metro root.
+
+```python
+import os
+
+from unikraft_cloud.core.http import ApiClient, ApiClientConfig
+from unikraft_cloud_plugin_sandbox_api import SandboxPluginApi
+
+uuid = "..."  # The instance the plugin is attached to.
+api = SandboxPluginApi(
+    ApiClient(
+        ApiClientConfig(
+            base_url=f"https://api.fra.unikraft.cloud/v1/instances/{uuid}/plugins/sandbox",
+            token=os.environ["UKC_TOKEN"],
+        )
+    )
+)
+```
+
+The last path segment is whatever name the plugin was attached under in the
+instance's `plugins` array, so it is not necessarily `sandbox`. To let the
+SDK build that URL for you, use `unikraft-cloud` instead.
+
+## Exports
+
+Everything below is importable from `unikraft_cloud_plugin_sandbox_api`.
+
+| Name | Carries |
+| --- | --- |
+| `SandboxPluginApi` | Every resource of the plugin behind one transport |
+| `CommandsApi` | The `commands` resource |
+| `FsApi` | The `fs` resource |
+| `models` | The wire models, an alias of `unikraft_cloud_plugin_sandbox_api.models_gen` |
+| `PLUGIN_NAME` | `"sandbox"`, the name the plugin is attached under unless the instance's creator chose another |
+| `Transport`, `RawResponse` | The protocols a transport and a raw-bytes response satisfy |
+| `CallOptions` | The options every method takes as `**options`: `headers`, `base_url` and `timeout` |
+| `QueryValue` | What a query parameter may hold |
+| `VERSION`, `SDK_MIN` | This package's version, and the oldest `unikraft-cloud` whose `ApiClient` is a transport for it |
+| `SPEC_HASH`, `TEMPLATES_HASH`, `CONFIG_HASH` | SHA-256 fingerprints of the specification, the templates and the configuration this package was built from |
+
+A `CallOptions` key that is absent leaves the transport's default in place, so
+`timeout=None` lifts the timeout for one call and no `timeout` at all keeps the
+client's.
+
+`SandboxPluginApi` groups one client per resource:
+
+- `api.commands`: the `commands` resource
+- `api.fs`: the `fs` resource

unikraft_cloud_plugin_sandbox_api-1.1.0/README.md

@@ -0,0 +1,76 @@
+# unikraft-cloud-plugin-sandbox-api
+
+The generated client for the Unikraft Cloud `sandbox` plugin API.
+openapi-gen generates it from the plugin's OpenAPI specification, so **do not
+edit it by hand**.
+
+This package is the raw ("plumbing") layer. Each method carries the name of its
+`operationId` and returns the response envelope exactly as the specification
+describes it. If you want the idiomatic layer, use
+[`unikraft-cloud`](https://pypi.org/project/unikraft-cloud/), which wraps this
+package and resolves the instance for you.
+
+## Install
+
+```sh
+pip install unikraft-cloud-plugin-sandbox-api
+```
+
+The package depends on pydantic and typing_extensions only. Each generated
+class takes a `Transport`,
+an object with `request()`, `request_no_content()`, `request_bytes()` and
+`stream()`. The `ApiClient` of `unikraft-cloud`
+0.2.0 or later is one. If you want to use it as the transport, install
+the SDK.
+
+## Usage
+
+The plugin runs inside a single instance and answers on that instance's plugin
+route, so `base_url` is the full plugin endpoint rather than a metro root.
+
+```python
+import os
+
+from unikraft_cloud.core.http import ApiClient, ApiClientConfig
+from unikraft_cloud_plugin_sandbox_api import SandboxPluginApi
+
+uuid = "..."  # The instance the plugin is attached to.
+api = SandboxPluginApi(
+    ApiClient(
+        ApiClientConfig(
+            base_url=f"https://api.fra.unikraft.cloud/v1/instances/{uuid}/plugins/sandbox",
+            token=os.environ["UKC_TOKEN"],
+        )
+    )
+)
+```
+
+The last path segment is whatever name the plugin was attached under in the
+instance's `plugins` array, so it is not necessarily `sandbox`. To let the
+SDK build that URL for you, use `unikraft-cloud` instead.
+
+## Exports
+
+Everything below is importable from `unikraft_cloud_plugin_sandbox_api`.
+
+| Name | Carries |
+| --- | --- |
+| `SandboxPluginApi` | Every resource of the plugin behind one transport |
+| `CommandsApi` | The `commands` resource |
+| `FsApi` | The `fs` resource |
+| `models` | The wire models, an alias of `unikraft_cloud_plugin_sandbox_api.models_gen` |
+| `PLUGIN_NAME` | `"sandbox"`, the name the plugin is attached under unless the instance's creator chose another |
+| `Transport`, `RawResponse` | The protocols a transport and a raw-bytes response satisfy |
+| `CallOptions` | The options every method takes as `**options`: `headers`, `base_url` and `timeout` |
+| `QueryValue` | What a query parameter may hold |
+| `VERSION`, `SDK_MIN` | This package's version, and the oldest `unikraft-cloud` whose `ApiClient` is a transport for it |
+| `SPEC_HASH`, `TEMPLATES_HASH`, `CONFIG_HASH` | SHA-256 fingerprints of the specification, the templates and the configuration this package was built from |
+
+A `CallOptions` key that is absent leaves the transport's default in place, so
+`timeout=None` lifts the timeout for one call and no `timeout` at all keeps the
+client's.
+
+`SandboxPluginApi` groups one client per resource:
+
+- `api.commands`: the `commands` resource
+- `api.fs`: the `fs` resource

unikraft_cloud_plugin_sandbox_api-1.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "unikraft-cloud-plugin-sandbox-api"
+version = "1.1.0"
+description = "Generated Python client for the Unikraft Cloud `sandbox` plugin API"
+readme = "README.md"
+license = "BSD-3-Clause"
+license-files = ["LICENSE.md"]
+authors = [{ name = "Unikraft GmbH" }]
+requires-python = ">=3.10"
+keywords = ["unikraft", "unikraft-cloud", "plugin", "sandbox", "sdk"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Typing :: Typed",
+]
+# The wire models are pydantic; the transport is whatever the caller passes.
+# Unpack on **options needs typing_extensions below Python 3.12.
+dependencies = [
+  "pydantic>=2.7",
+  "typing_extensions>=4.4",
+]
+
+[project.urls]
+Homepage = "https://unikraft.com"
+Repository = "https://github.com/unikraft-cloud/plugins"
+
+[build-system]
+requires = ["uv_build>=0.8.0,<0.9.0"]
+build-backend = "uv_build"

unikraft_cloud_plugin_sandbox_api-1.1.0/src/unikraft_cloud_plugin_sandbox_api/__init__.py

@@ -0,0 +1,85 @@
+# Code generated by openapi-gen; DO NOT EDIT.
+#
+# The `sandbox` plugin API's "plumbing" layer: the generated clients, plus
+# a container that groups them behind one transport. Everything here returns
+# the response envelope exactly as the OpenAPI specification describes it, or,
+# for an operation that answers with raw bytes, the payload untouched.
+
+from __future__ import annotations
+
+from . import models_gen as models
+from ._meta import CONFIG_HASH, SDK_MIN, SPEC_HASH, TEMPLATES_HASH, VERSION
+from .commands_gen import CommandsApi
+from .fs_gen import FsApi
+from .transport import CallOptions, QueryValue, RawResponse, Transport
+
+__all__ = [
+    "CONFIG_HASH",
+    "PLUGIN_NAME",
+    "SDK_MIN",
+    "SPEC_HASH",
+    "TEMPLATES_HASH",
+    "VERSION",
+    "CommandsApi",
+    "FsApi",
+    "CallOptions",
+    "QueryValue",
+    "RawResponse",
+    "SandboxPluginApi",
+    "Transport",
+    "models",
+]
+
+__version__ = VERSION
+
+#: The name the plugin is attached to an instance under, unless the instance's
+#: creator chose another, and hence the ``<name>`` in its route.
+PLUGIN_NAME = "sandbox"
+
+#: What a transport must offer, for the error that names a missing one.
+_TRANSPORT_METHODS = ("request", "request_no_content", "request_bytes", "stream")
+
+
+class SandboxPluginApi:
+    """Every `sandbox` plugin API resource, raw, behind one transport.
+
+    The idiomatic layer in ``unikraft_cloud`` derives the plugin's route from an
+    instance. Use this class only when you want the raw envelopes against a
+    route you already have.
+
+    .. code-block:: python
+
+        import os
+
+        from unikraft_cloud.core.http import ApiClient, ApiClientConfig
+        from unikraft_cloud_plugin_sandbox_api import SandboxPluginApi
+
+        uuid = "..."  # The instance the plugin is attached to.
+        api = SandboxPluginApi(
+            ApiClient(
+                ApiClientConfig(
+                    base_url=f"https://api.fra.unikraft.cloud/v1/instances/{uuid}/plugins/sandbox",
+                    token=os.environ["UKC_TOKEN"],
+                )
+            )
+        )
+    """
+
+    def __init__(self, transport: Transport) -> None:
+        missing = [
+            name
+            for name in _TRANSPORT_METHODS
+            if not callable(getattr(transport, name, None))
+        ]
+        if missing:
+            raise TypeError(
+                f"The transport has no {missing[0]}() method. Pass an ApiClient from "
+                "unikraft_cloud.core.http, or an object with "
+                f"{', '.join(_TRANSPORT_METHODS)}."
+            )
+        #: The transport every request goes through.
+        self.transport = transport
+        #: The `commands` resource of this plugin.
+        self.commands = CommandsApi(transport)
+        #: The `fs` resource of this plugin.
+        self.fs = FsApi(transport)

unikraft_cloud_plugin_sandbox_api-1.1.0/src/unikraft_cloud_plugin_sandbox_api/_meta.py

@@ -0,0 +1,20 @@
+# Code generated by openapi-gen; DO NOT EDIT.
+#
+# What this package was built from. The version is what it was published as;
+# the hashes fingerprint the sources that decided its contents, so a publish
+# can tell a rebuild of the same sources from a change under the same version.
+
+#: The version this package was published as.
+VERSION = "1.1.0"
+
+#: The oldest unikraft-cloud SDK whose ApiClient is a transport for this package.
+SDK_MIN = "0.2.0"
+
+#: SHA-256 of the OpenAPI specification.
+SPEC_HASH = "fe2a902ae04c2934eb14f7e7db0f5e75f9598471532986f01a939229d38b06d4"
+
+#: SHA-256 over the generator's templates and static files.
+TEMPLATES_HASH = "5efe373fc719c482bc42cc6ff89c27852a6bfef78c9e6d841a1f21eab2f97859"
+
+#: SHA-256 over the generation configuration: the SDK floor and the generator.
+CONFIG_HASH = "c8175452866bb01b92844bc4e537c4a05aef77ff778e937ce989a45ea7fefc6e"

unikraft_cloud_plugin_sandbox_api-1.1.0/src/unikraft_cloud_plugin_sandbox_api/commands_gen.py

@@ -0,0 +1,183 @@
+# Code generated by openapi-gen; DO NOT EDIT.
+
+from __future__ import annotations
+
+from typing_extensions import Unpack
+from urllib.parse import quote
+
+from . import models_gen as models
+from .transport import CallOptions, RawResponse, Transport
+
+
+class CommandsApi:
+    """Low-level "plumbing" client for the `commands` resource.
+
+    Methods mirror the OpenAPI specification and return the raw response
+    envelope. The idiomatic clients are built on top of this.
+    """
+
+    def __init__(self, transport: Transport) -> None:
+        #: The transport every request of this resource goes through.
+        self.transport = transport
+
+    async def delete_command_by_uuid(
+        self,
+        uuid: str,
+        **options: Unpack[CallOptions],
+    ) -> models.EmptyResponse:
+        """Delete Command by UUID"""
+        return await self.transport.request(
+            models.EmptyResponse,
+            method="DELETE",
+            path=f"/commands/{quote(uuid, safe='')}",
+            **options,
+        )
+
+    async def delete_command_logs_by_uuid(
+        self,
+        uuid: str,
+        **options: Unpack[CallOptions],
+    ) -> models.EmptyResponse:
+        """Delete Command Logs"""
+        return await self.transport.request(
+            models.EmptyResponse,
+            method="DELETE",
+            path=f"/commands/{quote(uuid, safe='')}/logs",
+            **options,
+        )
+
+    async def get_command_by_uuid(
+        self,
+        uuid: str,
+        **options: Unpack[CallOptions],
+    ) -> models.GetCommandResponse:
+        """Get Command by UUID"""
+        return await self.transport.request(
+            models.GetCommandResponse,
+            method="GET",
+            path=f"/commands/{quote(uuid, safe='')}",
+            **options,
+        )
+
+    async def get_command_logs(
+        self,
+        uuid: str,
+        *,
+        body: models.CommandLogsRequest | None = None,
+        **options: Unpack[CallOptions],
+    ) -> models.CommandLogsResponse:
+        """Get Command Logs"""
+        return await self.transport.request(
+            models.CommandLogsResponse,
+            method="GET",
+            path=f"/commands/{quote(uuid, safe='')}/logs",
+            body=body,
+            **options,
+        )
+
+    async def get_raw_command_log(
+        self,
+        uuid: str,
+        stream: models.CommandLogStream,
+        *,
+        range: str | None = None,
+        **options: Unpack[CallOptions],
+    ) -> RawResponse:
+        """Get Raw Command Log"""
+        request_headers: dict[str, str] = dict(options.get("headers") or {})
+        if range is not None:
+            request_headers["Range"] = range
+        options["headers"] = request_headers
+        return await self.transport.request_bytes(
+            method="GET",
+            path=f"/commands/{quote(uuid, safe='')}/logs/raw/{quote(stream, safe='')}",
+            **options,
+        )
+
+    async def list_commands(
+        self,
+        **options: Unpack[CallOptions],
+    ) -> models.ListCommandsResponse:
+        """List Commands"""
+        return await self.transport.request(
+            models.ListCommandsResponse,
+            method="GET",
+            path="/commands",
+            **options,
+        )
+
+    async def run_command(
+        self,
+        *,
+        body: models.RunCommandRequest,
+        **options: Unpack[CallOptions],
+    ) -> models.RunCommandResponse:
+        """Start Command"""
+        return await self.transport.request(
+            models.RunCommandResponse,
+            method="POST",
+            path="/commands",
+            body=body,
+            **options,
+        )
+
+    async def signal_command(
+        self,
+        uuid: str,
+        *,
+        body: models.CommandSignalRequest,
+        **options: Unpack[CallOptions],
+    ) -> models.EmptyResponse:
+        """Signal Command"""
+        return await self.transport.request(
+            models.EmptyResponse,
+            method="POST",
+            path=f"/commands/{quote(uuid, safe='')}/signal",
+            body=body,
+            **options,
+        )
+
+    async def wait_for_command(
+        self,
+        uuid: str,
+        **options: Unpack[CallOptions],
+    ) -> models.EmptyResponse:
+        """Wait for Command"""
+        return await self.transport.request(
+            models.EmptyResponse,
+            method="POST",
+            path=f"/commands/{quote(uuid, safe='')}/wait",
+            **options,
+        )
+
+    async def wait_for_command_with_timeout(
+        self,
+        uuid: str,
+        *,
+        body: models.CommandWaitTimeoutRequest,
+        **options: Unpack[CallOptions],
+    ) -> models.EmptyResponse:
+        """Wait for Command with Timeout"""
+        return await self.transport.request(
+            models.EmptyResponse,
+            method="POST",
+            path=f"/commands/{quote(uuid, safe='')}/wait_timeout",
+            body=body,
+            **options,
+        )
+
+    async def write_command_stdin(
+        self,
+        uuid: str,
+        *,
+        body: models.CommandStdinRequest,
+        **options: Unpack[CallOptions],
+    ) -> models.EmptyResponse:
+        """Write Command Stdin"""
+        return await self.transport.request(
+            models.EmptyResponse,
+            method="POST",
+            path=f"/commands/{quote(uuid, safe='')}/stdin",
+            body=body,
+            **options,
+        )

unikraft_cloud_plugin_sandbox_api-1.1.0/src/unikraft_cloud_plugin_sandbox_api/fs_gen.py

@@ -0,0 +1,94 @@
+# Code generated by openapi-gen; DO NOT EDIT.
+
+from __future__ import annotations
+
+from typing_extensions import Unpack
+
+from . import models_gen as models
+from .transport import CallOptions, RawResponse, Transport
+
+
+class FsApi:
+    """Low-level "plumbing" client for the `fs` resource.
+
+    Methods mirror the OpenAPI specification and return the raw response
+    envelope. The idiomatic clients are built on top of this.
+    """
+
+    def __init__(self, transport: Transport) -> None:
+        #: The transport every request of this resource goes through.
+        self.transport = transport
+
+    async def create_directory(
+        self,
+        *,
+        body: models.MkdirRequest,
+        **options: Unpack[CallOptions],
+    ) -> models.EmptyResponse:
+        """Create Directory"""
+        return await self.transport.request(
+            models.EmptyResponse,
+            method="POST",
+            path="/fs/mkdir",
+            body=body,
+            **options,
+        )
+
+    async def read_file(
+        self,
+        *,
+        body: models.ReadFileRequest,
+        **options: Unpack[CallOptions],
+    ) -> models.ReadFileResponse:
+        """Read File"""
+        return await self.transport.request(
+            models.ReadFileResponse,
+            method="POST",
+            path="/fs/read",
+            body=body,
+            **options,
+        )
+
+    async def read_raw_file(
+        self,
+        *,
+        body: models.ReadFileRequest,
+        **options: Unpack[CallOptions],
+    ) -> RawResponse:
+        """Read Raw File"""
+        return await self.transport.request_bytes(
+            method="POST",
+            path="/fs/read_raw",
+            body=body,
+            **options,
+        )
+
+    async def upload_file(
+        self,
+        *,
+        body: models.UploadFileRequest,
+        **options: Unpack[CallOptions],
+    ) -> models.EmptyResponse:
+        """Upload File"""
+        return await self.transport.request(
+            models.EmptyResponse,
+            method="POST",
+            path="/fs/upload",
+            body=body,
+            **options,
+        )
+
+    async def write_file(
+        self,
+        *,
+        body: models.WriteFileRequest,
+        **options: Unpack[CallOptions],
+    ) -> models.EmptyResponse:
+        """Write File"""
+        return await self.transport.request(
+            models.EmptyResponse,
+            method="POST",
+            path="/fs/write",
+            body=body,
+            **options,
+        )

unikraft_cloud_plugin_sandbox_api-1.1.0/src/unikraft_cloud_plugin_sandbox_api/models_gen.py

@@ -0,0 +1,473 @@
+# Code generated by openapi-gen; DO NOT EDIT.
+#
+# Type definitions for a Unikraft Cloud plugin API, generated from its OpenAPI
+# specification. These mirror the wire format exactly.
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict
+
+# Enumerations, as Literal aliases rather than enum classes: the values stay
+# plain strings, so `state == "running"` needs no import, and a value the server
+# adds is one line to widen.
+
+
+CommandLogStream = Literal["stdout", "stderr"]
+"""The output stream to read raw bytes from."""
+
+FileEncoding = Literal["utf-8", "base64"]
+"""The encoding of the data written to a file."""
+
+ResponseStatus = Literal["success", "error", "partial_success"]
+"""The response status of an API request."""
+
+
+class CommandLogsData(BaseModel):
+    """The collected output of a command."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # Every field is optional: one response shape serves several requests, and a
+    # summary listing or a failed bulk item carries only some of them.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    stdout: str | None = None
+    """The requested part of the standard output stream, base64-encoded."""
+    stderr: str | None = None
+    """The requested part of the standard error stream, base64-encoded."""
+    stdout_available: int | None = None
+    """The total number of bytes available in the standard output stream."""
+    stderr_available: int | None = None
+    """The total number of bytes available in the standard error stream."""
+
+
+class CommandLogsRange(BaseModel):
+    """The byte range of a single output stream to return."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # A field the specification requires is required here too, so a request
+    # missing one fails at construction rather than at the server.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    offset: int
+    """The first byte of the stream to return."""
+    limit: int | None = None
+    """
+    The maximum number of bytes to return. When omitted, everything from
+    `offset` to the end of the stream is returned.
+    """
+
+
+class CommandLogsRequest(BaseModel):
+    """
+    The (optional) request body limiting which parts of the output streams are
+    returned. When omitted, both streams are returned in their entirety.
+    """
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # A field the specification requires is required here too, so a request
+    # missing one fails at construction rather than at the server.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    stdout: CommandLogsRange
+    """The part of the standard output stream to return."""
+    stderr: CommandLogsRange
+    """The part of the standard error stream to return."""
+
+
+class CommandLogsResponse(BaseModel):
+    """
+    The response to fetching the output of a command. `404` is returned, with an
+    empty body, when no command with the given UUID exists. `410` is returned,
+    with an
+    empty body, if the command's logs have been deleted.
+    """
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # Every field is optional: one response shape serves several requests, and a
+    # summary listing or a failed bulk item carries only some of them.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    status: ResponseStatus | None = None
+    """The status of the response."""
+    message: str | None = None
+    """An optional message providing additional information about the status."""
+    data: CommandLogsData | None = None
+    """The response data for this request."""
+    errors: list[ResponseError] | None = None
+    """A list of errors which may have occurred during the request."""
+    op_time_us: int | None = None
+    """The operation time in microseconds."""
+
+
+class CommandSignalRequest(BaseModel):
+    """The request to send a signal to a command."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # A field the specification requires is required here too, so a request
+    # missing one fails at construction rather than at the server.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    signal: int | str
+    """
+    The signal to send, either as a number or as a name, with or without the
+    `SIG` prefix, e.g. `15`, `TERM` or `SIGTERM`.
+    """
+
+
+class CommandStdinRequest(BaseModel):
+    """The request to feed data into a command's standard input."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # A field the specification requires is required here too, so a request
+    # missing one fails at construction rather than at the server.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    data: str
+    """The bytes to feed into standard input, base64-encoded."""
+    eof: bool | None = None
+    """Whether to close standard input after injecting `data`."""
+
+
+class CommandWaitTimeoutRequest(BaseModel):
+    """The request to wait for a command to finish, up to a timeout."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # A field the specification requires is required here too, so a request
+    # missing one fails at construction rather than at the server.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    timeout_s: float
+    """The maximum time to wait, in seconds. Decimals are accepted."""
+
+
+class EmptyResponse(BaseModel):
+    """
+    A response which carries no data of its own. `data` is `null`; the outcome
+    of
+    the request is the HTTP status code.
+    """
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # Every field is optional: one response shape serves several requests, and a
+    # summary listing or a failed bulk item carries only some of them.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    status: ResponseStatus | None = None
+    """The status of the response."""
+    message: str | None = None
+    """An optional message providing additional information about the status."""
+    data: Any | None = None
+    """The response data for this request."""
+    errors: list[ResponseError] | None = None
+    """A list of errors which may have occurred during the request."""
+    op_time_us: int | None = None
+    """The operation time in microseconds."""
+
+
+class GetCommandData(BaseModel):
+    """The state of a single command."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # Every field is optional: one response shape serves several requests, and a
+    # summary listing or a failed bulk item carries only some of them.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    uuid: str | None = None
+    """The UUID of the command."""
+    cmdline: CommandLineShell | CommandLineArgs | None = None
+    """
+    The command the command was started with, in the form it was supplied in:
+    a shell command line, or an argument vector.
+    """
+    cwd: str | None = None
+    """The current working directory, if supplied at startup, else null"""
+    env: dict[str, str] | None = None
+    """Environment variables, if supplied at startup, else null"""
+    exitcode: int | None = None
+    """
+    The exit code of the command. It is `null` while the command is still
+    running.
+    """
+
+
+class GetCommandResponse(BaseModel):
+    """
+    The response to inspecting a command. `404` is returned, with an empty body,
+    when no command with the given UUID exists.
+    """
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # Every field is optional: one response shape serves several requests, and a
+    # summary listing or a failed bulk item carries only some of them.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    status: ResponseStatus | None = None
+    """The status of the response."""
+    message: str | None = None
+    """An optional message providing additional information about the status."""
+    data: GetCommandData | None = None
+    """The response data for this request."""
+    errors: list[ResponseError] | None = None
+    """A list of errors which may have occurred during the request."""
+    op_time_us: int | None = None
+    """The operation time in microseconds."""
+
+
+class ListCommandsData(BaseModel):
+    """The known commands."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # Every field is optional: one response shape serves several requests, and a
+    # summary listing or a failed bulk item carries only some of them.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    commands: list[str] | None = None
+    """The UUIDs of all known commands, in the order they were started."""
+
+
+class ListCommandsResponse(BaseModel):
+    """The response to listing the commands known to the sandbox."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # Every field is optional: one response shape serves several requests, and a
+    # summary listing or a failed bulk item carries only some of them.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    status: ResponseStatus | None = None
+    """The status of the response."""
+    message: str | None = None
+    """An optional message providing additional information about the status."""
+    data: ListCommandsData | None = None
+    """The response data for this request."""
+    errors: list[ResponseError] | None = None
+    """A list of errors which may have occurred during the request."""
+    op_time_us: int | None = None
+    """The operation time in microseconds."""
+
+
+class MkdirRequest(BaseModel):
+    """The request to create a directory in the sandbox filesystem."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # A field the specification requires is required here too, so a request
+    # missing one fails at construction rather than at the server.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    path: str
+    """The absolute path of the directory to create."""
+    parents: bool
+    """Whether to create missing parent directories."""
+
+
+class ReadFileData(BaseModel):
+    """The contents of a file."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # Every field is optional: one response shape serves several requests, and a
+    # summary listing or a failed bulk item carries only some of them.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    contents: str | None = None
+    """The contents of the file, base64-encoded."""
+
+
+class ReadFileRequest(BaseModel):
+    """The request to read a file from the sandbox filesystem."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # A field the specification requires is required here too, so a request
+    # missing one fails at construction rather than at the server.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    path: str
+    """The absolute path of the file to read."""
+
+
+class ReadFileResponse(BaseModel):
+    """
+    The response to reading a file. `500` is returned when the file could not be
+    read.
+    """
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # Every field is optional: one response shape serves several requests, and a
+    # summary listing or a failed bulk item carries only some of them.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    status: ResponseStatus | None = None
+    """The status of the response."""
+    message: str | None = None
+    """An optional message providing additional information about the status."""
+    data: ReadFileData | None = None
+    """The response data for this request."""
+    errors: list[ResponseError] | None = None
+    """A list of errors which may have occurred during the request."""
+    op_time_us: int | None = None
+    """The operation time in microseconds."""
+
+
+class ResponseError(BaseModel):
+    """The error response message for an API request."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # Every field is optional: one response shape serves several requests, and a
+    # summary listing or a failed bulk item carries only some of them.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    status: int | None = None
+    """The HTTP status code of the error."""
+
+
+class RunCommandData(BaseModel):
+    """The identity of a newly started command."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # Every field is optional: one response shape serves several requests, and a
+    # summary listing or a failed bulk item carries only some of them.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    uuid: str | None = None
+    """The UUID assigned to the newly started command."""
+
+
+class RunCommandRequest(BaseModel):
+    """The request to start a command in the sandbox."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # A field the specification requires is required here too, so a request
+    # missing one fails at construction rather than at the server.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    cmd: CommandLineShell | CommandLineArgs
+    """
+    The command to run: a command line interpreted by the shell, or an argument
+    vector executed directly. A bare program name in a vector is looked up in
+    the `PATH` of `env`, falling back to the sandbox's own `PATH`. `400` is
+    returned if the vector is empty or the program cannot be resolved.
+    """
+    cwd: str | None = None
+    """(OPTIONAL) Current working directory"""
+    env: dict[str, str] | None = None
+    """(OPTIONAL) Environment variables"""
+
+
+class RunCommandResponse(BaseModel):
+    """
+    The response to starting a command. `500` is returned when the command could
+    not be spawned.
+    """
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # Every field is optional: one response shape serves several requests, and a
+    # summary listing or a failed bulk item carries only some of them.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    status: ResponseStatus | None = None
+    """The status of the response."""
+    message: str | None = None
+    """An optional message providing additional information about the status."""
+    data: RunCommandData | None = None
+    """The response data for this request."""
+    errors: list[ResponseError] | None = None
+    """A list of errors which may have occurred during the request."""
+    op_time_us: int | None = None
+    """The operation time in microseconds."""
+
+
+class UploadFileRequest(BaseModel):
+    """The request to upload a file to the sandbox filesystem."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # A field the specification requires is required here too, so a request
+    # missing one fails at construction rather than at the server.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    path: str
+    """Path where to upload the file."""
+    filename: str
+    """Name of uploaded file; will be used if `path` is a directory."""
+    parents: bool
+    """Whether to create parent directories of `path`."""
+    encoding: FileEncoding
+    """The encoding of `data`."""
+    data: str
+    """The data to write, in the given encoding"""
+
+
+class WriteFileRequest(BaseModel):
+    """The request to write a file in the sandbox filesystem."""
+
+    # Fields the specification does not describe are kept rather than dropped,
+    # so a newly added one survives a round trip and does not break this client.
+    # A field the specification requires is required here too, so a request
+    # missing one fails at construction rather than at the server.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    path: str
+    """The absolute path of the file to write. It is created if missing."""
+    append: bool
+    """Whether to append to the file instead of truncating it."""
+    encoding: FileEncoding
+    """The encoding of `data`."""
+    data: str
+    """The data to write, in the given encoding."""
+
+
+CommandLineArgs = list[str]
+"""The command as an argument vector, executed directly without a shell."""
+
+CommandLineShell = str
+"""The command line, interpreted by the shell."""
+
+
+# Annotations are deferred, so a model may name one defined further down. This
+# resolves them all now: a reference that cannot be resolved becomes an error on
+# import rather than a surprise at the first request.
+for _model in (
+    CommandLogsData,
+    CommandLogsRange,
+    CommandLogsRequest,
+    CommandLogsResponse,
+    CommandSignalRequest,
+    CommandStdinRequest,
+    CommandWaitTimeoutRequest,
+    EmptyResponse,
+    GetCommandData,
+    GetCommandResponse,
+    ListCommandsData,
+    ListCommandsResponse,
+    MkdirRequest,
+    ReadFileData,
+    ReadFileRequest,
+    ReadFileResponse,
+    ResponseError,
+    RunCommandData,
+    RunCommandRequest,
+    RunCommandResponse,
+    UploadFileRequest,
+    WriteFileRequest,
+):
+    _model.model_rebuild()

unikraft_cloud_plugin_sandbox_api-1.1.0/src/unikraft_cloud_plugin_sandbox_api/transport.py

@@ -0,0 +1,125 @@
+# Code generated by openapi-gen; DO NOT EDIT.
+#
+# The contract between this package and the transport that carries its
+# requests. `ApiClient` in `unikraft_cloud.core.http` satisfies it, and so does
+# any object with these four methods, because the types are protocols. This
+# module imports no SDK, so the package depends on none.
+#
+# This is the only copy of the contract. The SDK's `ApiClient` satisfies it by
+# shape, which the SDK's own type check confirms wherever it hands one over.
+# Widening is safe: a new optional parameter, a wider input type. A rename, a
+# new required parameter, or a changed return type must reach `ApiClient` in
+# the SDK as well, and every plugin package must be republished.
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Mapping, Sequence
+from typing import Any, Protocol, TypedDict, TypeVar
+
+from typing_extensions import Unpack
+
+__all__ = ["CallOptions", "QueryValue", "RawResponse", "Transport"]
+
+T = TypeVar("T")
+
+#: A value that can be serialised into a query string.
+QueryValue = str | int | float | bool | Sequence[str | int | float | bool] | None
+
+
+class CallOptions(TypedDict, total=False):
+    """What a caller may set on one call, over the transport's own defaults.
+
+    A key that is absent leaves the transport's default in place, so
+    ``timeout=None`` lifts the timeout for one call and no ``timeout`` at all
+    keeps the client's. A generated method passes these through untouched.
+    """
+
+    #: Extra headers, merged over the transport's defaults for this call.
+    headers: Mapping[str, str] | None
+    #: The base URL to send this call to, e.g. another metro.
+    base_url: str | None
+    #: Seconds to wait for this call, or ``None`` to wait without limit.
+    timeout: float | None
+
+
+class RawResponse(Protocol):
+    """The payload of an operation that answers with raw bytes, unenveloped.
+
+    The status and headers travel with the bytes because they carry meaning
+    of their own there: a ``206`` answers a ``Range`` request, and its
+    ``Content-Range`` header says which bytes these are.
+    """
+
+    @property
+    def content(self) -> bytes:
+        """The response body, untouched."""
+        ...
+
+    @property
+    def status(self) -> int:
+        """The HTTP status code."""
+        ...
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        """The response headers, case-insensitive."""
+        ...
+
+
+class Transport(Protocol):
+    """What a generated class needs from the SDK: one method per response shape.
+
+    Every method takes the request as keyword arguments, applies the
+    :class:`CallOptions` it is given over its own defaults, and raises the
+    SDK's error on a failure.
+    """
+
+    async def request(
+        self,
+        model: type[T],
+        *,
+        method: str,
+        path: str,
+        query: Mapping[str, QueryValue] | None = None,
+        body: Any = None,
+        **options: Unpack[CallOptions],
+    ) -> T:
+        """Perform a request and return its response envelope parsed as ``model``."""
+        ...
+
+    async def request_no_content(
+        self,
+        *,
+        method: str,
+        path: str,
+        query: Mapping[str, QueryValue] | None = None,
+        body: Any = None,
+        **options: Unpack[CallOptions],
+    ) -> None:
+        """Perform a request whose response carries no payload worth parsing."""
+        ...
+
+    async def request_bytes(
+        self,
+        *,
+        method: str,
+        path: str,
+        query: Mapping[str, QueryValue] | None = None,
+        body: Any = None,
+        **options: Unpack[CallOptions],
+    ) -> RawResponse:
+        """Perform a request whose success response is a raw byte payload."""
+        ...
+
+    def stream(
+        self,
+        model: type[T],
+        *,
+        method: str,
+        path: str,
+        query: Mapping[str, QueryValue] | None = None,
+        body: Any = None,
+        **options: Unpack[CallOptions],
+    ) -> AsyncIterator[T]:
+        """Yield each event of a ``text/event-stream`` response, parsed as ``model``."""
+        ...