From b58f29d565a2b86530c3b64e7f13b3ea311935b1 Mon Sep 17 00:00:00 2001 From: sfroment Date: Thu, 24 Sep 2026 18:03:33 +0200 Subject: [PATCH 01/14] fix: fail closed on terminal deployment states STOPPED/SLEEPING/UNHEALTHY previously polled until wait_ready timeout; now raises SandboxDeploymentError naming the status. DEGRADED counts as ready (JS classifyServiceStatus parity). --- koyeb/sandbox/sandbox.py | 27 ++- koyeb/sandbox/test_deployment_status.py | 235 ++++++++++++++++++++++++ koyeb/sandbox/utils.py | 45 ++++- 3 files changed, 292 insertions(+), 15 deletions(-) create mode 100644 koyeb/sandbox/test_deployment_status.py diff --git a/koyeb/sandbox/sandbox.py b/koyeb/sandbox/sandbox.py index 6ed182cc..3bad7635 100644 --- a/koyeb/sandbox/sandbox.py +++ b/koyeb/sandbox/sandbox.py @@ -17,7 +17,6 @@ from koyeb.api.exceptions import ApiException, NotFoundException from koyeb.api.models.create_app import AppLifeCycle, CreateApp from koyeb.api.models.create_service import CreateService, ServiceLifeCycle -from koyeb.api.models.deployment_status import DeploymentStatus from koyeb.api.models.egress_policy import EgressPolicy from koyeb.api.models.egress_policy_mode import EgressPolicyMode from koyeb.api.models.network_policy import NetworkPolicy @@ -33,6 +32,7 @@ build_config_files, build_network_policy, build_env_vars, + classify_deployment_status, create_deployment_definition, create_docker_source, create_koyeb_sandbox_routes, @@ -800,11 +800,6 @@ def template( delete_builder=delete_builder, ) - _DEPLOYMENT_ERROR_STATUSES = { - DeploymentStatus.ERROR, - DeploymentStatus.ERRORING, - } - def _resolve_deployment_id(self) -> Optional[str]: """Resolve and cache the deployment ID for this sandbox's service.""" if self._deployment_id is not None: @@ -862,12 +857,14 @@ def _is_deployment_healthy(self) -> bool: deployment_response = clients.deployments.get_deployment(deployment_id) deployment = deployment_response.deployment status = deployment.status - if status in self._DEPLOYMENT_ERROR_STATUSES: + classification = classify_deployment_status(status) + if classification == "terminal_failure": + status_value = getattr(status, "value", status) raise SandboxDeploymentError( - f"Sandbox '{self.name}' deployment reached status {status.value}. " - f"The sandbox will not become ready." + f"Sandbox '{self.name}' deployment reached status {status_value} " + f"— it will not become ready; wake or redeploy the sandbox." ) - is_healthy = status == DeploymentStatus.HEALTHY + is_healthy = classification == "ready" # Cache sandbox URL from metadata when deployment is healthy if is_healthy and self._sandbox_url is None: metadata = deployment.metadata @@ -2053,12 +2050,14 @@ async def _async_is_deployment_healthy(self) -> bool: ) deployment = deployment_response.deployment status = deployment.status - if status in self._DEPLOYMENT_ERROR_STATUSES: + classification = classify_deployment_status(status) + if classification == "terminal_failure": + status_value = getattr(status, "value", status) raise SandboxDeploymentError( - f"Sandbox '{self.name}' deployment reached status {status.value}. " - f"The sandbox will not become ready." + f"Sandbox '{self.name}' deployment reached status {status_value} " + f"— it will not become ready; wake or redeploy the sandbox." ) - is_healthy = status == DeploymentStatus.HEALTHY + is_healthy = classification == "ready" if is_healthy and self._sandbox_url is None: metadata = deployment.metadata if metadata and metadata.sandbox: diff --git a/koyeb/sandbox/test_deployment_status.py b/koyeb/sandbox/test_deployment_status.py new file mode 100644 index 00000000..583c4672 --- /dev/null +++ b/koyeb/sandbox/test_deployment_status.py @@ -0,0 +1,235 @@ +import asyncio +import unittest +from types import SimpleNamespace +from unittest.mock import patch + +from koyeb.api.models.deployment_status import DeploymentStatus +from koyeb.api.models.service_status import ServiceStatus +from koyeb.sandbox.sandbox import AsyncSandbox, Sandbox, SandboxDeploymentError +from koyeb.sandbox.utils import ( + classify_deployment_status, + classify_service_status, +) + + +class TestClassifyServiceStatus(unittest.TestCase): + """JS SDK parity (claim.ts classifyServiceStatus): HEALTHY/DEGRADED are + usable, STARTING/RESUMING are in progress, everything else — including + unknown forward-compat values — is a terminal failure (fail closed).""" + + def test_ready(self): + self.assertEqual(classify_service_status(ServiceStatus.HEALTHY), "ready") + self.assertEqual(classify_service_status(ServiceStatus.DEGRADED), "ready") + + def test_in_progress(self): + self.assertEqual( + classify_service_status(ServiceStatus.STARTING), "in_progress" + ) + self.assertEqual( + classify_service_status(ServiceStatus.RESUMING), "in_progress" + ) + + def test_known_terminal(self): + for status in ( + ServiceStatus.UNHEALTHY, + ServiceStatus.DELETING, + ServiceStatus.DELETED, + ServiceStatus.PAUSING, + ServiceStatus.PAUSED, + ): + self.assertEqual( + classify_service_status(status), + "terminal_failure", + msg=f"{status} should be terminal_failure", + ) + + def test_unknown_value_fails_closed(self): + self.assertEqual( + classify_service_status("SOME_FUTURE_STATE"), "terminal_failure" + ) + + +class TestClassifyDeploymentStatus(unittest.TestCase): + """Deployment-level twin: pre-HEALTHY states are in progress, HEALTHY and + DEGRADED are ready, every other state — SLEEPING/STASHED included, plus + unknown values — is terminal (it will not become ready on its own).""" + + def test_ready(self): + self.assertEqual(classify_deployment_status(DeploymentStatus.HEALTHY), "ready") + self.assertEqual(classify_deployment_status(DeploymentStatus.DEGRADED), "ready") + + def test_in_progress(self): + for status in ( + DeploymentStatus.PENDING, + DeploymentStatus.PROVISIONING, + DeploymentStatus.SCHEDULED, + DeploymentStatus.ALLOCATING, + DeploymentStatus.STARTING, + ): + self.assertEqual( + classify_deployment_status(status), + "in_progress", + msg=f"{status} should be in_progress", + ) + + def test_terminal(self): + for status in ( + DeploymentStatus.CANCELING, + DeploymentStatus.CANCELED, + DeploymentStatus.STOPPING, + DeploymentStatus.STOPPED, + DeploymentStatus.UNHEALTHY, + DeploymentStatus.ERRORING, + DeploymentStatus.ERROR, + DeploymentStatus.STASHED, + DeploymentStatus.SLEEPING, + ): + self.assertEqual( + classify_deployment_status(status), + "terminal_failure", + msg=f"{status} should be terminal_failure", + ) + + def test_unknown_value_fails_closed(self): + self.assertEqual( + classify_deployment_status("SOME_FUTURE_STATE"), "terminal_failure" + ) + + +class TestSyncDeploymentHealthWiring(unittest.TestCase): + """_is_deployment_healthy must fail fast on terminal states (raise + SandboxDeploymentError naming the status) and treat DEGRADED as ready, + instead of polling non-HEALTHY states until the wait timeout.""" + + def _make_sandbox(self): + sb = Sandbox.__new__(Sandbox) + sb.name = "sb" + sb.api_token = None + sb.host = None + sb._deployment_id = "dep-1" + sb._sandbox_url = None + return sb + + @staticmethod + def _fake_clients(status): + reply = SimpleNamespace( + deployment=SimpleNamespace(status=status, metadata=None) + ) + return SimpleNamespace( + deployments=SimpleNamespace(get_deployment=lambda deployment_id: reply), + ) + + def _patch_clients(self, status): + return patch( + "koyeb.sandbox.sandbox.get_api_clients", + return_value=self._fake_clients(status), + ) + + def test_stopped_raises_naming_status(self): + sb = self._make_sandbox() + with self._patch_clients(DeploymentStatus.STOPPED): + with self.assertRaises(SandboxDeploymentError) as cm: + sb._is_deployment_healthy() + self.assertIn("STOPPED", str(cm.exception)) + self.assertIn("wake or redeploy", str(cm.exception)) + + def test_sleeping_raises_naming_status(self): + """A scale-to-zero sandbox must not hang wait_ready until timeout.""" + sb = self._make_sandbox() + with self._patch_clients(DeploymentStatus.SLEEPING): + with self.assertRaises(SandboxDeploymentError) as cm: + sb._is_deployment_healthy() + self.assertIn("SLEEPING", str(cm.exception)) + + def test_degraded_is_ready(self): + sb = self._make_sandbox() + with self._patch_clients(DeploymentStatus.DEGRADED): + self.assertTrue(sb._is_deployment_healthy()) + + def test_starting_is_still_in_progress(self): + sb = self._make_sandbox() + with self._patch_clients(DeploymentStatus.STARTING): + self.assertFalse(sb._is_deployment_healthy()) + + def test_is_healthy_propagates_terminal_error(self): + """is_healthy() on a stopped sandbox raises (self-explanatory) instead + of silently returning False after a full timeout.""" + sb = self._make_sandbox() + with self._patch_clients(DeploymentStatus.STOPPED): + with self.assertRaises(SandboxDeploymentError) as cm: + sb.is_healthy() + self.assertIn("STOPPED", str(cm.exception)) + + +class TestAsyncDeploymentHealthWiring(unittest.TestCase): + """Async twin of the fail-closed wiring.""" + + def _make_sandbox(self): + sb = AsyncSandbox.__new__(AsyncSandbox) + sb.name = "sb" + sb.api_token = None + sb.host = None + sb._deployment_id = "dep-1" + sb._sandbox_url = None + return sb + + @staticmethod + def _fake_clients(status): + class FakeDeployments: + async def get_deployment(self, deployment_id): + return SimpleNamespace( + deployment=SimpleNamespace(status=status, metadata=None) + ) + + return SimpleNamespace(deployments=FakeDeployments()) + + def _patch_clients(self, status): + return patch( + "koyeb.sandbox.utils.get_async_api_clients", + return_value=self._fake_clients(status), + ) + + def test_stopped_raises_naming_status(self): + sb = self._make_sandbox() + + async def run(): + with self._patch_clients(DeploymentStatus.STOPPED): + await sb._async_is_deployment_healthy() + + with self.assertRaises(SandboxDeploymentError) as cm: + asyncio.run(run()) + self.assertIn("STOPPED", str(cm.exception)) + self.assertIn("wake or redeploy", str(cm.exception)) + + def test_sleeping_raises(self): + sb = self._make_sandbox() + + async def run(): + with self._patch_clients(DeploymentStatus.SLEEPING): + await sb._async_is_deployment_healthy() + + with self.assertRaises(SandboxDeploymentError) as cm: + asyncio.run(run()) + self.assertIn("SLEEPING", str(cm.exception)) + + def test_degraded_is_ready(self): + sb = self._make_sandbox() + + async def run(): + with self._patch_clients(DeploymentStatus.DEGRADED): + return await sb._async_is_deployment_healthy() + + self.assertTrue(asyncio.run(run())) + + def test_starting_is_still_in_progress(self): + sb = self._make_sandbox() + + async def run(): + with self._patch_clients(DeploymentStatus.STARTING): + return await sb._async_is_deployment_healthy() + + self.assertFalse(asyncio.run(run())) + + +if __name__ == "__main__": + unittest.main() diff --git a/koyeb/sandbox/utils.py b/koyeb/sandbox/utils.py index 9bf85485..795841f6 100644 --- a/koyeb/sandbox/utils.py +++ b/koyeb/sandbox/utils.py @@ -10,7 +10,7 @@ import os import shlex from dataclasses import dataclass -from typing import Any, Dict, List, Optional, Tuple +from typing import Any, Dict, List, Literal, Optional, Tuple, Union from koyeb.api import ApiClient, Configuration from koyeb.api.api import ( @@ -31,6 +31,8 @@ from koyeb.api.models.deployment_port import DeploymentPort from koyeb.api.models.deployment_proxy_port import DeploymentProxyPort from koyeb.api.models.deployment_route import DeploymentRoute +from koyeb.api.models.deployment_status import DeploymentStatus +from koyeb.api.models.service_status import ServiceStatus from koyeb.api.models.deployment_scaling import DeploymentScaling from koyeb.api.models.deployment_scaling_target import DeploymentScalingTarget from koyeb.api.models.deployment_scaling_target_sleep_idle_delay import ( @@ -98,6 +100,47 @@ def _validate_port_protocol(protocol: str) -> str: ) from e +StatusClassification = Literal["ready", "in_progress", "terminal_failure"] + + +def classify_service_status(status: Union[ServiceStatus, str]) -> StatusClassification: + """Classify a service status for readiness, failing closed. + + HEALTHY and DEGRADED are usable, STARTING and RESUMING are still in + progress, and every other state — including unknown forward-compat + values — is a terminal failure. Mirrors the JS SDK's + classifyServiceStatus (src/claim.ts). + """ + if status in (ServiceStatus.HEALTHY, ServiceStatus.DEGRADED): + return "ready" + if status in (ServiceStatus.STARTING, ServiceStatus.RESUMING): + return "in_progress" + return "terminal_failure" + + +def classify_deployment_status( + status: Union[DeploymentStatus, str], +) -> StatusClassification: + """Classify a deployment status for readiness, failing closed. + + HEALTHY and DEGRADED are ready, the pre-ready states (PENDING, + PROVISIONING, SCHEDULED, ALLOCATING, STARTING) are in progress, and every + other state — including SLEEPING, STASHED, and unknown forward-compat + values — is terminal: it will not become ready on its own during a wait. + """ + if status in (DeploymentStatus.HEALTHY, DeploymentStatus.DEGRADED): + return "ready" + if status in ( + DeploymentStatus.PENDING, + DeploymentStatus.PROVISIONING, + DeploymentStatus.SCHEDULED, + DeploymentStatus.ALLOCATING, + DeploymentStatus.STARTING, + ): + return "in_progress" + return "terminal_failure" + + @dataclass(frozen=True) class ApiClients: """Bundle of Koyeb API clients sharing a single underlying ApiClient.""" From f3375f43d36471ab797ffb747fec2cea46c1423b Mon Sep 17 00:00:00 2001 From: sfroment Date: Thu, 24 Sep 2026 18:05:01 +0200 Subject: [PATCH 02/14] feat: typed errors for token, port, secret gates MissingApiTokenError/InvalidPortError keep ValueError parents so published 1.5.x except-clauses still catch them. get_from_id now fails fast with NoSandboxSecretError instead of returning a handle that dies on first connected op. --- koyeb/sandbox/__init__.py | 6 ++ koyeb/sandbox/sandbox.py | 32 +++--- koyeb/sandbox/snapshot.py | 8 +- koyeb/sandbox/test_errors.py | 192 +++++++++++++++++++++++++++++++++++ koyeb/sandbox/utils.py | 46 +++++++-- 5 files changed, 259 insertions(+), 25 deletions(-) create mode 100644 koyeb/sandbox/test_errors.py diff --git a/koyeb/sandbox/__init__.py b/koyeb/sandbox/__init__.py index ed51af10..e963990e 100644 --- a/koyeb/sandbox/__init__.py +++ b/koyeb/sandbox/__init__.py @@ -22,6 +22,9 @@ from .snapshot import DeclarativeSnapshot, Snapshot, SnapshotStatus, SnapshotType from .utils import ( EgressPolicyError, + InvalidPortError, + MissingApiTokenError, + NoSandboxSecretError, SandboxDeploymentError, SandboxError, SandboxServiceError, @@ -39,6 +42,9 @@ "FileInfo", "SandboxStatus", "EgressPolicyError", + "InvalidPortError", + "MissingApiTokenError", + "NoSandboxSecretError", "SandboxDeploymentError", "SandboxError", "SandboxServiceError", diff --git a/koyeb/sandbox/sandbox.py b/koyeb/sandbox/sandbox.py index 3bad7635..a058c89d 100644 --- a/koyeb/sandbox/sandbox.py +++ b/koyeb/sandbox/sandbox.py @@ -26,6 +26,8 @@ from .utils import ( DEFAULT_INSTANCE_WAIT_TIMEOUT, DEFAULT_POLL_INTERVAL, + MissingApiTokenError, + NoSandboxSecretError, SandboxDeploymentError, SandboxError, SandboxTimeoutError, @@ -236,9 +238,7 @@ def create( if api_token is None: api_token = os.getenv("KOYEB_API_TOKEN") if not api_token: - raise ValueError( - "API token is required. Set KOYEB_API_TOKEN environment variable or pass api_token parameter" - ) + raise MissingApiTokenError() # Handle snapshot parameter (can be Snapshot object or snapshot name/ID string) actual_snapshot_id = None @@ -521,9 +521,7 @@ def get_from_id( if api_token is None: api_token = os.getenv("KOYEB_API_TOKEN") if not api_token: - raise ValueError( - "API token is required. Set KOYEB_API_TOKEN environment variable or pass api_token parameter" - ) + raise MissingApiTokenError() if not id: raise ValueError("id is required") @@ -566,6 +564,13 @@ def get_from_id( except Exception as e: logger.debug(f"Could not get deployment {deployment_id}: {e}") + if sandbox_secret is None: + raise NoSandboxSecretError( + f"Sandbox '{id}' has no SANDBOX_SECRET in its deployment " + f"definition — it may not be a Koyeb sandbox service, so the " + f"executor connection cannot be established." + ) + sandbox = cls( sandbox_id=service.id, app_id=service.app_id, @@ -1623,9 +1628,7 @@ async def get_from_id( if api_token is None: api_token = os.getenv("KOYEB_API_TOKEN") if not api_token: - raise ValueError( - "API token is required. Set KOYEB_API_TOKEN environment variable or pass api_token parameter" - ) + raise MissingApiTokenError() if not id: raise ValueError("id is required") @@ -1671,6 +1674,13 @@ async def get_from_id( except Exception as e: logger.debug(f"Could not get deployment {deployment_id}: {e}") + if sandbox_secret is None: + raise NoSandboxSecretError( + f"Sandbox '{id}' has no SANDBOX_SECRET in its deployment " + f"definition — it may not be a Koyeb sandbox service, so the " + f"executor connection cannot be established." + ) + sandbox = cls( sandbox_id=service.id, app_id=service.app_id, @@ -1798,9 +1808,7 @@ async def create( if api_token is None: api_token = os.getenv("KOYEB_API_TOKEN") if not api_token: - raise ValueError( - "API token is required. Set KOYEB_API_TOKEN environment variable or pass api_token parameter" - ) + raise MissingApiTokenError() # Handle snapshot parameter (can be Snapshot object or snapshot name/ID string) actual_snapshot_id = None diff --git a/koyeb/sandbox/snapshot.py b/koyeb/sandbox/snapshot.py index ba677e21..3330a1c6 100644 --- a/koyeb/sandbox/snapshot.py +++ b/koyeb/sandbox/snapshot.py @@ -13,7 +13,7 @@ from typing import Any, ClassVar, Dict, List, Optional, Union from .sandbox import Sandbox -from .utils import SandboxError, get_api_clients +from .utils import MissingApiTokenError, SandboxError, get_api_clients class SnapshotType(Enum): @@ -91,7 +91,7 @@ def get( if not api_token: api_token = os.getenv("KOYEB_API_TOKEN") if not api_token: - raise SandboxError( + raise MissingApiTokenError( "API token is required. Set KOYEB_API_TOKEN environment variable." ) @@ -141,7 +141,7 @@ def list( if not api_token: api_token = os.getenv("KOYEB_API_TOKEN") if not api_token: - raise SandboxError( + raise MissingApiTokenError( "API token is required. Set KOYEB_API_TOKEN environment variable." ) @@ -397,7 +397,7 @@ def __init__( if not api_token: api_token = os.getenv("KOYEB_API_TOKEN") if not api_token: - raise SandboxError( + raise MissingApiTokenError( "API token is required. Set KOYEB_API_TOKEN environment variable." ) diff --git a/koyeb/sandbox/test_errors.py b/koyeb/sandbox/test_errors.py new file mode 100644 index 00000000..4e3eab86 --- /dev/null +++ b/koyeb/sandbox/test_errors.py @@ -0,0 +1,192 @@ +import asyncio +import os +import unittest +from types import SimpleNamespace +from unittest.mock import patch + +from koyeb.sandbox.snapshot import Snapshot +from koyeb.sandbox.sandbox import AsyncSandbox, Sandbox +from koyeb.sandbox.utils import ( + InvalidPortError, + MissingApiTokenError, + NoSandboxSecretError, + SandboxError, + get_api_clients, + get_async_api_clients, + validate_port, +) + + +def _no_token_env(): + """Isolate the process env so KOYEB_API_TOKEN is unset.""" + return patch.dict(os.environ, {}, clear=True) + + +class TestErrorHierarchy(unittest.TestCase): + """Back-compat contract: token/port errors are SandboxError AND ValueError + (published 1.5.x callers except ValueError); NoSandboxSecretError is + SandboxError-only.""" + + def test_missing_api_token_error(self): + self.assertTrue(issubclass(MissingApiTokenError, SandboxError)) + self.assertTrue(issubclass(MissingApiTokenError, ValueError)) + + def test_invalid_port_error(self): + self.assertTrue(issubclass(InvalidPortError, SandboxError)) + self.assertTrue(issubclass(InvalidPortError, ValueError)) + + def test_no_sandbox_secret_error(self): + self.assertTrue(issubclass(NoSandboxSecretError, SandboxError)) + self.assertFalse(issubclass(NoSandboxSecretError, ValueError)) + + +class TestMissingApiTokenRaiseSites(unittest.TestCase): + """Every entry point raises MissingApiTokenError, not a plain ValueError.""" + + def test_get_api_clients(self): + with _no_token_env(): + with self.assertRaises(MissingApiTokenError) as cm: + get_api_clients() + self.assertIsInstance(cm.exception, ValueError) + + def test_get_async_api_clients(self): + with _no_token_env(): + with self.assertRaises(MissingApiTokenError): + get_async_api_clients() + + def test_sandbox_create(self): + with _no_token_env(): + with self.assertRaises(MissingApiTokenError): + Sandbox.create() + + def test_sandbox_get_from_id(self): + with _no_token_env(): + with self.assertRaises(MissingApiTokenError): + Sandbox.get_from_id("svc-1") + + def test_async_sandbox_create(self): + with _no_token_env(): + with self.assertRaises(MissingApiTokenError): + asyncio.run(AsyncSandbox.create()) + + def test_async_sandbox_get_from_id(self): + with _no_token_env(): + with self.assertRaises(MissingApiTokenError): + asyncio.run(AsyncSandbox.get_from_id("svc-1")) + + def test_snapshot_get(self): + with _no_token_env(): + with self.assertRaises(MissingApiTokenError) as cm: + Snapshot.get("snap-1") + self.assertIsInstance(cm.exception, SandboxError) + + +class TestInvalidPortRaiseSite(unittest.TestCase): + def test_below_range(self): + with self.assertRaises(InvalidPortError) as cm: + validate_port(0) + self.assertIsInstance(cm.exception, ValueError) + self.assertIn("0", str(cm.exception)) + + def test_above_range(self): + with self.assertRaises(InvalidPortError): + validate_port(70000) + + def test_non_integer(self): + with self.assertRaises(InvalidPortError): + validate_port("8080") + + def test_valid_port_unchanged(self): + self.assertIsNone(validate_port(8080)) + + +_FAKE_SERVICE = SimpleNamespace( + id="svc-1", + app_id="app-1", + name="sb", + active_deployment_id="dep-1", + latest_deployment_id="dep-1", +) + + +def _deployment_with_env(env): + return SimpleNamespace( + deployment=SimpleNamespace(definition=SimpleNamespace(env=env), metadata=None) + ) + + +def _fake_sync_clients(env): + return SimpleNamespace( + services=SimpleNamespace( + get_service=lambda **kw: SimpleNamespace(service=_FAKE_SERVICE) + ), + deployments=SimpleNamespace(get_deployment=lambda **kw: _deployment_with_env(env)), + ) + + +class _FakeAsyncApi: + def __init__(self, reply): + self._reply = reply + + async def __call__(self, **kwargs): + return self._reply + + +def _fake_async_clients(env): + class Services: + async def get_service(self, **kwargs): + return SimpleNamespace(service=_FAKE_SERVICE) + + class Deployments: + def __init__(self): + self._reply = _deployment_with_env(env) + + async def get_deployment(self, **kwargs): + return self._reply + + return SimpleNamespace(services=Services(), deployments=Deployments()) + + +class TestNoSandboxSecretRaiseSite(unittest.TestCase): + """get_from_id fails fast when the deployment carries no SANDBOX_SECRET, + instead of returning a handle that dies later on first connected op.""" + + def test_sync_missing_secret_raises(self): + clients = _fake_sync_clients(env=[]) + with patch( + "koyeb.sandbox.sandbox.get_api_clients", return_value=clients + ): + with self.assertRaises(NoSandboxSecretError) as cm: + Sandbox.get_from_id("svc-1", api_token="tok") + self.assertIn("SANDBOX_SECRET", str(cm.exception)) + + def test_sync_secret_found_returns_handle(self): + env = [SimpleNamespace(key="SANDBOX_SECRET", value="sec")] + clients = _fake_sync_clients(env=env) + with patch( + "koyeb.sandbox.sandbox.get_api_clients", return_value=clients + ): + sb = Sandbox.get_from_id("svc-1", api_token="tok") + self.assertEqual(sb.sandbox_secret, "sec") + + def test_async_missing_secret_raises(self): + clients = _fake_async_clients(env=[]) + with patch( + "koyeb.sandbox.utils.get_async_api_clients", return_value=clients + ): + with self.assertRaises(NoSandboxSecretError) as cm: + asyncio.run(AsyncSandbox.get_from_id("svc-1", api_token="tok")) + self.assertIn("SANDBOX_SECRET", str(cm.exception)) + + def test_async_secret_found_returns_handle(self): + env = [SimpleNamespace(key="SANDBOX_SECRET", value="sec")] + clients = _fake_async_clients(env=env) + with patch( + "koyeb.sandbox.utils.get_async_api_clients", return_value=clients + ): + sb = asyncio.run(AsyncSandbox.get_from_id("svc-1", api_token="tok")) + self.assertEqual(sb.sandbox_secret, "sec") + + +if __name__ == "__main__": + unittest.main() diff --git a/koyeb/sandbox/utils.py b/koyeb/sandbox/utils.py index 795841f6..d8aaf0b4 100644 --- a/koyeb/sandbox/utils.py +++ b/koyeb/sandbox/utils.py @@ -177,9 +177,7 @@ def get_api_clients( """ token = api_token or os.getenv("KOYEB_API_TOKEN") if not token: - raise ValueError( - "API token is required. Set KOYEB_API_TOKEN environment variable or pass api_token parameter" - ) + raise MissingApiTokenError() api_host = os.getenv("KOYEB_API_HOST", host) if not api_host: @@ -258,9 +256,7 @@ def get_async_api_clients( """ token = api_token or os.getenv("KOYEB_API_TOKEN") if not token: - raise ValueError( - "API token is required. Set KOYEB_API_TOKEN environment variable or pass api_token parameter" - ) + raise MissingApiTokenError() api_host = os.getenv("KOYEB_API_HOST", host) if not api_host: @@ -661,9 +657,7 @@ def validate_port(port: int) -> None: ValueError: If port is not in valid range [1, 65535] """ if not isinstance(port, int) or port < MIN_PORT or port > MAX_PORT: - raise ValueError( - f"Port must be an integer between {MIN_PORT} and {MAX_PORT}, got {port}" - ) + raise InvalidPortError(port) def check_error_message(error_msg: str, error_type: str) -> bool: @@ -756,6 +750,40 @@ class SandboxError(Exception): """Base exception for sandbox operations""" +class MissingApiTokenError(SandboxError, ValueError): + """Raised when no API token is provided and KOYEB_API_TOKEN is unset. + + Also inherits ValueError for back-compat with published 1.5.x callers + that catch the old plain ValueError from the token gates. + """ + + DEFAULT_MESSAGE = ( + "API token is required. Set KOYEB_API_TOKEN environment variable " + "or pass api_token parameter" + ) + + def __init__(self, message: Optional[str] = None): + super().__init__(message or self.DEFAULT_MESSAGE) + + +class InvalidPortError(SandboxError, ValueError): + """Raised when a port is not an integer in [MIN_PORT, MAX_PORT]. + + Also inherits ValueError for back-compat with published 1.5.x callers + that catch the old plain ValueError from validate_port. + """ + + def __init__(self, port: Any): + super().__init__( + f"Port must be an integer between {MIN_PORT} and {MAX_PORT}, got {port}" + ) + + +class NoSandboxSecretError(SandboxError): + """Raised when a sandbox deployment carries no SANDBOX_SECRET, so the + executor connection cannot be established.""" + + class SandboxTimeoutError(SandboxError): """Raised when a sandbox operation times out""" From 378e2c3375981a37e3e190ddd4dbdbd2559e0a80 Mon Sep 17 00:00:00 2001 From: sfroment Date: Thu, 24 Sep 2026 18:06:38 +0200 Subject: [PATCH 03/14] feat: retry executor 5xx and network errors, wrap 4xx 4xx leaked raw httpx.HTTPStatusError; now SandboxRequestError with status and body. SandboxServiceError subclasses it, so 5xx remains catchable under both names. Network errors retry with the same exponential backoff (Go CLI parity) and wrap as SandboxError. --- koyeb/sandbox/__init__.py | 2 + koyeb/sandbox/executor_client.py | 109 +++++++++----- koyeb/sandbox/test_executor_retry.py | 218 +++++++++++++++++++++++++++ koyeb/sandbox/utils.py | 30 +++- 4 files changed, 319 insertions(+), 40 deletions(-) create mode 100644 koyeb/sandbox/test_executor_retry.py diff --git a/koyeb/sandbox/__init__.py b/koyeb/sandbox/__init__.py index e963990e..113a6c6c 100644 --- a/koyeb/sandbox/__init__.py +++ b/koyeb/sandbox/__init__.py @@ -27,6 +27,7 @@ NoSandboxSecretError, SandboxDeploymentError, SandboxError, + SandboxRequestError, SandboxServiceError, SandboxTimeoutError, ) @@ -47,6 +48,7 @@ "NoSandboxSecretError", "SandboxDeploymentError", "SandboxError", + "SandboxRequestError", "SandboxServiceError", "SandboxTimeoutError", "CommandResult", diff --git a/koyeb/sandbox/executor_client.py b/koyeb/sandbox/executor_client.py index 6ce94488..6fcea309 100644 --- a/koyeb/sandbox/executor_client.py +++ b/koyeb/sandbox/executor_client.py @@ -16,6 +16,7 @@ from .utils import ( DEFAULT_HTTP_TIMEOUT, SandboxError, + SandboxRequestError, SandboxServiceError, SandboxTimeoutError, ) @@ -111,7 +112,12 @@ def _request_with_retry( **kwargs, ) -> httpx.Response: """ - Make an HTTP request with retry logic for 503 errors. + Make an HTTP request with retry logic for transient failures. + + Retries all 5xx responses and network errors (httpx.RequestError, + excluding timeouts) with exponential backoff. 4xx responses are + wrapped as SandboxRequestError; 5xx that persist after retries are + wrapped as SandboxServiceError. Args: method: HTTP method (e.g., 'GET', 'POST') @@ -124,10 +130,12 @@ def _request_with_retry( Response object Raises: - httpx.HTTPStatusError: If the request fails after all retries + SandboxRequestError: On a non-retryable HTTP error (4xx) + SandboxServiceError: On an HTTP 5xx error after retries are exhausted + SandboxTimeoutError: On request timeout + SandboxError: On network errors after retries are exhausted """ backoff = initial_backoff - last_exception = None # Set default timeout if not provided if "timeout" not in kwargs: @@ -137,10 +145,11 @@ def _request_with_retry( try: response = self._client.request(method, url, **kwargs) - # If we get a 503, retry with backoff - if response.status_code == 503 and attempt < max_retries: + # Retry transient server errors (5xx) with backoff + if response.status_code >= 500 and attempt < max_retries: logger.debug( - f"Received 503 error, retrying... (attempt {attempt + 1}/{max_retries + 1})" + f"Received {response.status_code} error, retrying... " + f"(attempt {attempt + 1}/{max_retries + 1})" ) time.sleep(backoff) backoff *= 2 # Exponential backoff @@ -150,34 +159,43 @@ def _request_with_retry( return response except httpx.HTTPStatusError as e: - if e.response.status_code == 503 and attempt < max_retries: + if e.response.status_code >= 500 and attempt < max_retries: logger.debug( - f"Received 503 error, retrying... (attempt {attempt + 1}/{max_retries + 1})" + f"Received {e.response.status_code} error, retrying... " + f"(attempt {attempt + 1}/{max_retries + 1})" ) time.sleep(backoff) backoff *= 2 - last_exception = e continue if e.response.status_code >= 500: raise SandboxServiceError( status_code=e.response.status_code, message=e.response.text, ) from e - raise + raise SandboxRequestError( + status_code=e.response.status_code, + body=e.response.text, + ) from e except httpx.TimeoutException as e: raise SandboxTimeoutError( f"Request timed out after {kwargs.get('timeout', self.timeout)}s" ) from e except httpx.RequestError as e: - logger.warning(f"Request failed: {e}") - raise + # Transient network errors (connection refused, reset, ...) + # are retried with the same backoff as server errors. + if attempt < max_retries: + logger.debug( + f"Network error, retrying... " + f"(attempt {attempt + 1}/{max_retries + 1}): {e}" + ) + time.sleep(backoff) + backoff *= 2 + continue + logger.warning(f"Request failed after {max_retries} retries: {e}") + raise SandboxError(f"Request to sandbox executor failed: {e}") from e - # If we exhausted all retries, raise the last exception - if last_exception: - raise SandboxServiceError( - status_code=last_exception.response.status_code, - message=last_exception.response.text, - ) from last_exception + # Unreachable in practice: every terminal path returns or raises. + raise SandboxError(f"Request to {url} failed after {max_retries} retries") def health(self) -> Dict[str, str]: """ @@ -583,7 +601,12 @@ async def _request_with_retry( **kwargs, ) -> httpx.Response: """ - Make an async HTTP request with retry logic for 503 errors. + Make an HTTP request with retry logic for transient failures. + + Retries all 5xx responses and network errors (httpx.RequestError, + excluding timeouts) with exponential backoff. 4xx responses are + wrapped as SandboxRequestError; 5xx that persist after retries are + wrapped as SandboxServiceError. Args: method: HTTP method (e.g., 'GET', 'POST') @@ -596,10 +619,12 @@ async def _request_with_retry( Response object Raises: - httpx.HTTPStatusError: If the request fails after all retries + SandboxRequestError: On a non-retryable HTTP error (4xx) + SandboxServiceError: On an HTTP 5xx error after retries are exhausted + SandboxTimeoutError: On request timeout + SandboxError: On network errors after retries are exhausted """ backoff = initial_backoff - last_exception = None # Set default timeout if not provided if "timeout" not in kwargs: @@ -609,10 +634,11 @@ async def _request_with_retry( try: response = await self._client.request(method, url, **kwargs) - # If we get a 503, retry with backoff - if response.status_code == 503 and attempt < max_retries: + # Retry transient server errors (5xx) with backoff + if response.status_code >= 500 and attempt < max_retries: logger.debug( - f"Received 503 error, retrying... (attempt {attempt + 1}/{max_retries + 1})" + f"Received {response.status_code} error, retrying... " + f"(attempt {attempt + 1}/{max_retries + 1})" ) await asyncio.sleep(backoff) backoff *= 2 # Exponential backoff @@ -622,34 +648,43 @@ async def _request_with_retry( return response except httpx.HTTPStatusError as e: - if e.response.status_code == 503 and attempt < max_retries: + if e.response.status_code >= 500 and attempt < max_retries: logger.debug( - f"Received 503 error, retrying... (attempt {attempt + 1}/{max_retries + 1})" + f"Received {e.response.status_code} error, retrying... " + f"(attempt {attempt + 1}/{max_retries + 1})" ) await asyncio.sleep(backoff) backoff *= 2 - last_exception = e continue if e.response.status_code >= 500: raise SandboxServiceError( status_code=e.response.status_code, message=e.response.text, ) from e - raise + raise SandboxRequestError( + status_code=e.response.status_code, + body=e.response.text, + ) from e except httpx.TimeoutException as e: raise SandboxTimeoutError( f"Request timed out after {kwargs.get('timeout', self.timeout)}s" ) from e except httpx.RequestError as e: - logger.warning(f"Request failed: {e}") - raise - - # If we exhausted all retries, raise the last exception - if last_exception: - raise SandboxServiceError( - status_code=last_exception.response.status_code, - message=last_exception.response.text, - ) from last_exception + # Transient network errors (connection refused, reset, ...) + # are retried with the same backoff as server errors. + if attempt < max_retries: + logger.debug( + f"Network error, retrying... " + f"(attempt {attempt + 1}/{max_retries + 1}): {e}" + ) + await asyncio.sleep(backoff) + backoff *= 2 + continue + logger.warning(f"Request failed after {max_retries} retries: {e}") + raise SandboxError(f"Request to sandbox executor failed: {e}") from e + + # Unreachable in practice: every terminal path returns or raises. + raise SandboxError(f"Request to {url} failed after {max_retries} retries") async def health(self) -> Dict[str, str]: """ diff --git a/koyeb/sandbox/test_executor_retry.py b/koyeb/sandbox/test_executor_retry.py new file mode 100644 index 00000000..daba2ce8 --- /dev/null +++ b/koyeb/sandbox/test_executor_retry.py @@ -0,0 +1,218 @@ +import asyncio +import unittest +from unittest.mock import patch + +import httpx + +from koyeb.sandbox.executor_client import ( + AsyncSandboxClient, + ConnectionInfo, + SandboxClient, +) +from koyeb.sandbox.utils import ( + SandboxError, + SandboxRequestError, + SandboxServiceError, + SandboxTimeoutError, +) + + +class _ScriptedHandler: + """MockTransport handler playing a scripted sequence of responses/errors.""" + + def __init__(self, steps): + self.steps = list(steps) + self.calls = 0 + + def __call__(self, request): + self.calls += 1 + step = self.steps.pop(0) + if isinstance(step, Exception): + raise step + return step(request) + + @staticmethod + def response(status_code, **kwargs): + return lambda request: httpx.Response(status_code, request=request, **kwargs) + + +_CONN = ConnectionInfo(public_url="https://sb.example", routing_key=None, secret="s") + + +def _make_sync_client(handler): + client = SandboxClient(_CONN) + client._client = httpx.Client(transport=httpx.MockTransport(handler)) + return client, handler + + +def _make_async_client(handler): + client = AsyncSandboxClient(_CONN) + client._client = httpx.AsyncClient(transport=httpx.MockTransport(handler)) + return client, handler + + +class TestErrorHierarchy(unittest.TestCase): + def test_service_error_is_request_error(self): + self.assertTrue(issubclass(SandboxServiceError, SandboxRequestError)) + self.assertTrue(issubclass(SandboxRequestError, SandboxError)) + + def test_service_error_message_unchanged(self): + err = SandboxServiceError(status_code=503, message="boom") + self.assertEqual(str(err), "Sandbox service error (503): boom") + self.assertEqual(err.status_code, 503) + + +class TestSyncRetryScope(unittest.TestCase): + """Executor requests retry all 5xx (not just 503) and network errors, + with exponential backoff; 4xx wrap as SandboxRequestError.""" + + def test_503_then_200(self): + handler = _ScriptedHandler( + [_ScriptedHandler.response(503), _ScriptedHandler.response(200)] + ) + client, handler = _make_sync_client(handler) + with patch("koyeb.sandbox.executor_client.time.sleep") as sleep: + response = client._request_with_retry("GET", "https://sb.example/health") + self.assertEqual(response.status_code, 200) + self.assertEqual(handler.calls, 2) + self.assertEqual([c.args[0] for c in sleep.call_args_list], [1.0]) + + def test_all_5xx_retried(self): + handler = _ScriptedHandler( + [ + _ScriptedHandler.response(500), + _ScriptedHandler.response(502), + _ScriptedHandler.response(504), + _ScriptedHandler.response(200), + ] + ) + client, handler = _make_sync_client(handler) + with patch("koyeb.sandbox.executor_client.time.sleep") as sleep: + response = client._request_with_retry("GET", "https://sb.example/health") + self.assertEqual(response.status_code, 200) + self.assertEqual(handler.calls, 4) + self.assertEqual( + [c.args[0] for c in sleep.call_args_list], [1.0, 2.0, 4.0] + ) + + def test_5xx_exhausted_raises_service_error(self): + handler = _ScriptedHandler([_ScriptedHandler.response(500)] * 4) + client, handler = _make_sync_client(handler) + with patch("koyeb.sandbox.executor_client.time.sleep"): + with self.assertRaises(SandboxServiceError) as cm: + client._request_with_retry("GET", "https://sb.example/health") + self.assertEqual(cm.exception.status_code, 500) + self.assertIsInstance(cm.exception, SandboxRequestError) + self.assertEqual(handler.calls, 4) + + def test_4xx_wrapped_as_request_error(self): + handler = _ScriptedHandler( + [_ScriptedHandler.response(404, json={"error": "nope"})] + ) + client, _ = _make_sync_client(handler) + with self.assertRaises(SandboxRequestError) as cm: + client._request_with_retry("GET", "https://sb.example/health") + self.assertEqual(cm.exception.status_code, 404) + self.assertIn("nope", str(cm.exception)) + self.assertNotIsInstance(cm.exception, httpx.HTTPStatusError) + self.assertIsInstance(cm.exception, SandboxError) + + def test_network_error_retried_then_wrapped(self): + handler = _ScriptedHandler( + [ + lambda request: (_ for _ in ()).throw( + httpx.ConnectError("refused", request=request) + ) + ] + * 4 + ) + client, handler = _make_sync_client(handler) + with patch("koyeb.sandbox.executor_client.time.sleep") as sleep: + with self.assertRaises(SandboxError) as cm: + client._request_with_retry("GET", "https://sb.example/health") + self.assertNotIsInstance(cm.exception, SandboxRequestError) + self.assertEqual(handler.calls, 4) + self.assertEqual([c.args[0] for c in sleep.call_args_list], [1.0, 2.0, 4.0]) + + def test_network_error_recovers(self): + def connect_error(request): + raise httpx.ConnectError("refused", request=request) + + handler = _ScriptedHandler( + [connect_error, _ScriptedHandler.response(200)] + ) + client, handler = _make_sync_client(handler) + with patch("koyeb.sandbox.executor_client.time.sleep"): + response = client._request_with_retry("GET", "https://sb.example/health") + self.assertEqual(response.status_code, 200) + self.assertEqual(handler.calls, 2) + + def test_timeout_still_sandbox_timeout(self): + def read_timeout(request): + raise httpx.ReadTimeout("too slow", request=request) + + handler = _ScriptedHandler([read_timeout]) + client, _ = _make_sync_client(handler) + with self.assertRaises(SandboxTimeoutError): + client._request_with_retry("GET", "https://sb.example/health") + + +class TestAsyncRetryScope(unittest.TestCase): + def test_all_5xx_retried(self): + handler = _ScriptedHandler( + [ + _ScriptedHandler.response(500), + _ScriptedHandler.response(503), + _ScriptedHandler.response(200), + ] + ) + client, handler = _make_async_client(handler) + + async def run(): + with patch("koyeb.sandbox.executor_client.asyncio.sleep") as sleep: + response = await client._request_with_retry( + "GET", "https://sb.example/health" + ) + return response, sleep + + response, sleep = asyncio.run(run()) + self.assertEqual(response.status_code, 200) + self.assertEqual(handler.calls, 3) + self.assertEqual([c.args[0] for c in sleep.call_args_list], [1.0, 2.0]) + + def test_4xx_wrapped_as_request_error(self): + handler = _ScriptedHandler( + [_ScriptedHandler.response(401, json={"error": "bad token"})] + ) + client, _ = _make_async_client(handler) + + async def run(): + return await client._request_with_retry( + "GET", "https://sb.example/health" + ) + + with self.assertRaises(SandboxRequestError) as cm: + asyncio.run(run()) + self.assertEqual(cm.exception.status_code, 401) + + def test_network_error_retried_then_wrapped(self): + def connect_error(request): + raise httpx.ConnectError("refused", request=request) + + handler = _ScriptedHandler([connect_error] * 4) + client, handler = _make_async_client(handler) + + async def run(): + with patch("koyeb.sandbox.executor_client.asyncio.sleep"): + return await client._request_with_retry( + "GET", "https://sb.example/health" + ) + + with self.assertRaises(SandboxError) as cm: + asyncio.run(run()) + self.assertNotIsInstance(cm.exception, SandboxRequestError) + self.assertEqual(handler.calls, 4) + + +if __name__ == "__main__": + unittest.main() diff --git a/koyeb/sandbox/utils.py b/koyeb/sandbox/utils.py index d8aaf0b4..8e7accb8 100644 --- a/koyeb/sandbox/utils.py +++ b/koyeb/sandbox/utils.py @@ -792,12 +792,36 @@ class SandboxDeploymentError(SandboxError): """Raised when a sandbox deployment reaches an error state""" -class SandboxServiceError(SandboxError): +class SandboxRequestError(SandboxError): + """Raised when the sandbox executor returns a non-OK HTTP response. + + Carries the HTTP status code and response body. SandboxServiceError + (HTTP 5xx) subclasses this, so `except SandboxRequestError` catches + every executor HTTP failure — mirroring the JS SDK's SandboxRequestError. + """ + + def __init__( + self, + status_code: int, + body: Any = None, + message: Optional[str] = None, + ): + self.status_code = status_code + self.body = body + super().__init__( + message or f"Sandbox executor request failed: {status_code} {body}" + ) + + +class SandboxServiceError(SandboxRequestError): """Raised when the sandbox executor returns an HTTP 5xx error""" def __init__(self, status_code: int, message: str): - self.status_code = status_code - super().__init__(f"Sandbox service error ({status_code}): {message}") + super().__init__( + status_code, + body=message, + message=f"Sandbox service error ({status_code}): {message}", + ) class EgressPolicyError(SandboxError): From 66ff4d982f9b406c85394a18e2c8627dffb20162 Mon Sep 17 00:00:00 2001 From: sfroment Date: Thu, 24 Sep 2026 18:09:16 +0200 Subject: [PATCH 04/14] feat: clean up sandbox when create fails or times out Default cleanup_on_failure=True mirrors JS: a failed wait deletes the orphaned sandbox (which otherwise burns instance-hours) and the error says so; False restores the old keep-and-retry behavior. Service-creation failures wrap as SandboxError and delete the app this call created, never a caller-provided app. --- koyeb/sandbox/sandbox.py | 434 ++++++++++++++++----------- koyeb/sandbox/test_create_cleanup.py | 223 ++++++++++++++ 2 files changed, 486 insertions(+), 171 deletions(-) create mode 100644 koyeb/sandbox/test_create_cleanup.py diff --git a/koyeb/sandbox/sandbox.py b/koyeb/sandbox/sandbox.py index a058c89d..e2bec2dc 100644 --- a/koyeb/sandbox/sandbox.py +++ b/koyeb/sandbox/sandbox.py @@ -77,6 +77,29 @@ def __str__(self) -> str: return f"ExposedPort(port={self.port}, exposed_at='{self.exposed_at}')" +def _cleanup_after_failure(sandbox: "Sandbox") -> None: + """Best-effort sandbox deletion after a failed create. + + Never raises: the original failure must be preserved and re-raised. + """ + try: + sandbox.delete() + except Exception as e: + logger.warning( + f"Cleanup failed, sandbox '{sandbox.name}' may still exist: {e}" + ) + + +async def _cleanup_after_failure_async(sandbox: "Sandbox") -> None: + """Async twin of _cleanup_after_failure for AsyncSandbox.delete.""" + try: + await sandbox.delete() + except Exception as e: + logger.warning( + f"Cleanup failed, sandbox '{sandbox.name}' may still exist: {e}" + ) + + class Sandbox: """ Synchronous sandbox for running code on Koyeb infrastructure. @@ -150,6 +173,7 @@ def create( outbound_allowlist: Optional[List[str]] = None, snapshot: Optional[Union[str, "Snapshot"]] = None, sandbox_secret: Optional[str] = None, + cleanup_on_failure: bool = True, ) -> Sandbox: """ Create a new sandbox instance. @@ -313,8 +337,21 @@ def create( ) if wait_ready: - is_ready = sandbox.wait_ready(timeout=timeout) + try: + is_ready = sandbox.wait_ready(timeout=timeout) + except SandboxError as e: + if cleanup_on_failure: + _cleanup_after_failure(sandbox) + e.args = (f"{e} The sandbox was deleted.",) + raise if not is_ready: + if cleanup_on_failure: + _cleanup_after_failure(sandbox) + raise SandboxTimeoutError( + f"Sandbox '{sandbox.name}' did not become ready within {timeout} seconds " + f"and was deleted. Create with cleanup_on_failure=False to keep a " + f"timed-out sandbox for inspection." + ) raise SandboxTimeoutError( f"Sandbox '{sandbox.name}' did not become ready within {timeout} seconds. " f"The sandbox was created but may not be ready yet. " @@ -379,6 +416,7 @@ def _create_sync( env["SANDBOX_SECRET"] = sandbox_secret # Use provided app_id or create a new app + created_app = False if app_id is None: app_name = f"sandbox-app-{name}-{int(time.time())}" app_response = apps_api.create_app( @@ -387,102 +425,121 @@ def _create_sync( ) ) app_id = app_response.app.id + created_app = True - env_vars = build_env_vars(env) - config_file_objects = build_config_files(config_files) - docker_source = create_docker_source( - image, - privileged=privileged, - image_registry_secret=registry_secret, - entrypoint=entrypoint, - command=command, - args=args, - ) + def _delete_created_app() -> None: + """Delete the app this call created; never masks the real error.""" + if not created_app: + return + try: + apps_api.delete_app(app_id) + except Exception as cleanup_error: + logger.warning( + f"Failed to delete app {app_id} after sandbox creation error: {cleanup_error}" + ) - deployment_definition = create_deployment_definition( - name=name, - docker_source=docker_source, - env_vars=env_vars, - instance_type=instance_type, - exposed_port_protocol=exposed_port_protocol, - region=region, - routes=routes, - idle_timeout=idle_timeout, - enable_tcp_proxy=enable_tcp_proxy, - _experimental_enable_light_sleep=_experimental_enable_light_sleep, - _experimental_deep_sleep_value=_experimental_deep_sleep_value, - enable_mesh=enable_mesh, - config_files=config_file_objects if config_file_objects else None, - network_policy=network_policy, - ) + try: + env_vars = build_env_vars(env) + config_file_objects = build_config_files(config_files) + docker_source = create_docker_source( + image, + privileged=privileged, + image_registry_secret=registry_secret, + entrypoint=entrypoint, + command=command, + args=args, + ) - service_life_cycle = ServiceLifeCycle( - delete_after_create=delete_after_delay, - delete_after_sleep=delete_after_inactivity_delay, - ) + deployment_definition = create_deployment_definition( + name=name, + docker_source=docker_source, + env_vars=env_vars, + instance_type=instance_type, + exposed_port_protocol=exposed_port_protocol, + region=region, + routes=routes, + idle_timeout=idle_timeout, + enable_tcp_proxy=enable_tcp_proxy, + _experimental_enable_light_sleep=_experimental_enable_light_sleep, + _experimental_deep_sleep_value=_experimental_deep_sleep_value, + enable_mesh=enable_mesh, + config_files=config_file_objects if config_file_objects else None, + network_policy=network_policy, + ) - # Build deployment definition - used for both snapshot and non-snapshot cases - env_vars = build_env_vars(env) - config_file_objects = build_config_files(config_files) - docker_source = create_docker_source( - image, - privileged=privileged, - image_registry_secret=registry_secret, - entrypoint=entrypoint, - command=command, - args=args, - ) - deployment_definition = create_deployment_definition( - name=name, - docker_source=docker_source, - env_vars=env_vars, - instance_type=instance_type, - exposed_port_protocol=exposed_port_protocol, - region=region, - routes=routes, - idle_timeout=idle_timeout, - enable_tcp_proxy=enable_tcp_proxy, - _experimental_enable_light_sleep=_experimental_enable_light_sleep, - _experimental_deep_sleep_value=_experimental_deep_sleep_value, - enable_mesh=enable_mesh, - config_files=config_file_objects if config_file_objects else None, - network_policy=network_policy, - ) + service_life_cycle = ServiceLifeCycle( + delete_after_create=delete_after_delay, + delete_after_sleep=delete_after_inactivity_delay, + ) - # Handle snapshot creation based on snapshot type - # For FULL snapshots, don't provide definition (API will infer it) - # For FILESYSTEM snapshots, always provide definition with snapshot_id - if snapshot_id: - # Import here to avoid circular import - from .snapshot import SnapshotType as ST + # Build deployment definition - used for both snapshot and non-snapshot cases + env_vars = build_env_vars(env) + config_file_objects = build_config_files(config_files) + docker_source = create_docker_source( + image, + privileged=privileged, + image_registry_secret=registry_secret, + entrypoint=entrypoint, + command=command, + args=args, + ) + deployment_definition = create_deployment_definition( + name=name, + docker_source=docker_source, + env_vars=env_vars, + instance_type=instance_type, + exposed_port_protocol=exposed_port_protocol, + region=region, + routes=routes, + idle_timeout=idle_timeout, + enable_tcp_proxy=enable_tcp_proxy, + _experimental_enable_light_sleep=_experimental_enable_light_sleep, + _experimental_deep_sleep_value=_experimental_deep_sleep_value, + enable_mesh=enable_mesh, + config_files=config_file_objects if config_file_objects else None, + network_policy=network_policy, + ) - # For FULL snapshots, create service without definition - if snapshot_type == ST.FULL: - create_service = CreateService( - app_id=app_id, - life_cycle=service_life_cycle, - instance_snapshot_id=snapshot_id, - name=name, - ) + # Handle snapshot creation based on snapshot type + # For FULL snapshots, don't provide definition (API will infer it) + # For FILESYSTEM snapshots, always provide definition with snapshot_id + if snapshot_id: + # Import here to avoid circular import + from .snapshot import SnapshotType as ST + + # For FULL snapshots, create service without definition + if snapshot_type == ST.FULL: + create_service = CreateService( + app_id=app_id, + life_cycle=service_life_cycle, + instance_snapshot_id=snapshot_id, + name=name, + ) + else: + # For FILESYSTEM snapshots (or unknown), provide definition + create_service = CreateService( + app_id=app_id, + definition=deployment_definition, + life_cycle=service_life_cycle, + instance_snapshot_id=snapshot_id, + name=name, + ) else: - # For FILESYSTEM snapshots (or unknown), provide definition + # No snapshot, create normally with definition create_service = CreateService( app_id=app_id, definition=deployment_definition, life_cycle=service_life_cycle, - instance_snapshot_id=snapshot_id, name=name, ) - else: - # No snapshot, create normally with definition - create_service = CreateService( - app_id=app_id, - definition=deployment_definition, - life_cycle=service_life_cycle, - name=name, - ) - service_response = services_api.create_service(service=create_service) - service_id = service_response.service.id + service_response = services_api.create_service(service=create_service) + service_id = service_response.service.id + except ApiException as e: + _delete_created_app() + raise SandboxError(f"Failed to create sandbox '{name}': {e}") from e + except Exception: + _delete_created_app() + raise return cls( sandbox_id=name, @@ -1744,6 +1801,7 @@ async def create( outbound_allowlist: Optional[List[str]] = None, snapshot: Optional[Union[str, "Snapshot"]] = None, sandbox_secret: Optional[str] = None, + cleanup_on_failure: bool = True, ) -> AsyncSandbox: """ Create a new sandbox instance with async support. @@ -1853,6 +1911,7 @@ async def create( from .utils import get_async_api_clients, build_network_policy from koyeb.api_async.models.create_app import CreateApp as AsyncCreateApp from koyeb.api_async.models.create_app import AppLifeCycle as AsyncAppLifeCycle + from koyeb.api_async.exceptions import ApiException as AsyncApiException from koyeb.api_async.models.create_service import ( CreateService as AsyncCreateService, ) @@ -1879,6 +1938,7 @@ async def create( env["SANDBOX_SECRET"] = sandbox_secret # Use provided app_id or create a new app + created_app = False if app_id is None: app_name = f"sandbox-app-{name}-{int(time.time())}" app_response = await clients.apps.create_app( @@ -1887,59 +1947,107 @@ async def create( ) ) app_id = app_response.app.id + created_app = True - env_vars = build_env_vars(env) - config_file_objects = build_config_files(config_files) - docker_source = create_docker_source( - image, - privileged=privileged, - image_registry_secret=registry_secret, - entrypoint=entrypoint, - command=command, - args=args, - ) + async def _delete_created_app() -> None: + """Delete the app this call created; never masks the real error.""" + if not created_app: + return + try: + await clients.apps.delete_app(app_id) + except Exception as cleanup_error: + logger.warning( + f"Failed to delete app {app_id} after sandbox creation error: {cleanup_error}" + ) - deployment_definition = create_deployment_definition( - name=name, - docker_source=docker_source, - env_vars=env_vars, - instance_type=instance_type, - exposed_port_protocol=exposed_port_protocol, - region=region, - routes=routes, - idle_timeout=idle_timeout, - enable_tcp_proxy=enable_tcp_proxy, - _experimental_enable_light_sleep=_experimental_enable_light_sleep, - _experimental_deep_sleep_value=_experimental_deep_sleep_value, - enable_mesh=enable_mesh, - config_files=config_file_objects if config_file_objects else None, - network_policy=network_policy, - ) + try: + env_vars = build_env_vars(env) + config_file_objects = build_config_files(config_files) + docker_source = create_docker_source( + image, + privileged=privileged, + image_registry_secret=registry_secret, + entrypoint=entrypoint, + command=command, + args=args, + ) - service_life_cycle = AsyncServiceLifeCycle( - delete_after_create=delete_after_delay, - delete_after_sleep=delete_after_inactivity_delay, - ) - # Convert sync DeploymentDefinition to dict so the async Pydantic model - # (which expects koyeb.api_async.models.DeploymentDefinition) can coerce it. - - # Handle snapshot creation based on snapshot type - # For FULL snapshots, don't provide definition (API will infer it) - # For FILESYSTEM snapshots, always provide definition with snapshot_id - if actual_snapshot_id: - # Import here to avoid circular import - from .snapshot import SnapshotType as ST - - # For FULL snapshots, create service without definition - if actual_snapshot_type == ST.FULL: - create_service = AsyncCreateService( - app_id=app_id, - life_cycle=service_life_cycle, - instance_snapshot_id=actual_snapshot_id, - name=name, - ) + deployment_definition = create_deployment_definition( + name=name, + docker_source=docker_source, + env_vars=env_vars, + instance_type=instance_type, + exposed_port_protocol=exposed_port_protocol, + region=region, + routes=routes, + idle_timeout=idle_timeout, + enable_tcp_proxy=enable_tcp_proxy, + _experimental_enable_light_sleep=_experimental_enable_light_sleep, + _experimental_deep_sleep_value=_experimental_deep_sleep_value, + enable_mesh=enable_mesh, + config_files=config_file_objects if config_file_objects else None, + network_policy=network_policy, + ) + + service_life_cycle = AsyncServiceLifeCycle( + delete_after_create=delete_after_delay, + delete_after_sleep=delete_after_inactivity_delay, + ) + # Convert sync DeploymentDefinition to dict so the async Pydantic model + # (which expects koyeb.api_async.models.DeploymentDefinition) can coerce it. + + # Handle snapshot creation based on snapshot type + # For FULL snapshots, don't provide definition (API will infer it) + # For FILESYSTEM snapshots, always provide definition with snapshot_id + if actual_snapshot_id: + # Import here to avoid circular import + from .snapshot import SnapshotType as ST + + # For FULL snapshots, create service without definition + if actual_snapshot_type == ST.FULL: + create_service = AsyncCreateService( + app_id=app_id, + life_cycle=service_life_cycle, + instance_snapshot_id=actual_snapshot_id, + name=name, + ) + else: + # For FILESYSTEM snapshots (or unknown), provide definition + env_vars = build_env_vars(env) + config_file_objects = build_config_files(config_files) + docker_source = create_docker_source( + image, + privileged=privileged, + image_registry_secret=registry_secret, + entrypoint=entrypoint, + command=command, + args=args, + ) + deployment_definition = create_deployment_definition( + name=name, + docker_source=docker_source, + env_vars=env_vars, + instance_type=instance_type, + exposed_port_protocol=exposed_port_protocol, + region=region, + routes=routes, + idle_timeout=idle_timeout, + enable_tcp_proxy=enable_tcp_proxy, + _experimental_enable_light_sleep=_experimental_enable_light_sleep, + _experimental_deep_sleep_value=_experimental_deep_sleep_value, + enable_mesh=enable_mesh, + config_files=config_file_objects if config_file_objects else None, + network_policy=network_policy, + ) + create_service = AsyncCreateService( + app_id=app_id, + definition=deployment_definition.to_dict(), + life_cycle=service_life_cycle, + instance_snapshot_id=actual_snapshot_id, + name=name, + ) else: - # For FILESYSTEM snapshots (or unknown), provide definition + # No snapshot, create normally with definition env_vars = build_env_vars(env) config_file_objects = build_config_files(config_files) docker_source = create_docker_source( @@ -1970,45 +2078,16 @@ async def create( app_id=app_id, definition=deployment_definition.to_dict(), life_cycle=service_life_cycle, - instance_snapshot_id=actual_snapshot_id, name=name, ) - else: - # No snapshot, create normally with definition - env_vars = build_env_vars(env) - config_file_objects = build_config_files(config_files) - docker_source = create_docker_source( - image, - privileged=privileged, - image_registry_secret=registry_secret, - entrypoint=entrypoint, - command=command, - args=args, - ) - deployment_definition = create_deployment_definition( - name=name, - docker_source=docker_source, - env_vars=env_vars, - instance_type=instance_type, - exposed_port_protocol=exposed_port_protocol, - region=region, - routes=routes, - idle_timeout=idle_timeout, - enable_tcp_proxy=enable_tcp_proxy, - _experimental_enable_light_sleep=_experimental_enable_light_sleep, - _experimental_deep_sleep_value=_experimental_deep_sleep_value, - enable_mesh=enable_mesh, - config_files=config_file_objects if config_file_objects else None, - network_policy=network_policy, - ) - create_service = AsyncCreateService( - app_id=app_id, - definition=deployment_definition.to_dict(), - life_cycle=service_life_cycle, - name=name, - ) - service_response = await clients.services.create_service(service=create_service) - service_id = service_response.service.id + service_response = await clients.services.create_service(service=create_service) + service_id = service_response.service.id + except AsyncApiException as e: + await _delete_created_app() + raise SandboxError(f"Failed to create sandbox '{name}': {e}") from e + except Exception: + await _delete_created_app() + raise sandbox = cls( sandbox_id=name, @@ -2023,8 +2102,21 @@ async def create( ) if wait_ready: - is_ready = await sandbox.wait_ready(timeout=timeout) + try: + is_ready = await sandbox.wait_ready(timeout=timeout) + except SandboxError as e: + if cleanup_on_failure: + await _cleanup_after_failure_async(sandbox) + e.args = (f"{e} The sandbox was deleted.",) + raise if not is_ready: + if cleanup_on_failure: + await _cleanup_after_failure_async(sandbox) + raise SandboxTimeoutError( + f"Sandbox '{sandbox.name}' did not become ready within {timeout} seconds " + f"and was deleted. Create with cleanup_on_failure=False to keep a " + f"timed-out sandbox for inspection." + ) raise SandboxTimeoutError( f"Sandbox '{sandbox.name}' did not become ready within {timeout} seconds. " f"The sandbox was created but may not be ready yet. " diff --git a/koyeb/sandbox/test_create_cleanup.py b/koyeb/sandbox/test_create_cleanup.py new file mode 100644 index 00000000..5212e6c3 --- /dev/null +++ b/koyeb/sandbox/test_create_cleanup.py @@ -0,0 +1,223 @@ +import asyncio +import unittest +from types import SimpleNamespace +from unittest.mock import patch + +from koyeb.api.exceptions import ApiException +from koyeb.api_async.exceptions import ApiException as AsyncApiException + +from koyeb.sandbox.sandbox import ( + AsyncSandbox, + Sandbox, + SandboxDeploymentError, + SandboxError, + SandboxTimeoutError, +) + + +class FakeApps: + def __init__(self): + self.created = [] + self.deleted = [] + + def create_app(self, app): + self.created.append(app) + return SimpleNamespace(app=SimpleNamespace(id="app-1")) + + def delete_app(self, app_id): + self.deleted.append(app_id) + + +class FakeServices: + def __init__(self, exc=None): + self.exc = exc + + def create_service(self, service): + if self.exc is not None: + raise self.exc + return SimpleNamespace(service=SimpleNamespace(id="svc-1")) + + +def _fake_sync_clients(exc=None): + return SimpleNamespace(apps=FakeApps(), services=FakeServices(exc=exc)) + + +class FakeAsyncApps: + def __init__(self): + self.created = [] + self.deleted = [] + + async def create_app(self, app): + self.created.append(app) + return SimpleNamespace(app=SimpleNamespace(id="app-1")) + + async def delete_app(self, app_id): + self.deleted.append(app_id) + + +class FakeAsyncServices: + def __init__(self, exc=None): + self.exc = exc + + async def create_service(self, service): + if self.exc is not None: + raise self.exc + return SimpleNamespace(service=SimpleNamespace(id="svc-1")) + + +def _fake_async_clients(exc=None): + return SimpleNamespace(apps=FakeAsyncApps(), services=FakeAsyncServices(exc=exc)) + + +class TestCreateServiceFailureCleanup(unittest.TestCase): + """Service-creation failures wrap as SandboxError and delete the app this + call created (JS sandbox.ts:236-237) — but never a caller-provided app.""" + + def test_sync_wraps_and_deletes_created_app(self): + clients = _fake_sync_clients( + exc=ApiException(status=500, reason="Internal Server Error") + ) + with patch( + "koyeb.sandbox.sandbox.get_api_clients", return_value=clients + ): + with self.assertRaises(SandboxError) as cm: + Sandbox.create(api_token="tok", wait_ready=False) + self.assertNotIsInstance(cm.exception, ApiException) + self.assertEqual(clients.apps.deleted, ["app-1"]) + + def test_sync_keeps_caller_provided_app(self): + clients = _fake_sync_clients( + exc=ApiException(status=500, reason="Internal Server Error") + ) + with patch( + "koyeb.sandbox.sandbox.get_api_clients", return_value=clients + ): + with self.assertRaises(SandboxError): + Sandbox.create( + api_token="tok", app_id="existing-app", wait_ready=False + ) + self.assertEqual(clients.apps.deleted, []) + self.assertEqual(clients.apps.created, []) + + def test_async_wraps_and_deletes_created_app(self): + clients = _fake_async_clients( + exc=AsyncApiException(status=500, reason="Internal Server Error") + ) + with patch( + "koyeb.sandbox.utils.get_async_api_clients", return_value=clients + ): + with self.assertRaises(SandboxError) as cm: + asyncio.run(AsyncSandbox.create(api_token="tok", wait_ready=False)) + self.assertNotIsInstance(cm.exception, ApiException) + self.assertEqual(clients.apps.deleted, ["app-1"]) + + +class TestWaitReadyCleanup(unittest.TestCase): + """cleanup_on_failure=True (default): wait timeout or terminal state + deletes the sandbox before raising, and the error says so.""" + + def _create_ok_clients(self): + return _fake_sync_clients() + + def test_sync_timeout_deletes_and_says_so(self): + clients = self._create_ok_clients() + with patch( + "koyeb.sandbox.sandbox.get_api_clients", return_value=clients + ): + with patch.object(Sandbox, "wait_ready", return_value=False): + with patch.object(Sandbox, "delete") as delete: + with self.assertRaises(SandboxTimeoutError) as cm: + Sandbox.create(api_token="tok", timeout=1) + delete.assert_called_once() + self.assertIn("deleted", str(cm.exception)) + self.assertNotIn("wait_ready() again", str(cm.exception)) + + def test_sync_cleanup_on_failure_false_keeps_sandbox(self): + clients = self._create_ok_clients() + with patch( + "koyeb.sandbox.sandbox.get_api_clients", return_value=clients + ): + with patch.object(Sandbox, "wait_ready", return_value=False): + with patch.object(Sandbox, "delete") as delete: + with self.assertRaises(SandboxTimeoutError) as cm: + Sandbox.create( + api_token="tok", timeout=1, cleanup_on_failure=False + ) + delete.assert_not_called() + self.assertIn("wait_ready() again", str(cm.exception)) + + def test_sync_terminal_error_deletes_and_annotates(self): + clients = self._create_ok_clients() + terminal = SandboxDeploymentError( + "Sandbox 'quick-sandbox' deployment reached status STOPPED " + "— it will not become ready; wake or redeploy the sandbox." + ) + with patch( + "koyeb.sandbox.sandbox.get_api_clients", return_value=clients + ): + with patch.object(Sandbox, "wait_ready", side_effect=terminal): + with patch.object(Sandbox, "delete") as delete: + with self.assertRaises(SandboxDeploymentError) as cm: + Sandbox.create(api_token="tok", timeout=1) + delete.assert_called_once() + self.assertIn("STOPPED", str(cm.exception)) + self.assertIn("The sandbox was deleted.", str(cm.exception)) + + def test_sync_cleanup_failure_preserves_original_error(self): + clients = self._create_ok_clients() + with patch( + "koyeb.sandbox.sandbox.get_api_clients", return_value=clients + ): + with patch.object(Sandbox, "wait_ready", return_value=False): + with patch.object( + Sandbox, "delete", side_effect=RuntimeError("api down") + ) as delete: + with self.assertRaises(SandboxTimeoutError) as cm: + Sandbox.create(api_token="tok", timeout=1) + delete.assert_called_once() + self.assertNotIsInstance(cm.exception, RuntimeError) + + def test_sync_success_does_not_delete(self): + clients = self._create_ok_clients() + with patch( + "koyeb.sandbox.sandbox.get_api_clients", return_value=clients + ): + with patch.object(Sandbox, "wait_ready", return_value=True): + with patch.object(Sandbox, "delete") as delete: + sb = Sandbox.create(api_token="tok") + delete.assert_not_called() + self.assertEqual(sb.service_id, "svc-1") + + def test_async_timeout_deletes_and_says_so(self): + clients = _fake_async_clients() + with patch( + "koyeb.sandbox.utils.get_async_api_clients", return_value=clients + ): + with patch.object(AsyncSandbox, "wait_ready", return_value=False): + with patch.object(AsyncSandbox, "delete") as delete: + with self.assertRaises(SandboxTimeoutError) as cm: + asyncio.run(AsyncSandbox.create(api_token="tok", timeout=1)) + self.assertEqual(delete.await_count, 1) + self.assertIn("deleted", str(cm.exception)) + self.assertNotIn("wait_ready() again", str(cm.exception)) + + def test_async_terminal_error_deletes_and_annotates(self): + clients = _fake_async_clients() + terminal = SandboxDeploymentError( + "Sandbox 'quick-sandbox' deployment reached status STOPPED " + "— it will not become ready; wake or redeploy the sandbox." + ) + with patch( + "koyeb.sandbox.utils.get_async_api_clients", return_value=clients + ): + with patch.object(AsyncSandbox, "wait_ready", side_effect=terminal): + with patch.object(AsyncSandbox, "delete") as delete: + with self.assertRaises(SandboxDeploymentError) as cm: + asyncio.run(AsyncSandbox.create(api_token="tok", timeout=1)) + self.assertEqual(delete.await_count, 1) + self.assertIn("STOPPED", str(cm.exception)) + self.assertIn("The sandbox was deleted.", str(cm.exception)) + + +if __name__ == "__main__": + unittest.main() From aabeb7ed24e150f52ff8094c4d63390e1abd39bd Mon Sep 17 00:00:00 2001 From: sfroment Date: Thu, 24 Sep 2026 18:12:03 +0200 Subject: [PATCH 05/14] feat: add service pools and sandbox claims ServicePool CRUD + claim/get_claim/list_claims/wait_claim_ready, fully mirrored sync+async over the existing generated ServicePoolsApi/PoolClaimsApi. Claims are idempotent by request_id (UUID, preserved across retries) and retry 429/5xx with linear backoff, matching the JS SDK. --- koyeb/sandbox/__init__.py | 30 ++ koyeb/sandbox/pool.py | 698 +++++++++++++++++++++++++++++++++++++ koyeb/sandbox/test_pool.py | 567 ++++++++++++++++++++++++++++++ koyeb/sandbox/utils.py | 33 ++ 4 files changed, 1328 insertions(+) create mode 100644 koyeb/sandbox/pool.py create mode 100644 koyeb/sandbox/test_pool.py diff --git a/koyeb/sandbox/__init__.py b/koyeb/sandbox/__init__.py index 113a6c6c..beae586e 100644 --- a/koyeb/sandbox/__init__.py +++ b/koyeb/sandbox/__init__.py @@ -18,10 +18,26 @@ SandboxExecutor, ) from .filesystem import FileInfo, SandboxFilesystem +from .pool import ( + AsyncServicePool, + ClaimResult, + ServicePool, + claim, + claim_async, + get_claim, + get_claim_async, + list_claims, + list_claims_async, + wait_claim_ready, + wait_claim_ready_async, +) from .sandbox import AsyncSandbox, ExposedPort, ProcessInfo, Sandbox from .snapshot import DeclarativeSnapshot, Snapshot, SnapshotStatus, SnapshotType from .utils import ( EgressPolicyError, + PoolClaimError, + ServicePoolError, + ServiceTerminalStateError, InvalidPortError, MissingApiTokenError, NoSandboxSecretError, @@ -42,7 +58,21 @@ "AsyncSandboxExecutor", "FileInfo", "SandboxStatus", + "AsyncServicePool", + "ClaimResult", + "ServicePool", + "claim", + "claim_async", + "get_claim", + "get_claim_async", + "list_claims", + "list_claims_async", + "wait_claim_ready", + "wait_claim_ready_async", "EgressPolicyError", + "PoolClaimError", + "ServicePoolError", + "ServiceTerminalStateError", "InvalidPortError", "MissingApiTokenError", "NoSandboxSecretError", diff --git a/koyeb/sandbox/pool.py b/koyeb/sandbox/pool.py new file mode 100644 index 00000000..b9154336 --- /dev/null +++ b/koyeb/sandbox/pool.py @@ -0,0 +1,698 @@ +""" +Koyeb service pools: pre-warmed sandbox pools and claims. + +Mirrors the JS SDK's service-pool.ts / claim.ts: a pool keeps ``size`` +pre-warmed sandboxes ready; ``claim()`` hands one out idempotently (the +same ``request_id`` returns the same claim), retrying transient failures +(429/5xx) with linear backoff. Sync and async are fully mirrored. +""" + +import asyncio +import secrets +import time +import uuid +from dataclasses import dataclass +from typing import Any, List, Optional, Union + +from koyeb.api.exceptions import ApiException +from koyeb.api.models.create_service_pool import CreateServicePool +from koyeb.api.models.pool_claim import PoolClaim +from koyeb.api.models.pool_claim_request import PoolClaimRequest +from koyeb.api.models.update_service_pool import UpdateServicePool +from koyeb.api_async.exceptions import ApiException as AsyncApiException +from koyeb.api_async.models.create_service_pool import ( + CreateServicePool as AsyncCreateServicePool, +) +from koyeb.api_async.models.pool_claim_request import ( + PoolClaimRequest as AsyncPoolClaimRequest, +) +from koyeb.api_async.models.update_service_pool import ( + UpdateServicePool as AsyncUpdateServicePool, +) + +from .utils import ( + PoolClaimError, + ServicePoolError, + ServiceTerminalStateError, + build_config_files, + build_env_vars, + build_network_policy, + classify_service_status, + create_deployment_definition, + create_docker_source, + create_koyeb_sandbox_routes, + get_api_clients, + get_async_api_clients, + logger, +) + +DEFAULT_POOL_SIZE = 1 +DEFAULT_CLAIM_ATTEMPTS = 3 +DEFAULT_CLAIM_RETRY_DELAY = 1.0 # seconds; linear: delay * attempt number +DEFAULT_CLAIM_WAIT_TIMEOUT = 300.0 +DEFAULT_CLAIM_POLL_INTERVAL = 2.0 + + +@dataclass +class ClaimResult: + """A sandbox claimed from a service pool (``service_id`` is always set).""" + + claim_id: str + pool_id: str + request_id: str + service_id: str + prewarmed: bool + + +def _claim_error_retryable(status: Any) -> bool: + """Claims are idempotent per (pool_id, request_id): only transient + failures (429, 5xx) are worth retrying.""" + return status == 429 or (isinstance(status, int) and status >= 500) + + +def _status_value(status: Any) -> Any: + return getattr(status, "value", status) + + +def claim( + pool_id: str, + request_id: Optional[str] = None, + api_token: Optional[str] = None, + host: Optional[str] = None, + max_attempts: int = DEFAULT_CLAIM_ATTEMPTS, + retry_delay: float = DEFAULT_CLAIM_RETRY_DELAY, +) -> ClaimResult: + """Claim a sandbox from a service pool. + + On the warm path (``prewarmed=True``) the claimed sandbox is already + running. On the cold path a sandbox service is created on demand: + ``service_id`` is returned immediately and the sandbox becomes usable + once the service is ready — see ``wait_claim_ready``. + + Idempotent: the same ``(pool_id, request_id)`` pair always returns the + same claim; ``request_id`` defaults to a generated UUID and is preserved + across the SDK's internal retries. + """ + if request_id is None: + request_id = str(uuid.uuid4()) + clients = get_api_clients(api_token, host) + + for attempt in range(1, max_attempts + 1): + try: + reply = clients.pool_claims.claim( + body=PoolClaimRequest(pool_id=pool_id, request_id=request_id) + ) + except ApiException as e: + if attempt >= max_attempts or not _claim_error_retryable(e.status): + raise PoolClaimError( + f"Failed to claim a sandbox from pool '{pool_id}' " + f"(attempt {attempt}/{max_attempts}): {e}" + ) from e + logger.debug( + f"Claim attempt {attempt}/{max_attempts} failed " + f"(status {e.status}); retrying" + ) + time.sleep(retry_delay * attempt) + continue + + if not getattr(reply, "claim_id", None) or not getattr( + reply, "service_id", None + ): + raise PoolClaimError( + f"Pool claim reply for pool '{pool_id}' did not include " + f"claim_id/service_id" + ) + + prewarmed = getattr(reply, "prewarmed", None) + return ClaimResult( + claim_id=reply.claim_id, + pool_id=pool_id, + request_id=request_id, + service_id=reply.service_id, + prewarmed=bool(prewarmed) if prewarmed is not None else False, + ) + + raise PoolClaimError( + f"Failed to claim a sandbox from pool '{pool_id}' " + f"after {max_attempts} attempts" + ) # pragma: no cover - loop always returns or raises + + +async def claim_async( + pool_id: str, + request_id: Optional[str] = None, + api_token: Optional[str] = None, + host: Optional[str] = None, + max_attempts: int = DEFAULT_CLAIM_ATTEMPTS, + retry_delay: float = DEFAULT_CLAIM_RETRY_DELAY, +) -> ClaimResult: + """Async twin of :func:`claim`.""" + if request_id is None: + request_id = str(uuid.uuid4()) + clients = get_async_api_clients(api_token, host) + + for attempt in range(1, max_attempts + 1): + try: + reply = await clients.pool_claims.claim( + body=AsyncPoolClaimRequest(pool_id=pool_id, request_id=request_id) + ) + except AsyncApiException as e: + if attempt >= max_attempts or not _claim_error_retryable(e.status): + raise PoolClaimError( + f"Failed to claim a sandbox from pool '{pool_id}' " + f"(attempt {attempt}/{max_attempts}): {e}" + ) from e + logger.debug( + f"Claim attempt {attempt}/{max_attempts} failed " + f"(status {e.status}); retrying" + ) + await asyncio.sleep(retry_delay * attempt) + continue + + if not getattr(reply, "claim_id", None) or not getattr( + reply, "service_id", None + ): + raise PoolClaimError( + f"Pool claim reply for pool '{pool_id}' did not include " + f"claim_id/service_id" + ) + + prewarmed = getattr(reply, "prewarmed", None) + return ClaimResult( + claim_id=reply.claim_id, + pool_id=pool_id, + request_id=request_id, + service_id=reply.service_id, + prewarmed=bool(prewarmed) if prewarmed is not None else False, + ) + + raise PoolClaimError( + f"Failed to claim a sandbox from pool '{pool_id}' " + f"after {max_attempts} attempts" + ) # pragma: no cover - loop always returns or raises + + +def get_claim( + claim_id: str, + api_token: Optional[str] = None, + host: Optional[str] = None, +) -> PoolClaim: + """Fetch a claim's state (UNSPECIFIED, PENDING, FULFILLED, FAILED, RELEASED).""" + clients = get_api_clients(api_token, host) + return clients.pool_claims.get_claim(claim_id).claim + + +async def get_claim_async( + claim_id: str, + api_token: Optional[str] = None, + host: Optional[str] = None, +) -> Any: + """Async twin of :func:`get_claim`.""" + clients = get_async_api_clients(api_token, host) + return (await clients.pool_claims.get_claim(claim_id)).claim + + +def list_claims( + pool_id: str, + status: Optional[str] = None, + limit: Optional[int] = None, + offset: Optional[int] = None, + api_token: Optional[str] = None, + host: Optional[str] = None, +) -> List[PoolClaim]: + """List claims on a service pool, optionally filtered by status.""" + clients = get_api_clients(api_token, host) + reply = clients.pool_claims.list_claim( + pool_id=pool_id, + status=status, + limit=str(limit) if limit is not None else None, + offset=str(offset) if offset is not None else None, + ) + return list(reply.claims or []) + + +async def list_claims_async( + pool_id: str, + status: Optional[str] = None, + limit: Optional[int] = None, + offset: Optional[int] = None, + api_token: Optional[str] = None, + host: Optional[str] = None, +) -> List[Any]: + """Async twin of :func:`list_claims`.""" + clients = get_async_api_clients(api_token, host) + reply = await clients.pool_claims.list_claim( + pool_id=pool_id, + status=status, + limit=str(limit) if limit is not None else None, + offset=str(offset) if offset is not None else None, + ) + return list(reply.claims or []) + + +def wait_claim_ready( + claim_or_service_id: Union[ClaimResult, str], + timeout: float = DEFAULT_CLAIM_WAIT_TIMEOUT, + poll_interval: float = DEFAULT_CLAIM_POLL_INTERVAL, + api_token: Optional[str] = None, + host: Optional[str] = None, +) -> bool: + """Poll Get Service until the claimed sandbox is ready. + + General service-health polling: returns True on ready, False on + timeout, and raises :class:`ServiceTerminalStateError` on terminal + states. Transient Get Service failures are treated as in-progress and + retried until the timeout (they dominate while a cold claim provisions). + """ + service_id = ( + claim_or_service_id.service_id + if isinstance(claim_or_service_id, ClaimResult) + else claim_or_service_id + ) + clients = get_api_clients(api_token, host) + start = time.time() + + while time.time() - start < timeout: + status = None + try: + status = clients.services.get_service(service_id).service.status + except Exception as e: + logger.debug(f"Get Service {service_id} failed, will retry: {e}") + if status is not None: + classification = classify_service_status(status) + if classification == "terminal_failure": + raise ServiceTerminalStateError(service_id, status) + if classification == "ready": + return True + time.sleep(poll_interval) + + return False + + +async def wait_claim_ready_async( + claim_or_service_id: Union[ClaimResult, str], + timeout: float = DEFAULT_CLAIM_WAIT_TIMEOUT, + poll_interval: float = DEFAULT_CLAIM_POLL_INTERVAL, + api_token: Optional[str] = None, + host: Optional[str] = None, +) -> bool: + """Async twin of :func:`wait_claim_ready`.""" + service_id = ( + claim_or_service_id.service_id + if isinstance(claim_or_service_id, ClaimResult) + else claim_or_service_id + ) + clients = get_async_api_clients(api_token, host) + start = time.time() + + while time.time() - start < timeout: + status = None + try: + status = (await clients.services.get_service(service_id)).service.status + except Exception as e: + logger.debug(f"Get Service {service_id} failed, will retry: {e}") + if status is not None: + classification = classify_service_status(status) + if classification == "terminal_failure": + raise ServiceTerminalStateError(service_id, status) + if classification == "ready": + return True + await asyncio.sleep(poll_interval) + + return False + + +class ServicePool: + """A Koyeb service pool keeping pre-warmed sandboxes ready to claim.""" + + def __init__( + self, + id: str, + name: str, + size: int, + ready_count: int, + status: Any, + definition: Any = None, + api_token: Optional[str] = None, + host: Optional[str] = None, + ): + self.id = id + self.name = name + self.size = size + self.ready_count = ready_count + self.status = status + self.definition = definition + self.api_token = api_token + self.host = host + + @classmethod + def create( + cls, + name: str, + image: str = "koyeb/sandbox", + size: int = DEFAULT_POOL_SIZE, + instance_type: str = "micro", + region: Optional[str] = None, + env: Optional[dict] = None, + config_files: Optional[dict] = None, + privileged: bool = False, + registry_secret: Optional[str] = None, + exposed_port_protocol: Optional[str] = None, + enable_tcp_proxy: bool = False, + idle_timeout: int = 300, + _experimental_enable_light_sleep: bool = False, + block_network: bool = False, + outbound_allowlist: Optional[List[str]] = None, + api_token: Optional[str] = None, + host: Optional[str] = None, + ) -> "ServicePool": + """Create a pool of ``size`` pre-warmed sandboxes built from the same + definition options as ``Sandbox.create`` (minus sandbox-specific + entrypoint/command overrides).""" + network_policy = build_network_policy(block_network, outbound_allowlist) + env = dict(env) if env else {} + env["SANDBOX_SECRET"] = secrets.token_urlsafe(32) + env_vars = build_env_vars(env) + config_file_objects = build_config_files(config_files) + docker_source = create_docker_source( + image, + privileged=privileged, + image_registry_secret=registry_secret, + ) + definition = create_deployment_definition( + name=name, + docker_source=docker_source, + env_vars=env_vars, + instance_type=instance_type, + exposed_port_protocol=exposed_port_protocol, + region=region, + routes=create_koyeb_sandbox_routes(), + idle_timeout=idle_timeout, + enable_tcp_proxy=enable_tcp_proxy, + _experimental_enable_light_sleep=_experimental_enable_light_sleep, + enable_mesh=None, + config_files=config_file_objects if config_file_objects else None, + network_policy=network_policy, + ) + clients = get_api_clients(api_token, host) + try: + reply = clients.service_pools.create_service_pool( + service_pool=CreateServicePool( + name=name, size=size, definition=definition + ) + ) + except ApiException as e: + raise ServicePoolError(f"Failed to create service pool '{name}': {e}") from e + return cls._from_model(reply.service_pool, api_token, host) + + @classmethod + def get( + cls, + pool_id: str, + api_token: Optional[str] = None, + host: Optional[str] = None, + ) -> "ServicePool": + clients = get_api_clients(api_token, host) + try: + reply = clients.service_pools.get_service_pool(pool_id) + except ApiException as e: + raise ServicePoolError(f"Failed to get service pool '{pool_id}': {e}") from e + return cls._from_model(reply.service_pool, api_token, host) + + @classmethod + def list( + cls, + name: Optional[str] = None, + limit: Optional[int] = None, + offset: Optional[int] = None, + api_token: Optional[str] = None, + host: Optional[str] = None, + ) -> List["ServicePool"]: + clients = get_api_clients(api_token, host) + try: + reply = clients.service_pools.list_service_pools( + name=name, + limit=str(limit) if limit is not None else None, + offset=str(offset) if offset is not None else None, + ) + except ApiException as e: + raise ServicePoolError(f"Failed to list service pools: {e}") from e + return [ + cls._from_model(pool, api_token, host) + for pool in reply.service_pools or [] + ] + + def update(self, size: Optional[int] = None) -> "ServicePool": + """Resize the pool; returns the updated pool.""" + clients = get_api_clients(self.api_token, self.host) + try: + reply = clients.service_pools.update_service_pool( + id=self.id, + service_pool=UpdateServicePool(size=size), + update_mask="size", + ) + except ApiException as e: + raise ServicePoolError(f"Failed to update service pool '{self.id}': {e}") from e + return ServicePool._from_model( + reply.service_pool, self.api_token, self.host + ) + + def delete(self) -> None: + """Delete the pool (async server-side: it enters DELETING).""" + clients = get_api_clients(self.api_token, self.host) + try: + clients.service_pools.delete_service_pool(self.id) + except ApiException as e: + raise ServicePoolError(f"Failed to delete service pool '{self.id}': {e}") from e + + def refresh(self) -> "ServicePool": + """Re-fetch the pool's state (ready_count, status) in place.""" + clients = get_api_clients(self.api_token, self.host) + try: + reply = clients.service_pools.get_service_pool(self.id) + except ApiException as e: + raise ServicePoolError(f"Failed to refresh service pool '{self.id}': {e}") from e + model = reply.service_pool + self.name = model.name + self.size = model.size + self.ready_count = model.ready_count + self.status = model.status + self.definition = model.definition + return self + + def claims( + self, + status: Optional[str] = None, + limit: Optional[int] = None, + offset: Optional[int] = None, + ) -> List[PoolClaim]: + return list_claims( + self.id, + status=status, + limit=limit, + offset=offset, + api_token=self.api_token, + host=self.host, + ) + + @staticmethod + def _from_model( + model: Any, + api_token: Optional[str] = None, + host: Optional[str] = None, + ) -> "ServicePool": + return ServicePool( + id=model.id, + name=model.name, + size=model.size, + ready_count=model.ready_count, + status=model.status, + definition=model.definition, + api_token=api_token, + host=host, + ) + + +class AsyncServicePool: + """Async twin of :class:`ServicePool`.""" + + def __init__( + self, + id: str, + name: str, + size: int, + ready_count: int, + status: Any, + definition: Any = None, + api_token: Optional[str] = None, + host: Optional[str] = None, + ): + self.id = id + self.name = name + self.size = size + self.ready_count = ready_count + self.status = status + self.definition = definition + self.api_token = api_token + self.host = host + + @classmethod + async def create( + cls, + name: str, + image: str = "koyeb/sandbox", + size: int = DEFAULT_POOL_SIZE, + instance_type: str = "micro", + region: Optional[str] = None, + env: Optional[dict] = None, + config_files: Optional[dict] = None, + privileged: bool = False, + registry_secret: Optional[str] = None, + exposed_port_protocol: Optional[str] = None, + enable_tcp_proxy: bool = False, + idle_timeout: int = 300, + _experimental_enable_light_sleep: bool = False, + block_network: bool = False, + outbound_allowlist: Optional[List[str]] = None, + api_token: Optional[str] = None, + host: Optional[str] = None, + ) -> "AsyncServicePool": + network_policy = build_network_policy(block_network, outbound_allowlist) + env = dict(env) if env else {} + env["SANDBOX_SECRET"] = secrets.token_urlsafe(32) + env_vars = build_env_vars(env) + config_file_objects = build_config_files(config_files) + docker_source = create_docker_source( + image, + privileged=privileged, + image_registry_secret=registry_secret, + ) + definition = create_deployment_definition( + name=name, + docker_source=docker_source, + env_vars=env_vars, + instance_type=instance_type, + exposed_port_protocol=exposed_port_protocol, + region=region, + routes=create_koyeb_sandbox_routes(), + idle_timeout=idle_timeout, + enable_tcp_proxy=enable_tcp_proxy, + _experimental_enable_light_sleep=_experimental_enable_light_sleep, + enable_mesh=None, + config_files=config_file_objects if config_file_objects else None, + network_policy=network_policy, + ) + clients = get_async_api_clients(api_token, host) + try: + reply = await clients.service_pools.create_service_pool( + service_pool=AsyncCreateServicePool( + name=name, size=size, definition=definition.to_dict() + ) + ) + except AsyncApiException as e: + raise ServicePoolError(f"Failed to create service pool '{name}': {e}") from e + return cls._from_model(reply.service_pool, api_token, host) + + @classmethod + async def get( + cls, + pool_id: str, + api_token: Optional[str] = None, + host: Optional[str] = None, + ) -> "AsyncServicePool": + clients = get_async_api_clients(api_token, host) + try: + reply = await clients.service_pools.get_service_pool(pool_id) + except AsyncApiException as e: + raise ServicePoolError(f"Failed to get service pool '{pool_id}': {e}") from e + return cls._from_model(reply.service_pool, api_token, host) + + @classmethod + async def list( + cls, + name: Optional[str] = None, + limit: Optional[int] = None, + offset: Optional[int] = None, + api_token: Optional[str] = None, + host: Optional[str] = None, + ) -> List["AsyncServicePool"]: + clients = get_async_api_clients(api_token, host) + try: + reply = await clients.service_pools.list_service_pools( + name=name, + limit=str(limit) if limit is not None else None, + offset=str(offset) if offset is not None else None, + ) + except AsyncApiException as e: + raise ServicePoolError(f"Failed to list service pools: {e}") from e + return [ + cls._from_model(pool, api_token, host) + for pool in reply.service_pools or [] + ] + + async def update(self, size: Optional[int] = None) -> "AsyncServicePool": + clients = get_async_api_clients(self.api_token, self.host) + try: + reply = await clients.service_pools.update_service_pool( + id=self.id, + service_pool=AsyncUpdateServicePool(size=size), + update_mask="size", + ) + except AsyncApiException as e: + raise ServicePoolError(f"Failed to update service pool '{self.id}': {e}") from e + return AsyncServicePool._from_model( + reply.service_pool, self.api_token, self.host + ) + + async def delete(self) -> None: + clients = get_async_api_clients(self.api_token, self.host) + try: + await clients.service_pools.delete_service_pool(self.id) + except AsyncApiException as e: + raise ServicePoolError(f"Failed to delete service pool '{self.id}': {e}") from e + + async def refresh(self) -> "AsyncServicePool": + clients = get_async_api_clients(self.api_token, self.host) + try: + reply = await clients.service_pools.get_service_pool(self.id) + except AsyncApiException as e: + raise ServicePoolError(f"Failed to refresh service pool '{self.id}': {e}") from e + model = reply.service_pool + self.name = model.name + self.size = model.size + self.ready_count = model.ready_count + self.status = model.status + self.definition = model.definition + return self + + async def claims( + self, + status: Optional[str] = None, + limit: Optional[int] = None, + offset: Optional[int] = None, + ) -> List[Any]: + return await list_claims_async( + self.id, + status=status, + limit=limit, + offset=offset, + api_token=self.api_token, + host=self.host, + ) + + @staticmethod + def _from_model( + model: Any, + api_token: Optional[str] = None, + host: Optional[str] = None, + ) -> "AsyncServicePool": + return AsyncServicePool( + id=model.id, + name=model.name, + size=model.size, + ready_count=model.ready_count, + status=model.status, + definition=model.definition, + api_token=api_token, + host=host, + ) diff --git a/koyeb/sandbox/test_pool.py b/koyeb/sandbox/test_pool.py new file mode 100644 index 00000000..fce5ac62 --- /dev/null +++ b/koyeb/sandbox/test_pool.py @@ -0,0 +1,567 @@ +import asyncio +import time +import unittest +import uuid +from types import SimpleNamespace +from unittest.mock import patch + +from koyeb.api.exceptions import ApiException +from koyeb.api_async.exceptions import ApiException as AsyncApiException +from koyeb.api.models.deployment_definition_type import DeploymentDefinitionType +from koyeb.api.models.pool_claim_status import PoolClaimStatus +from koyeb.api.models.service_pool_status import ServicePoolStatus +from koyeb.api.models.service_status import ServiceStatus + +from koyeb.sandbox.pool import ( + AsyncServicePool, + ClaimResult, + ServicePool, + claim, + claim_async, + get_claim, + get_claim_async, + list_claims, + list_claims_async, + wait_claim_ready, + wait_claim_ready_async, +) +from koyeb.sandbox.utils import ( + PoolClaimError, + SandboxError, + ServicePoolError, + ServiceTerminalStateError, +) + + +def _pool_model(ready_count=1, size=2): + return SimpleNamespace( + id="pool-1", + name="my-pool", + size=size, + ready_count=ready_count, + status=ServicePoolStatus.READY, + definition=None, + ) + + +_POOL_CLAIM = SimpleNamespace( + id="claim-1", + pool_id="pool-1", + service_id="svc-1", + request_id="req-1", + status=PoolClaimStatus.FULFILLED, +) + + +class FakeServicePoolsApi: + def __init__(self, pool=None, pools=None): + self.created = [] + self.updates = [] + self.deleted = [] + self.got = [] + self.list_kwargs = None + self._pool = pool or _pool_model() + self._pools = pools if pools is not None else [_pool_model()] + + def create_service_pool(self, service_pool): + self.created.append(service_pool) + return SimpleNamespace(service_pool=self._pool) + + def get_service_pool(self, id): + self.got.append(id) + return SimpleNamespace(service_pool=self._pool) + + def list_service_pools(self, **kwargs): + self.list_kwargs = kwargs + return SimpleNamespace( + service_pools=self._pools, count=len(self._pools), has_next=False + ) + + def update_service_pool(self, id, service_pool, update_mask=None): + self.updates.append((id, service_pool, update_mask)) + return SimpleNamespace(service_pool=self._pool) + + def delete_service_pool(self, id): + self.deleted.append(id) + + +class FakePoolClaimsApi: + def __init__(self, reply=None, excs=None): + self.claim_bodies = [] + self.last_get = None + self.last_list = None + self._reply = reply or SimpleNamespace( + claim_id="claim-1", service_id="svc-1", prewarmed=True + ) + self._excs = list(excs or []) + + def claim(self, body): + self.claim_bodies.append(body) + if self._excs: + exc = self._excs.pop(0) + if exc is not None: + raise exc + return self._reply + + def get_claim(self, claim_id): + self.last_get = claim_id + return SimpleNamespace(claim=_POOL_CLAIM) + + def list_claim(self, **kwargs): + self.last_list = kwargs + return SimpleNamespace(claims=[_POOL_CLAIM], count=1, has_next=False) + + +class FakeServicesApi: + def __init__(self, statuses=None, excs=None): + self.calls = 0 + self._statuses = list(statuses or []) + self._excs = list(excs or []) + + def get_service(self, id): + self.calls += 1 + if self._excs: + exc = self._excs.pop(0) + if exc is not None: + raise exc + status = self._statuses.pop(0) if self._statuses else ServiceStatus.STARTING + return SimpleNamespace(service=SimpleNamespace(status=status)) + + +def _fake_sync_clients(pools_api=None, claims_api=None, services_api=None): + return SimpleNamespace( + service_pools=pools_api or FakeServicePoolsApi(), + pool_claims=claims_api or FakePoolClaimsApi(), + services=services_api or FakeServicesApi(), + ) + + +class FakeAsyncServicePoolsApi(FakeServicePoolsApi): + async def create_service_pool(self, service_pool): + return FakeServicePoolsApi.create_service_pool(self, service_pool) + + async def get_service_pool(self, id): + return FakeServicePoolsApi.get_service_pool(self, id) + + async def list_service_pools(self, **kwargs): + return FakeServicePoolsApi.list_service_pools(self, **kwargs) + + async def update_service_pool(self, id, service_pool, update_mask=None): + return FakeServicePoolsApi.update_service_pool(self, id, service_pool, update_mask) + + async def delete_service_pool(self, id): + return FakeServicePoolsApi.delete_service_pool(self, id) + + +class FakeAsyncPoolClaimsApi(FakePoolClaimsApi): + async def claim(self, body): + return FakePoolClaimsApi.claim(self, body) + + async def get_claim(self, claim_id): + return FakePoolClaimsApi.get_claim(self, claim_id) + + async def list_claim(self, **kwargs): + return FakePoolClaimsApi.list_claim(self, **kwargs) + + +class FakeAsyncServicesApi(FakeServicesApi): + async def get_service(self, id): + return FakeServicesApi.get_service(self, id) + + +def _fake_async_clients(pools_api=None, claims_api=None, services_api=None): + return SimpleNamespace( + service_pools=pools_api or FakeAsyncServicePoolsApi(), + pool_claims=claims_api or FakeAsyncPoolClaimsApi(), + services=services_api or FakeAsyncServicesApi(), + ) + + +class TestServicePoolCreate(unittest.TestCase): + def test_create_builds_sandbox_definition_with_defaults(self): + pools = FakeServicePoolsApi() + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(pools_api=pools), + ): + pool = ServicePool.create(name="my-pool", api_token="tok") + body = pools.created[0] + self.assertEqual(body.name, "my-pool") + self.assertEqual(body.size, 1) + self.assertEqual(body.definition.type, DeploymentDefinitionType.SANDBOX) + env_keys = [e.key for e in body.definition.env] + self.assertIn("SANDBOX_SECRET", env_keys) + self.assertEqual(pool.id, "pool-1") + self.assertEqual(pool.name, "my-pool") + self.assertEqual(pool.ready_count, 1) + self.assertEqual(pool.status, ServicePoolStatus.READY) + + def test_create_explicit_size(self): + pools = FakeServicePoolsApi() + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(pools_api=pools), + ): + ServicePool.create(name="p", size=3, api_token="tok") + self.assertEqual(pools.created[0].size, 3) + + +class TestServicePoolCrud(unittest.TestCase): + def _pool(self, pools): + return ServicePool( + id="pool-1", + name="my-pool", + size=2, + ready_count=1, + status=ServicePoolStatus.READY, + api_token="tok", + ) + + def test_get(self): + pools = FakeServicePoolsApi() + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(pools_api=pools), + ): + pool = ServicePool.get("pool-1", api_token="tok") + self.assertEqual(pools.got, ["pool-1"]) + self.assertEqual(pool.id, "pool-1") + + def test_list(self): + pools = FakeServicePoolsApi(pools=[_pool_model(), _pool_model()]) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(pools_api=pools), + ): + found = ServicePool.list(api_token="tok") + self.assertEqual(len(found), 2) + self.assertEqual(pools.list_kwargs.get("name"), None) + + def test_update_size(self): + pools = FakeServicePoolsApi() + pool = self._pool(pools) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(pools_api=pools), + ): + updated = pool.update(size=5) + pool_id, body, update_mask = pools.updates[0] + self.assertEqual(pool_id, "pool-1") + self.assertEqual(body.size, 5) + self.assertEqual(update_mask, "size") + self.assertEqual(updated.size, 2) # mapped from reply model + + def test_delete(self): + pools = FakeServicePoolsApi() + pool = self._pool(pools) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(pools_api=pools), + ): + pool.delete() + self.assertEqual(pools.deleted, ["pool-1"]) + + def test_delete_failure_wraps_as_service_pool_error(self): + class FailingPools(FakeServicePoolsApi): + def delete_service_pool(self, id): + raise ApiException(status=500, reason="boom") + + pool = ServicePool( + id="pool-1", name="p", size=1, ready_count=0, + status=ServicePoolStatus.READY, api_token="tok", + ) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(pools_api=FailingPools()), + ): + with self.assertRaises(ServicePoolError): + pool.delete() + + def test_refresh_updates_fields(self): + pools = FakeServicePoolsApi(pool=_pool_model(ready_count=7)) + pool = self._pool(pools) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(pools_api=pools), + ): + pool.refresh() + self.assertEqual(pool.ready_count, 7) + + def test_claims_delegates_with_filters(self): + claims = FakePoolClaimsApi() + pool = self._pool(None) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(claims_api=claims), + ): + found = pool.claims(status="FULFILLED", limit=10, offset=0) + self.assertEqual(claims.last_list.get("pool_id"), "pool-1") + self.assertEqual(claims.last_list.get("status"), "FULFILLED") + self.assertEqual(claims.last_list.get("limit"), "10") + self.assertEqual(claims.last_list.get("offset"), "0") + self.assertEqual(found, [_POOL_CLAIM]) + + +class TestClaim(unittest.TestCase): + def test_claim_happy_path(self): + claims = FakePoolClaimsApi() + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(claims_api=claims), + ): + result = claim("pool-1", api_token="tok") + self.assertIsInstance(result, ClaimResult) + self.assertEqual(result.claim_id, "claim-1") + self.assertEqual(result.pool_id, "pool-1") + self.assertEqual(result.service_id, "svc-1") + self.assertTrue(result.prewarmed) + # default request_id is a generated UUID, echoed on the request body + self.assertEqual(claims.claim_bodies[0].request_id, result.request_id) + uuid.UUID(result.request_id) # valid UUID + + def test_claim_retry_preserves_request_id(self): + claims = FakePoolClaimsApi( + excs=[ + ApiException(status=429, reason="Too Many Requests"), + ApiException(status=503, reason="Service Unavailable"), + ] + ) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(claims_api=claims), + ): + with patch("koyeb.sandbox.pool.time.sleep") as sleep: + result = claim("pool-1", api_token="tok") + self.assertEqual(len(claims.claim_bodies), 3) + request_ids = {b.request_id for b in claims.claim_bodies} + self.assertEqual(len(request_ids), 1) + self.assertEqual(request_ids.pop(), result.request_id) + self.assertEqual([c.args[0] for c in sleep.call_args_list], [1.0, 2.0]) + + def test_claim_missing_service_id_raises(self): + claims = FakePoolClaimsApi( + reply=SimpleNamespace(claim_id="claim-1", service_id=None, prewarmed=None) + ) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(claims_api=claims), + ): + with self.assertRaises(PoolClaimError): + claim("pool-1", api_token="tok") + + def test_claim_non_retryable_status_raises_immediately(self): + claims = FakePoolClaimsApi( + excs=[ApiException(status=400, reason="Bad Request")] + ) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(claims_api=claims), + ): + with patch("koyeb.sandbox.pool.time.sleep") as sleep: + with self.assertRaises(PoolClaimError): + claim("pool-1", api_token="tok") + self.assertEqual(len(claims.claim_bodies), 1) + sleep.assert_not_called() + + def test_claim_exhausted_wraps_last_error(self): + claims = FakePoolClaimsApi(excs=[ApiException(status=429, reason="slow")] * 3) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(claims_api=claims), + ): + with patch("koyeb.sandbox.pool.time.sleep") as sleep: + with self.assertRaises(PoolClaimError) as cm: + claim("pool-1", api_token="tok") + self.assertIsInstance(cm.exception.__cause__, ApiException) + self.assertIsInstance(cm.exception, SandboxError) + self.assertEqual([c.args[0] for c in sleep.call_args_list], [1.0, 2.0]) + + +class TestClaimHelpers(unittest.TestCase): + def test_get_claim(self): + claims = FakePoolClaimsApi() + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(claims_api=claims), + ): + found = get_claim("claim-1", api_token="tok") + self.assertEqual(claims.last_get, "claim-1") + self.assertEqual(found, _POOL_CLAIM) + + def test_list_claims_converts_pagination_to_strings(self): + claims = FakePoolClaimsApi() + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(claims_api=claims), + ): + found = list_claims("pool-1", status="PENDING", limit=5, offset=0, api_token="tok") + self.assertEqual(claims.last_list.get("pool_id"), "pool-1") + self.assertEqual(claims.last_list.get("status"), "PENDING") + self.assertEqual(claims.last_list.get("limit"), "5") + self.assertEqual(claims.last_list.get("offset"), "0") + self.assertEqual(found, [_POOL_CLAIM]) + + +class TestWaitClaimReady(unittest.TestCase): + def test_ready_after_progress(self): + services = FakeServicesApi( + statuses=[ServiceStatus.STARTING, ServiceStatus.HEALTHY] + ) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(services_api=services), + ): + with patch("koyeb.sandbox.pool.time.sleep") as sleep: + ready = wait_claim_ready("svc-1", timeout=10, poll_interval=2, api_token="tok") + self.assertTrue(ready) + self.assertEqual(services.calls, 2) + sleep.assert_called_once_with(2) + + def test_accepts_claim_result(self): + services = FakeServicesApi(statuses=[ServiceStatus.HEALTHY]) + result = ClaimResult( + claim_id="c", pool_id="pool-1", request_id="r", service_id="svc-9", prewarmed=False + ) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(services_api=services), + ): + ready = wait_claim_ready(result, timeout=10, poll_interval=1, api_token="tok") + self.assertTrue(ready) + + def test_terminal_state_raises(self): + services = FakeServicesApi(statuses=[ServiceStatus.UNHEALTHY]) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(services_api=services), + ): + with self.assertRaises(ServiceTerminalStateError) as cm: + wait_claim_ready("svc-1", timeout=10, poll_interval=1, api_token="tok") + self.assertIn("svc-1", str(cm.exception)) + self.assertIn("UNHEALTHY", str(cm.exception)) + + def test_transient_get_service_error_is_retried(self): + services = FakeServicesApi( + excs=[ApiException(status=500, reason="boom")], + statuses=[ServiceStatus.HEALTHY], + ) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(services_api=services), + ): + with patch("koyeb.sandbox.pool.time.sleep"): + ready = wait_claim_ready("svc-1", timeout=10, poll_interval=1, api_token="tok") + self.assertTrue(ready) + + def test_timeout_returns_false(self): + services = FakeServicesApi(statuses=[ServiceStatus.STARTING] * 50) + with patch( + "koyeb.sandbox.pool.get_api_clients", + return_value=_fake_sync_clients(services_api=services), + ): + with patch("koyeb.sandbox.pool.time.sleep"): + with patch("koyeb.sandbox.pool.time.time", side_effect=list(range(0, 1000))): + ready = wait_claim_ready( + "svc-1", timeout=10, poll_interval=1, api_token="tok" + ) + self.assertFalse(ready) + + +class TestAsyncPoolMirror(unittest.TestCase): + def test_async_create(self): + pools = FakeAsyncServicePoolsApi() + with patch( + "koyeb.sandbox.pool.get_async_api_clients", + return_value=_fake_async_clients(pools_api=pools), + ): + pool = asyncio.run(AsyncServicePool.create(name="p", api_token="tok")) + body = pools.created[0] + self.assertEqual(body.size, 1) + self.assertEqual(body.name, "p") + self.assertEqual(pool.id, "pool-1") + + def test_async_claim_retry_preserves_request_id(self): + claims = FakeAsyncPoolClaimsApi( + excs=[ + AsyncApiException(status=500, reason="boom"), + AsyncApiException(status=429, reason="slow"), + ] + ) + with patch( + "koyeb.sandbox.pool.get_async_api_clients", + return_value=_fake_async_clients(claims_api=claims), + ): + with patch("koyeb.sandbox.pool.asyncio.sleep") as sleep: + + async def run(): + return await claim_async("pool-1", api_token="tok") + + result = asyncio.run(run()) + self.assertEqual(len(claims.claim_bodies), 3) + request_ids = {b.request_id for b in claims.claim_bodies} + self.assertEqual(len(request_ids), 1) + self.assertEqual(request_ids.pop(), result.request_id) + self.assertEqual([c.args[0] for c in sleep.call_args_list], [1.0, 2.0]) + + def test_async_get_and_list_claims(self): + claims = FakeAsyncPoolClaimsApi() + with patch( + "koyeb.sandbox.pool.get_async_api_clients", + return_value=_fake_async_clients(claims_api=claims), + ): + + async def run(): + got = await get_claim_async("claim-1", api_token="tok") + listed = await list_claims_async( + "pool-1", status="PENDING", limit=5, offset=0, api_token="tok" + ) + return got, listed + + got, listed = asyncio.run(run()) + self.assertEqual(got, _POOL_CLAIM) + self.assertEqual(listed, [_POOL_CLAIM]) + self.assertEqual(claims.last_list.get("limit"), "5") + + def test_async_wait_claim_ready_terminal(self): + services = FakeAsyncServicesApi(statuses=[ServiceStatus.UNHEALTHY]) + with patch( + "koyeb.sandbox.pool.get_async_api_clients", + return_value=_fake_async_clients(services_api=services), + ): + + async def run(): + return await wait_claim_ready_async( + "svc-1", timeout=10, poll_interval=1, api_token="tok" + ) + + with self.assertRaises(ServiceTerminalStateError): + asyncio.run(run()) + + def test_async_pool_update_delete_refresh(self): + pools = FakeAsyncServicePoolsApi(pool=_pool_model(ready_count=9)) + pool = AsyncServicePool( + id="pool-1", + name="my-pool", + size=2, + ready_count=1, + status=ServicePoolStatus.READY, + api_token="tok", + ) + with patch( + "koyeb.sandbox.pool.get_async_api_clients", + return_value=_fake_async_clients(pools_api=pools), + ): + + async def run(): + await pool.update(size=4) + await pool.delete() + await pool.refresh() + + asyncio.run(run()) + self.assertEqual(pools.updates[0][1].size, 4) + self.assertEqual(pools.deleted, ["pool-1"]) + self.assertEqual(pool.ready_count, 9) + + +if __name__ == "__main__": + unittest.main() diff --git a/koyeb/sandbox/utils.py b/koyeb/sandbox/utils.py index 8e7accb8..6bd2f6ce 100644 --- a/koyeb/sandbox/utils.py +++ b/koyeb/sandbox/utils.py @@ -19,7 +19,9 @@ DeploymentsApi, InstancesApi, InstanceSnapshotsApi, + PoolClaimsApi, SecretsApi, + ServicePoolsApi, ServicesApi, ) from koyeb.api.models.config_file import ConfigFile @@ -152,6 +154,8 @@ class ApiClients: deployments: DeploymentsApi secrets: SecretsApi instance_snapshots: Any + service_pools: ServicePoolsApi + pool_claims: PoolClaimsApi _api_clients_cache: Dict[Tuple[str, str], ApiClients] = {} @@ -200,6 +204,8 @@ def get_api_clients( deployments=DeploymentsApi(api_client), secrets=SecretsApi(api_client), instance_snapshots=InstanceSnapshotsApi(api_client), + service_pools=ServicePoolsApi(api_client), + pool_claims=PoolClaimsApi(api_client), ) _api_clients_cache[cache_key] = clients return clients @@ -215,7 +221,9 @@ def get_api_clients( DeploymentsApi as AsyncDeploymentsApi, InstancesApi as AsyncInstancesApi, InstanceSnapshotsApi as AsyncInstanceSnapshotsApi, + PoolClaimsApi as AsyncPoolClaimsApi, SecretsApi as AsyncSecretsApi, + ServicePoolsApi as AsyncServicePoolsApi, ServicesApi as AsyncServicesApi, ) @@ -231,6 +239,8 @@ class AsyncApiClients: deployments: AsyncDeploymentsApi secrets: AsyncSecretsApi instance_snapshots: Any + service_pools: AsyncServicePoolsApi + pool_claims: AsyncPoolClaimsApi _async_api_clients_cache: Dict[Tuple[str, str], AsyncApiClients] = {} @@ -279,6 +289,8 @@ def get_async_api_clients( deployments=AsyncDeploymentsApi(api_client), secrets=AsyncSecretsApi(api_client), instance_snapshots=AsyncInstanceSnapshotsApi(api_client), + service_pools=AsyncServicePoolsApi(api_client), + pool_claims=AsyncPoolClaimsApi(api_client), ) _async_api_clients_cache[cache_key] = clients return clients @@ -826,3 +838,24 @@ def __init__(self, status_code: int, message: str): class EgressPolicyError(SandboxError): """Raised when egress policy arguments are invalid or conflicting""" + + +class PoolClaimError(SandboxError): + """Raised when claiming a sandbox from a service pool fails""" + + +class ServicePoolError(SandboxError): + """Raised when a service pool operation fails""" + + +class ServiceTerminalStateError(SandboxError): + """Raised when a service reaches a state that will never become ready""" + + def __init__(self, service_id: str, status: Any): + self.service_id = service_id + self.status = status + status_value = getattr(status, "value", status) + super().__init__( + f"Service '{service_id}' reached terminal state '{status_value}' " + f"and will not become ready." + ) From a520881d6c71ae142f0a49d59d6622addc661974 Mon Sep 17 00:00:00 2001 From: sfroment Date: Thu, 24 Sep 2026 18:13:34 +0200 Subject: [PATCH 06/14] feat: add Sandbox.list with lazy handles Lists type-SANDBOX services with CLI-parity pagination (100 per page). Handles carry no executor secret; the first connected op raises NoSandboxSecretError naming the get_from_id fix instead of a generic SandboxError. --- koyeb/sandbox/executor_client.py | 7 +- koyeb/sandbox/sandbox.py | 98 +++++++++++++++++++++++++ koyeb/sandbox/test_sandbox_list.py | 114 +++++++++++++++++++++++++++++ 3 files changed, 218 insertions(+), 1 deletion(-) create mode 100644 koyeb/sandbox/test_sandbox_list.py diff --git a/koyeb/sandbox/executor_client.py b/koyeb/sandbox/executor_client.py index 6fcea309..72b49076 100644 --- a/koyeb/sandbox/executor_client.py +++ b/koyeb/sandbox/executor_client.py @@ -15,6 +15,7 @@ from .utils import ( DEFAULT_HTTP_TIMEOUT, + NoSandboxSecretError, SandboxError, SandboxRequestError, SandboxServiceError, @@ -39,7 +40,11 @@ def validate(self) -> None: if not self.public_url: raise ValueError("Unable to get sandbox URL") if not self.secret: - raise ValueError("Sandbox secret not available") + raise NoSandboxSecretError( + "Sandbox secret not available — this handle is not " + "executor-connected (e.g. it came from Sandbox.list()); use " + "Sandbox.get_from_id() for a connected handle" + ) def _build_headers(conn_info: ConnectionInfo) -> Dict[str, str]: diff --git a/koyeb/sandbox/sandbox.py b/koyeb/sandbox/sandbox.py index e2bec2dc..0411586b 100644 --- a/koyeb/sandbox/sandbox.py +++ b/koyeb/sandbox/sandbox.py @@ -661,6 +661,59 @@ def get_from_id( return sandbox + @classmethod + def list( + cls, + app_id: Optional[str] = None, + name: Optional[str] = None, + api_token: Optional[str] = None, + host: Optional[str] = None, + ) -> List["Sandbox"]: + """ + List sandbox services. + + Paginates services of type SANDBOX (100 per page, mirroring the CLI). + Returns lazily-connected handles: they carry no executor secret, so + connected operations raise NoSandboxSecretError — use + ``Sandbox.get_from_id(handle.id)`` for a connected handle. + + Args: + app_id: Optional app filter + name: Optional name filter + api_token: Koyeb API token (defaults to KOYEB_API_TOKEN env var) + host: Koyeb API host (defaults to KOYEB_API_HOST env var) + + Returns: + List[Sandbox]: Lazy handles for every sandbox service + """ + clients = get_api_clients(api_token, host) + sandboxes: List["Sandbox"] = [] + limit = 100 + offset = 0 + while True: + reply = clients.services.list_services( + app_id=app_id, + name=name, + types=["SANDBOX"], + limit=str(limit), + offset=str(offset), + ) + for service in reply.services or []: + sandboxes.append( + cls( + sandbox_id=service.id, + app_id=service.app_id, + service_id=service.id, + name=service.name, + api_token=api_token, + host=host, + ) + ) + offset += limit + if offset >= (reply.count or 0): + break + return sandboxes + def snapshot( self, name: str, @@ -2125,6 +2178,51 @@ async def _delete_created_app() -> None: return sandbox + @classmethod + async def list( + cls, + app_id: Optional[str] = None, + name: Optional[str] = None, + api_token: Optional[str] = None, + host: Optional[str] = None, + ) -> List["AsyncSandbox"]: + """ + List sandbox services (async twin of :meth:`Sandbox.list`). + + Returns lazily-connected handles without executor secrets; use + ``AsyncSandbox.get_from_id(handle.id)`` for a connected handle. + """ + from .utils import get_async_api_clients + + clients = get_async_api_clients(api_token, host) + sandboxes: List["AsyncSandbox"] = [] + limit = 100 + offset = 0 + while True: + reply = await clients.services.list_services( + app_id=app_id, + name=name, + types=["SANDBOX"], + limit=str(limit), + offset=str(offset), + ) + for service in reply.services or []: + sandboxes.append( + cls( + sandbox_id=service.id, + app_id=service.app_id, + service_id=service.id, + name=service.name, + api_token=api_token, + host=host, + ) + ) + offset += limit + if offset >= (reply.count or 0): + break + return sandboxes + + async def _async_is_deployment_healthy(self) -> bool: """Check deployment health via async API.""" try: diff --git a/koyeb/sandbox/test_sandbox_list.py b/koyeb/sandbox/test_sandbox_list.py new file mode 100644 index 00000000..6d6c3e43 --- /dev/null +++ b/koyeb/sandbox/test_sandbox_list.py @@ -0,0 +1,114 @@ +import asyncio +import unittest +from types import SimpleNamespace +from unittest.mock import patch + +from koyeb.sandbox.executor_client import ConnectionInfo +from koyeb.sandbox.sandbox import AsyncSandbox, Sandbox +from koyeb.sandbox.utils import NoSandboxSecretError, SandboxError, create_sandbox_client + + +def _service(idx): + return SimpleNamespace( + id=f"svc-{idx}", + app_id=f"app-{idx}", + name=f"sb-{idx}", + ) + + +class FakeListServicesApi: + """Realistic pagination: up to 100 items per page, count totals.""" + + def __init__(self, count=150): + self.calls = [] + self._count = count + + def list_services(self, **kwargs): + self.calls.append(kwargs) + limit = int(kwargs.get("limit") or 100) + offset = int(kwargs.get("offset") or 0) + services = [ + _service(i) for i in range(offset, min(offset + limit, self._count)) + ] + return SimpleNamespace(services=services, count=self._count, has_next=False) + + +class FakeAsyncListServicesApi(FakeListServicesApi): + async def list_services(self, **kwargs): + return FakeListServicesApi.list_services(self, **kwargs) + + +class TestSandboxList(unittest.TestCase): + def test_filters_types_and_paginates(self): + services = FakeListServicesApi(count=150) + with patch( + "koyeb.sandbox.sandbox.get_api_clients", + return_value=SimpleNamespace(services=services), + ): + found = Sandbox.list(app_id="app-9", name="sb", api_token="tok") + self.assertEqual(len(found), 150) + self.assertEqual(found[0].service_id, "svc-0") + self.assertEqual(found[149].service_id, "svc-149") + self.assertEqual(len(services.calls), 2) + first, second = services.calls + self.assertEqual(first.get("types"), ["SANDBOX"]) + self.assertEqual(first.get("app_id"), "app-9") + self.assertEqual(first.get("name"), "sb") + self.assertEqual(first.get("limit"), "100") + self.assertEqual(first.get("offset"), "0") + self.assertEqual(second.get("offset"), "100") + + def test_handles_are_lazy(self): + services = FakeListServicesApi(count=1) + with patch( + "koyeb.sandbox.sandbox.get_api_clients", + return_value=SimpleNamespace(services=services), + ): + found = Sandbox.list(api_token="tok") + self.assertIsNone(found[0].sandbox_secret) + self.assertEqual(found[0].name, "sb-0") + + def test_empty(self): + services = FakeListServicesApi(count=0) + with patch( + "koyeb.sandbox.sandbox.get_api_clients", + return_value=SimpleNamespace(services=services), + ): + found = Sandbox.list(api_token="tok") + self.assertEqual(found, []) + + +class TestAsyncSandboxList(unittest.TestCase): + def test_filters_types_and_paginates(self): + services = FakeAsyncListServicesApi(count=150) + with patch( + "koyeb.sandbox.utils.get_async_api_clients", + return_value=SimpleNamespace(services=services), + ): + found = asyncio.run(AsyncSandbox.list(app_id="app-9", api_token="tok")) + self.assertEqual(len(found), 150) + self.assertEqual(len(services.calls), 2) + self.assertEqual(services.calls[0].get("types"), ["SANDBOX"]) + self.assertIsNone(found[0].sandbox_secret) + + +class TestLazyHandleConnectedOp(unittest.TestCase): + """A lazily-connected handle (from Sandbox.list()) fails on the first + connected op with NoSandboxSecretError naming the fix.""" + + def test_validate_raises_no_sandbox_secret_error_naming_fix(self): + conn = ConnectionInfo(public_url="https://sb.example", routing_key=None, secret=None) + with self.assertRaises(NoSandboxSecretError) as cm: + conn.validate() + self.assertIn("get_from_id", str(cm.exception)) + + def test_create_sandbox_client_propagates_typed_error(self): + conn = ConnectionInfo(public_url="https://sb.example", routing_key=None, secret=None) + with self.assertRaises(NoSandboxSecretError) as cm: + create_sandbox_client(conn) + self.assertIsInstance(cm.exception, SandboxError) + self.assertIn("get_from_id", str(cm.exception)) + + +if __name__ == "__main__": + unittest.main() From 8a796077e23c4e719ea44da991b1d08a54078b03 Mon Sep 17 00:00:00 2001 From: sfroment Date: Thu, 24 Sep 2026 18:14:44 +0200 Subject: [PATCH 07/14] feat: opt-in raise_on_error for sandbox commands SandboxCommandError was exported but never raised. exec(..., raise_on_error=True) now raises it (carrying the CommandResult); default keeps returning failed results. --- koyeb/sandbox/exec.py | 126 ++++++++++++++-------- koyeb/sandbox/test_exec_raise_on_error.py | 124 +++++++++++++++++++++ 2 files changed, 205 insertions(+), 45 deletions(-) create mode 100644 koyeb/sandbox/test_exec_raise_on_error.py diff --git a/koyeb/sandbox/exec.py b/koyeb/sandbox/exec.py index 890922d2..e858003b 100644 --- a/koyeb/sandbox/exec.py +++ b/koyeb/sandbox/exec.py @@ -55,7 +55,23 @@ def output(self) -> str: class SandboxCommandError(SandboxError): - """Raised when command execution fails""" + """Raised when a sandbox command fails (opt-in via raise_on_error).""" + + def __init__(self, message: str, result: Optional["CommandResult"] = None): + super().__init__(message) + self.result = result + + +def _check_result(result: CommandResult, raise_on_error: bool) -> CommandResult: + """Raise SandboxCommandError for failed commands when opted in.""" + if raise_on_error and not result.success: + raise SandboxCommandError( + f"Command '{result.command}' failed with exit code " + f"{result.exit_code}: {result.stderr or result.stdout}", + result=result, + ) + return result + class SandboxExecutor: @@ -82,6 +98,7 @@ def __call__( on_stdout: Optional[Callable[[str], None]] = None, on_stderr: Optional[Callable[[str], None]] = None, stream: bool = True, + raise_on_error: bool = False, ) -> CommandResult: """ Execute a command in a shell synchronously. Supports streaming output via callbacks. @@ -139,24 +156,30 @@ def __call__( elif "code" in event: exit_code = event["code"] elif "error" in event and isinstance(event["error"], str): - return CommandResult( - stdout="", - stderr=event["error"], - exit_code=1, - status=CommandStatus.FAILED, - duration=time.time() - start_time, - command=command, + return _check_result( + CommandResult( + stdout="", + stderr=event["error"], + exit_code=1, + status=CommandStatus.FAILED, + duration=time.time() - start_time, + command=command, + ), + raise_on_error, ) - return CommandResult( - stdout="".join(stdout_buffer), - stderr="".join(stderr_buffer), - exit_code=exit_code, - status=( - CommandStatus.FINISHED if exit_code == 0 else CommandStatus.FAILED + return _check_result( + CommandResult( + stdout="".join(stdout_buffer), + stderr="".join(stderr_buffer), + exit_code=exit_code, + status=( + CommandStatus.FINISHED if exit_code == 0 else CommandStatus.FAILED + ), + duration=time.time() - start_time, + command=command, ), - duration=time.time() - start_time, - command=command, + raise_on_error, ) # Use regular run for non-streaming execution @@ -167,13 +190,16 @@ def __call__( stderr = response.get("stderr", "") exit_code = response.get("code", 0) - return CommandResult( - stdout=stdout, - stderr=stderr, - exit_code=exit_code, - status=(CommandStatus.FINISHED if exit_code == 0 else CommandStatus.FAILED), - duration=time.time() - start_time, - command=command, + return _check_result( + CommandResult( + stdout=stdout, + stderr=stderr, + exit_code=exit_code, + status=(CommandStatus.FINISHED if exit_code == 0 else CommandStatus.FAILED), + duration=time.time() - start_time, + command=command, + ), + raise_on_error, ) @@ -199,6 +225,7 @@ async def __call__( on_stdout: Optional[Callable[[str], None]] = None, on_stderr: Optional[Callable[[str], None]] = None, stream: bool = True, + raise_on_error: bool = False, ) -> CommandResult: """ Execute a command in a shell asynchronously. Supports streaming output via callbacks. @@ -257,24 +284,30 @@ async def __call__( elif "code" in event: exit_code = event["code"] elif "error" in event and isinstance(event["error"], str): - return CommandResult( - stdout="", - stderr=event["error"], - exit_code=1, - status=CommandStatus.FAILED, - duration=time.time() - start_time, - command=command, + return _check_result( + CommandResult( + stdout="", + stderr=event["error"], + exit_code=1, + status=CommandStatus.FAILED, + duration=time.time() - start_time, + command=command, + ), + raise_on_error, ) - return CommandResult( - stdout="".join(stdout_buffer), - stderr="".join(stderr_buffer), - exit_code=exit_code, - status=( - CommandStatus.FINISHED if exit_code == 0 else CommandStatus.FAILED + return _check_result( + CommandResult( + stdout="".join(stdout_buffer), + stderr="".join(stderr_buffer), + exit_code=exit_code, + status=( + CommandStatus.FINISHED if exit_code == 0 else CommandStatus.FAILED + ), + duration=time.time() - start_time, + command=command, ), - duration=time.time() - start_time, - command=command, + raise_on_error, ) # Use native async for non-streaming execution @@ -287,11 +320,14 @@ async def __call__( stderr = response.get("stderr", "") exit_code = response.get("code", 0) - return CommandResult( - stdout=stdout, - stderr=stderr, - exit_code=exit_code, - status=(CommandStatus.FINISHED if exit_code == 0 else CommandStatus.FAILED), - duration=time.time() - start_time, - command=command, + return _check_result( + CommandResult( + stdout=stdout, + stderr=stderr, + exit_code=exit_code, + status=(CommandStatus.FINISHED if exit_code == 0 else CommandStatus.FAILED), + duration=time.time() - start_time, + command=command, + ), + raise_on_error, ) diff --git a/koyeb/sandbox/test_exec_raise_on_error.py b/koyeb/sandbox/test_exec_raise_on_error.py new file mode 100644 index 00000000..d6b2dab9 --- /dev/null +++ b/koyeb/sandbox/test_exec_raise_on_error.py @@ -0,0 +1,124 @@ +import asyncio +import unittest +from unittest.mock import patch + +from koyeb.sandbox.exec import ( + AsyncSandboxExecutor, + CommandResult, + CommandStatus, + SandboxCommandError, + SandboxExecutor, +) + + +class FakeSyncClient: + def __init__(self, events=None, run_response=None): + self._events = events or [] + self._run_response = run_response or {} + + def run_streaming(self, cmd=None, cwd=None, env=None, timeout=None): + yield from self._events + + def run(self, cmd=None, cwd=None, env=None, timeout=None): + return self._run_response + + +class FakeAsyncClient: + def __init__(self, events=None, run_response=None): + self._events = events or [] + self._run_response = run_response or {} + + async def run_streaming(self, cmd=None, cwd=None, env=None, timeout=None): + for event in self._events: + yield event + + async def run(self, cmd=None, cwd=None, env=None, timeout=None): + return self._run_response + + +def _exec(client, **kwargs): + executor = SandboxExecutor(None) + with patch.object(SandboxExecutor, "_get_client", return_value=client): + return executor("cmd", **kwargs) + + +def _exec_async(client, **kwargs): + executor = AsyncSandboxExecutor(None) + with patch.object(AsyncSandboxExecutor, "_get_async_client", return_value=client): + + async def run(): + return await executor("cmd", **kwargs) + + return asyncio.run(run()) + + +class TestRaiseOnErrorOptIn(unittest.TestCase): + """Default behavior unchanged: a failed command returns a failed + CommandResult. With raise_on_error=True, a failed command raises + SandboxCommandError carrying the result — so the exported class is no + longer dead code.""" + + def test_default_returns_failed_result(self): + client = FakeSyncClient( + events=[{"stream": "stdout", "data": "out"}, {"code": 1}] + ) + result = _exec(client) + self.assertFalse(result.success) + self.assertEqual(result.exit_code, 1) + + def test_raise_on_error_streaming_failure(self): + client = FakeSyncClient( + events=[{"stream": "stdout", "data": "out"}, {"code": 1}] + ) + with self.assertRaises(SandboxCommandError) as cm: + _exec(client, raise_on_error=True) + self.assertIsInstance(cm.exception.result, CommandResult) + self.assertEqual(cm.exception.result.exit_code, 1) + self.assertIn("exit code 1", str(cm.exception)) + + def test_raise_on_error_error_event(self): + client = FakeSyncClient(events=[{"error": "failed to start"}]) + with self.assertRaises(SandboxCommandError): + _exec(client, raise_on_error=True) + + def test_raise_on_error_success_does_not_raise(self): + client = FakeSyncClient( + events=[{"stream": "stdout", "data": "hi"}, {"code": 0}] + ) + result = _exec(client, raise_on_error=True) + self.assertTrue(result.success) + + def test_raise_on_error_non_streaming(self): + client = FakeSyncClient(run_response={"stdout": "", "stderr": "boom", "code": 2}) + with self.assertRaises(SandboxCommandError) as cm: + _exec(client, stream=False, raise_on_error=True) + self.assertEqual(cm.exception.result.stderr, "boom") + # default still returns the failed result + result = _exec(FakeSyncClient(run_response={"stdout": "", "stderr": "boom", "code": 2}), stream=False) + self.assertEqual(result.status, CommandStatus.FAILED) + + +class TestRaiseOnErrorAsyncMirror(unittest.TestCase): + def test_default_returns_failed_result(self): + client = FakeAsyncClient( + events=[{"stream": "stdout", "data": "out"}, {"code": 1}] + ) + result = _exec_async(client) + self.assertFalse(result.success) + + def test_raise_on_error_streaming_failure(self): + client = FakeAsyncClient( + events=[{"stream": "stderr", "data": "bad"}, {"code": 1}] + ) + with self.assertRaises(SandboxCommandError) as cm: + _exec_async(client, raise_on_error=True) + self.assertEqual(cm.exception.result.exit_code, 1) + + def test_raise_on_error_non_streaming(self): + client = FakeAsyncClient(run_response={"stdout": "", "stderr": "x", "code": 3}) + with self.assertRaises(SandboxCommandError): + _exec_async(client, stream=False, raise_on_error=True) + + +if __name__ == "__main__": + unittest.main() From 81d7800198f64dc3a100008e53fd6b406c493aff Mon Sep 17 00:00:00 2001 From: sfroment Date: Fri, 25 Sep 2026 14:06:23 +0200 Subject: [PATCH 08/14] fix: align async create defaults and guard caller apps MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The async twin silently built a different sandbox than sync: always-on (idle_timeout 0) with mesh disabled, where sync scales to zero (300) with mesh auto. Aligned, and pinned by a parity suite that compares every sync/async twin's signatures, defaults, order, and kind. cleanup_on_failure also stops deleting a caller-provided app whole — only the service this call created — and sync update_network_policy passes self.host like its async twin. --- koyeb/sandbox/sandbox.py | 56 ++++-- koyeb/sandbox/test_create_cleanup.py | 104 +++++++++++ koyeb/sandbox/test_exec_raise_on_error.py | 18 ++ koyeb/sandbox/test_pool.py | 1 - koyeb/sandbox/test_sync_async_parity.py | 201 ++++++++++++++++++++++ koyeb/sandbox/test_utils.py | 46 +++++ koyeb/sandbox/utils.py | 2 +- 7 files changed, 407 insertions(+), 21 deletions(-) create mode 100644 koyeb/sandbox/test_sync_async_parity.py diff --git a/koyeb/sandbox/sandbox.py b/koyeb/sandbox/sandbox.py index 0411586b..567d7537 100644 --- a/koyeb/sandbox/sandbox.py +++ b/koyeb/sandbox/sandbox.py @@ -127,6 +127,9 @@ def __init__( self.poll_interval = poll_interval self.host = host self.snapshot_id = snapshot_id + # Owned apps are deleted with the sandbox; caller-provided apps keep + # their unrelated services, so delete() removes only the service. + self._owns_app = True self._created_at = time.time() self._sandbox_url: Optional[Tuple[str, Optional[str]]] = None self._domain: Optional[str] = None @@ -163,7 +166,7 @@ def create( delete_after_delay: int = 0, delete_after_inactivity_delay: int = 0, app_id: Optional[str] = None, - enable_mesh: bool = None, + enable_mesh: Optional[bool] = None, poll_interval: float = DEFAULT_POLL_INTERVAL, entrypoint: Optional[List[str]] = None, command: Optional[str] = None, @@ -210,7 +213,7 @@ def create( delete_after_inactivity_delay: If >0, automatically delete the sandbox if service sleeps due to inactivity after this many seconds. app_id: If provided, create the sandbox service in an existing app instead of creating a new one. - enable_mesh: Enable or disable mesh for this sandbox. Disabled by default + enable_mesh: Mesh tri-state: None (default) = auto, True = enabled, False = disabled poll_interval: Time between health checks in seconds when wait_ready is True (default: 0.5) entrypoint: Override the default entrypoint of the Docker image (e.g., ["/bin/sh", "-c"]) command: Override the default command of the Docker image (e.g., "python app.py") @@ -372,7 +375,7 @@ def _create_sync( region: Optional[str] = None, api_token: Optional[str] = None, timeout: int = 300, - idle_timeout: int = 0, + idle_timeout: int = 300, enable_tcp_proxy: bool = False, privileged: bool = False, registry_secret: Optional[str] = None, @@ -381,7 +384,7 @@ def _create_sync( delete_after_delay: int = 0, delete_after_inactivity_delay: int = 0, app_id: Optional[str] = None, - enable_mesh: bool = None, + enable_mesh: Optional[bool] = None, poll_interval: float = DEFAULT_POLL_INTERVAL, entrypoint: Optional[List[str]] = None, command: Optional[str] = None, @@ -541,7 +544,7 @@ def _delete_created_app() -> None: _delete_created_app() raise - return cls( + sandbox = cls( sandbox_id=name, app_id=app_id, service_id=service_id, @@ -552,6 +555,8 @@ def _delete_created_app() -> None: host=host, snapshot_id=snapshot_id, ) + sandbox._owns_app = created_app + return sandbox @classmethod def get_from_id( @@ -717,7 +722,7 @@ def list( def snapshot( self, name: str, - snapshot_type: "SnapshotType" = None, + snapshot_type: Optional["SnapshotType"] = None, wait_available: bool = True, timeout: int = 600, ) -> "Snapshot": @@ -1076,7 +1081,11 @@ def wait_tcp_proxy_ready( def delete(self) -> None: """Delete the sandbox instance.""" clients = get_api_clients(self.api_token, self.host) - clients.apps.delete_app(self.app_id) + if self._owns_app: + clients.apps.delete_app(self.app_id) + else: + # Caller-provided app: deleting it would destroy unrelated services. + clients.services.delete_service(id=self.service_id) def _get_url_and_header_from_metadata(self) -> Optional[Tuple[str, str]]: """ @@ -1295,7 +1304,11 @@ def _check_executor_health(self) -> bool: return False def is_healthy(self) -> bool: - """Check if sandbox is healthy and ready for operations""" + """Check if sandbox is healthy and ready for operations. + + Raises SandboxDeploymentError when the deployment reached a terminal + state (e.g. STOPPED) — classification fails closed. + """ # Check deployment status first to avoid sending traffic to a non-ready sandbox if not self._is_deployment_healthy(): return False @@ -1634,7 +1647,7 @@ def update_network_policy( egress=EgressPolicy(mode=EgressPolicyMode.EGRESS_POLICY_MODE_DEFAULT) ) try: - clients = get_api_clients(self.api_token) + clients = get_api_clients(self.api_token, self.host) services_api = clients.services deployments_api = clients.deployments service_response = services_api.get_service(self.service_id) @@ -1835,7 +1848,7 @@ async def create( region: Optional[str] = None, api_token: Optional[str] = None, timeout: int = 300, - idle_timeout: int = 0, + idle_timeout: int = 300, enable_tcp_proxy: bool = False, privileged: bool = False, registry_secret: Optional[str] = None, @@ -1844,7 +1857,7 @@ async def create( delete_after_delay: int = 0, delete_after_inactivity_delay: int = 0, app_id: Optional[str] = None, - enable_mesh: bool = False, + enable_mesh: Optional[bool] = None, poll_interval: float = DEFAULT_POLL_INTERVAL, entrypoint: Optional[List[str]] = None, command: Optional[str] = None, @@ -1893,7 +1906,7 @@ async def create( delete_after_inactivity_delay: If >0, automatically delete the sandbox if service sleeps due to inactivity after this many seconds. app_id: If provided, create the sandbox service in an existing app instead of creating a new one. - enable_mesh: Enable or disable mesh for this sandbox. Disabled by default + enable_mesh: Mesh tri-state: None (default) = auto, True = enabled, False = disabled poll_interval: Time between health checks in seconds when wait_ready is True (default: 0.5) entrypoint: Override the default entrypoint of the Docker image (e.g., ["/bin/sh", "-c"]) command: Override the default command of the Docker image (e.g., "python app.py") @@ -2153,6 +2166,7 @@ async def _delete_created_app() -> None: host=host, snapshot_id=actual_snapshot_id, ) + sandbox._owns_app = created_app if wait_ready: try: @@ -2222,7 +2236,6 @@ async def list( break return sandboxes - async def _async_is_deployment_healthy(self) -> bool: """Check deployment health via async API.""" try: @@ -2350,9 +2363,6 @@ async def wait_tcp_proxy_ready( while time.time() - start_time < timeout: from .utils import get_async_api_clients - from koyeb.api_async.api.deployments_api import ( - DeploymentsApi as AsyncDeploymentsApi, - ) try: clients = get_async_api_clients(self.api_token, self.host) @@ -2386,12 +2396,16 @@ async def delete(self) -> None: from .utils import get_async_api_clients clients = get_async_api_clients(self.api_token, self.host) - await clients.apps.delete_app(self.app_id) + if self._owns_app: + await clients.apps.delete_app(self.app_id) + else: + # Caller-provided app: deleting it would destroy unrelated services. + await clients.services.delete_service(id=self.service_id) async def snapshot( self, name: str, - snapshot_type: "SnapshotType" = None, + snapshot_type: Optional["SnapshotType"] = None, wait_available: bool = True, timeout: int = 600, ) -> "Snapshot": @@ -2546,7 +2560,11 @@ async def create_from_snapshot( return await cls.create(**create_params) async def is_healthy(self) -> bool: - """Check if sandbox is healthy and ready for operations asynchronously.""" + """Check if sandbox is healthy and ready for operations asynchronously. + + Raises SandboxDeploymentError when the deployment reached a terminal + state (e.g. STOPPED) — classification fails closed. + """ if not await self._async_is_deployment_healthy(): return False return await self._async_check_executor_health() diff --git a/koyeb/sandbox/test_create_cleanup.py b/koyeb/sandbox/test_create_cleanup.py index 5212e6c3..66fc5de1 100644 --- a/koyeb/sandbox/test_create_cleanup.py +++ b/koyeb/sandbox/test_create_cleanup.py @@ -31,12 +31,16 @@ def delete_app(self, app_id): class FakeServices: def __init__(self, exc=None): self.exc = exc + self.deleted = [] def create_service(self, service): if self.exc is not None: raise self.exc return SimpleNamespace(service=SimpleNamespace(id="svc-1")) + def delete_service(self, id): + self.deleted.append(id) + def _fake_sync_clients(exc=None): return SimpleNamespace(apps=FakeApps(), services=FakeServices(exc=exc)) @@ -58,12 +62,16 @@ async def delete_app(self, app_id): class FakeAsyncServices: def __init__(self, exc=None): self.exc = exc + self.deleted = [] async def create_service(self, service): if self.exc is not None: raise self.exc return SimpleNamespace(service=SimpleNamespace(id="svc-1")) + async def delete_service(self, id): + self.deleted.append(id) + def _fake_async_clients(exc=None): return SimpleNamespace(apps=FakeAsyncApps(), services=FakeAsyncServices(exc=exc)) @@ -188,6 +196,47 @@ def test_sync_success_does_not_delete(self): delete.assert_not_called() self.assertEqual(sb.service_id, "svc-1") + def test_async_cleanup_on_failure_false_keeps_sandbox(self): + clients = _fake_async_clients() + with patch( + "koyeb.sandbox.utils.get_async_api_clients", return_value=clients + ): + with patch.object(AsyncSandbox, "wait_ready", return_value=False): + with patch.object(AsyncSandbox, "delete") as delete: + with self.assertRaises(SandboxTimeoutError) as cm: + asyncio.run( + AsyncSandbox.create( + api_token="tok", timeout=1, cleanup_on_failure=False + ) + ) + delete.assert_not_called() + self.assertIn("wait_ready() again", str(cm.exception)) + + def test_async_cleanup_failure_preserves_original_error(self): + clients = _fake_async_clients() + with patch( + "koyeb.sandbox.utils.get_async_api_clients", return_value=clients + ): + with patch.object(AsyncSandbox, "wait_ready", return_value=False): + with patch.object( + AsyncSandbox, "delete", side_effect=RuntimeError("api down") + ) as delete: + with self.assertRaises(SandboxTimeoutError) as cm: + asyncio.run(AsyncSandbox.create(api_token="tok", timeout=1)) + self.assertEqual(delete.await_count, 1) + self.assertNotIsInstance(cm.exception, RuntimeError) + + def test_async_success_does_not_delete(self): + clients = _fake_async_clients() + with patch( + "koyeb.sandbox.utils.get_async_api_clients", return_value=clients + ): + with patch.object(AsyncSandbox, "wait_ready", return_value=True): + with patch.object(AsyncSandbox, "delete") as delete: + sb = asyncio.run(AsyncSandbox.create(api_token="tok")) + delete.assert_not_called() + self.assertEqual(sb.service_id, "svc-1") + def test_async_timeout_deletes_and_says_so(self): clients = _fake_async_clients() with patch( @@ -219,5 +268,60 @@ def test_async_terminal_error_deletes_and_annotates(self): self.assertIn("The sandbox was deleted.", str(cm.exception)) +class TestCallerAppCleanup(unittest.TestCase): + """Wait-failure cleanup must never delete a caller-provided app — only + the sandbox service this call created inside it.""" + + def test_sync_timeout_keeps_caller_app_deletes_service(self): + clients = _fake_sync_clients() + with patch( + "koyeb.sandbox.sandbox.get_api_clients", return_value=clients + ): + with patch.object(Sandbox, "wait_ready", return_value=False): + with self.assertRaises(SandboxTimeoutError): + Sandbox.create( + api_token="tok", app_id="existing-app", timeout=1 + ) + self.assertEqual(clients.apps.deleted, []) + self.assertEqual(clients.services.deleted, ["svc-1"]) + + def test_sync_timeout_deletes_app_created_by_call(self): + clients = _fake_sync_clients() + with patch( + "koyeb.sandbox.sandbox.get_api_clients", return_value=clients + ): + with patch.object(Sandbox, "wait_ready", return_value=False): + with self.assertRaises(SandboxTimeoutError): + Sandbox.create(api_token="tok", timeout=1) + self.assertEqual(clients.apps.deleted, ["app-1"]) + self.assertEqual(clients.services.deleted, []) + + def test_async_timeout_keeps_caller_app_deletes_service(self): + clients = _fake_async_clients() + with patch( + "koyeb.sandbox.utils.get_async_api_clients", return_value=clients + ): + with patch.object(AsyncSandbox, "wait_ready", return_value=False): + with self.assertRaises(SandboxTimeoutError): + asyncio.run( + AsyncSandbox.create( + api_token="tok", app_id="existing-app", timeout=1 + ) + ) + self.assertEqual(clients.apps.deleted, []) + self.assertEqual(clients.services.deleted, ["svc-1"]) + + def test_async_timeout_deletes_app_created_by_call(self): + clients = _fake_async_clients() + with patch( + "koyeb.sandbox.utils.get_async_api_clients", return_value=clients + ): + with patch.object(AsyncSandbox, "wait_ready", return_value=False): + with self.assertRaises(SandboxTimeoutError): + asyncio.run(AsyncSandbox.create(api_token="tok", timeout=1)) + self.assertEqual(clients.apps.deleted, ["app-1"]) + self.assertEqual(clients.services.deleted, []) + + if __name__ == "__main__": unittest.main() diff --git a/koyeb/sandbox/test_exec_raise_on_error.py b/koyeb/sandbox/test_exec_raise_on_error.py index d6b2dab9..d1257c39 100644 --- a/koyeb/sandbox/test_exec_raise_on_error.py +++ b/koyeb/sandbox/test_exec_raise_on_error.py @@ -113,12 +113,30 @@ def test_raise_on_error_streaming_failure(self): with self.assertRaises(SandboxCommandError) as cm: _exec_async(client, raise_on_error=True) self.assertEqual(cm.exception.result.exit_code, 1) + self.assertIn("exit code 1", str(cm.exception)) def test_raise_on_error_non_streaming(self): client = FakeAsyncClient(run_response={"stdout": "", "stderr": "x", "code": 3}) with self.assertRaises(SandboxCommandError): _exec_async(client, stream=False, raise_on_error=True) + def test_default_non_streaming_returns_failed_result(self): + client = FakeAsyncClient(run_response={"stdout": "", "stderr": "boom", "code": 2}) + result = _exec_async(client, stream=False) + self.assertEqual(result.status, CommandStatus.FAILED) + + def test_raise_on_error_error_event(self): + client = FakeAsyncClient(events=[{"error": "failed to start"}]) + with self.assertRaises(SandboxCommandError): + _exec_async(client, raise_on_error=True) + + def test_raise_on_error_success_does_not_raise(self): + client = FakeAsyncClient( + events=[{"stream": "stdout", "data": "hi"}, {"code": 0}] + ) + result = _exec_async(client, raise_on_error=True) + self.assertTrue(result.success) + if __name__ == "__main__": unittest.main() diff --git a/koyeb/sandbox/test_pool.py b/koyeb/sandbox/test_pool.py index fce5ac62..d941d823 100644 --- a/koyeb/sandbox/test_pool.py +++ b/koyeb/sandbox/test_pool.py @@ -1,5 +1,4 @@ import asyncio -import time import unittest import uuid from types import SimpleNamespace diff --git a/koyeb/sandbox/test_sync_async_parity.py b/koyeb/sandbox/test_sync_async_parity.py new file mode 100644 index 00000000..3f8cac48 --- /dev/null +++ b/koyeb/sandbox/test_sync_async_parity.py @@ -0,0 +1,201 @@ +"""Pins sync/async signature parity across the sandbox layer. + +The Python SDK is the reference implementation for the client family, so async +twins must not silently drift from their sync originals. +""" + +import ast +import inspect +import os +import unittest + +from koyeb.sandbox.exec import AsyncSandboxExecutor, SandboxExecutor +from koyeb.sandbox.executor_client import AsyncSandboxClient, SandboxClient +from koyeb.sandbox.filesystem import ( + AsyncSandboxFilesystem, + SandboxFilesystem, +) +from koyeb.sandbox.pool import ( + AsyncServicePool, + ServicePool, + claim, + claim_async, + get_claim, + get_claim_async, + list_claims, + list_claims_async, + wait_claim_ready, + wait_claim_ready_async, +) +from koyeb.sandbox.sandbox import ( + AsyncSandbox, + Sandbox, + _cleanup_after_failure, + _cleanup_after_failure_async, +) +from koyeb.sandbox.utils import ( + create_async_sandbox_client, + create_sandbox_client, + get_api_clients, + get_async_api_clients, +) + +CLASS_PAIRS = [ + ("Sandbox", Sandbox, AsyncSandbox), + ("ServicePool", ServicePool, AsyncServicePool), + ("SandboxExecutor", SandboxExecutor, AsyncSandboxExecutor), + ("SandboxFilesystem", SandboxFilesystem, AsyncSandboxFilesystem), + ("SandboxClient", SandboxClient, AsyncSandboxClient), +] + +FUNCTION_PAIRS = [ + ("claim", claim, claim_async), + ("get_claim", get_claim, get_claim_async), + ("list_claims", list_claims, list_claims_async), + ("wait_claim_ready", wait_claim_ready, wait_claim_ready_async), + ("_cleanup_after_failure", _cleanup_after_failure, _cleanup_after_failure_async), + ("get_api_clients", get_api_clients, get_async_api_clients), + ("create_sandbox_client", create_sandbox_client, create_async_sandbox_client), +] + +# AsyncSandbox.__init__ forwards to Sandbox.__init__ via *args/**kwargs. +STRUCTURAL_ALLOWLIST = {("Sandbox", "__init__")} + +# Sync-only public surface; async either inlines these or lacks a twin. +SYNC_ONLY_PUBLIC_ALLOWLIST = {"get_domain", "get_tcp_proxy_info", "template"} + + +def _params(fn): + """Parameter map with self/cls stripped so bound and unbound forms compare.""" + params = list(inspect.signature(fn).parameters.values()) + if params and params[0].name in ("self", "cls"): + params = params[1:] + return {p.name: p for p in params} + + +def _own_callable_names(cls): + return { + name + for name in vars(cls) + if callable(getattr(cls, name, None)) + } + + +class TestSyncAsyncSignatureParity(unittest.TestCase): + def _assert_twins_match(self, label, sync_fn, async_fn, allow_structural=False): + sync_params = _params(sync_fn) + async_params = _params(async_fn) + shared = set(sync_params) + if not allow_structural: + # Positional callers depend on order and kind, not just names. + self.assertEqual( + [(p.name, p.kind) for p in sync_params.values()], + [(p.name, p.kind) for p in async_params.values()], + f"{label}: parameter order or kind differs", + ) + else: + shared &= set(async_params) + for name in sorted(shared): + self.assertEqual( + sync_params[name].default, + async_params[name].default, + f"{label}: default for '{name}' differs", + ) + + def test_async_create_matches_sync_defaults(self): + # Explicit canary: keeps the flagship drift readable as the sweep grows. + sync_params = _params(Sandbox.create) + async_params = _params(AsyncSandbox.create) + self.assertEqual( + sync_params["idle_timeout"].default, + async_params["idle_timeout"].default, + "AsyncSandbox.create idle_timeout default drifted from sync", + ) + self.assertEqual( + sync_params["enable_mesh"].default, + async_params["enable_mesh"].default, + "AsyncSandbox.create enable_mesh default drifted from sync", + ) + + def test_class_method_twins_have_matching_signatures(self): + for name, sync_cls, async_cls in CLASS_PAIRS: + shared = _own_callable_names(sync_cls) & _own_callable_names(async_cls) + for method in sorted(shared): + self._assert_twins_match( + f"{name}.{method}", + getattr(sync_cls, method), + getattr(async_cls, method), + allow_structural=(name, method) in STRUCTURAL_ALLOWLIST, + ) + + def test_module_function_twins_have_matching_signatures(self): + for name, sync_fn, async_fn in FUNCTION_PAIRS: + self._assert_twins_match(name, sync_fn, async_fn) + + def test_sync_only_public_methods_are_pinned(self): + # Methods without an async override are invisible to the twins + # check; adding one requires an explicit decision recorded here. + sync_only = _own_callable_names(Sandbox) - _own_callable_names(AsyncSandbox) + sync_only = {name for name in sync_only if not name.startswith("_")} + self.assertEqual(SYNC_ONLY_PUBLIC_ALLOWLIST, sync_only) + + +class TestNoneDefaultsAreOptional(unittest.TestCase): + """A None default with a bare annotation lies to type checkers.""" + + def test_no_bare_annotation_with_none_default(self): + violations = self._find_violations() + self.assertEqual( + [], violations, "Non-Optional annotations with None default found" + ) + + @staticmethod + def _find_violations(): + violations = [] + sandbox_dir = os.path.dirname(os.path.abspath(__file__)) + for fname in sorted(os.listdir(sandbox_dir)): + if not fname.endswith(".py") or fname.startswith("test_"): + continue + with open(os.path.join(sandbox_dir, fname)) as f: + tree = ast.parse(f.read()) + for node in ast.walk(tree): + if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): + violations.extend( + TestNoneDefaultsAreOptional._check_function(fname, node) + ) + return violations + + @staticmethod + def _check_function(fname, fn): + violations = [] + pos = fn.args.posonlyargs + fn.args.args + for default, arg in zip(fn.args.defaults, pos[len(pos) - len(fn.args.defaults):]): + violations.extend( + TestNoneDefaultsAreOptional._check_arg(fname, fn, arg, default) + ) + for arg, default in zip(fn.args.kwonlyargs, fn.args.kw_defaults): + if default is not None: + violations.extend( + TestNoneDefaultsAreOptional._check_arg(fname, fn, arg, default) + ) + return violations + + @staticmethod + def _check_arg(fname, fn, arg, default): + if not (isinstance(default, ast.Constant) and default.value is None): + return [] + if arg.annotation is None: + return [] + ann = ast.unparse(arg.annotation) + if ( + "Optional" in ann + or "Union" in ann + or ann == "Any" + or ann.endswith("| None") + ): + return [] + return [f"{fname}:{fn.lineno} {fn.name}({arg.arg}: {ann} = None)"] + + +if __name__ == "__main__": + unittest.main() diff --git a/koyeb/sandbox/test_utils.py b/koyeb/sandbox/test_utils.py index a076a240..28114eb5 100644 --- a/koyeb/sandbox/test_utils.py +++ b/koyeb/sandbox/test_utils.py @@ -1,9 +1,11 @@ import unittest +from koyeb.api.models.deployment_mesh import DeploymentMesh from koyeb.api.models.egress_policy_mode import EgressPolicyMode from koyeb.sandbox.utils import ( EgressPolicyError, build_network_policy, + create_deployment_definition, create_docker_source, ) @@ -65,6 +67,50 @@ def test_privileged_and_registry_secret_still_work(self): self.assertEqual(ds.command, "serve") +class TestDeploymentDefinitionMapping(unittest.TestCase): + """Pins the enable_mesh and idle_timeout semantics the sync/async + default alignment depends on.""" + + def _definition(self, **kwargs): + return create_deployment_definition( + name="svc", + docker_source=create_docker_source("koyeb/sandbox"), + env_vars=[], + instance_type="micro", + **kwargs, + ) + + def test_enable_mesh_tri_state(self): + self.assertEqual( + self._definition(enable_mesh=None).mesh, DeploymentMesh.DEPLOYMENT_MESH_AUTO + ) + self.assertEqual( + self._definition(enable_mesh=True).mesh, + DeploymentMesh.DEPLOYMENT_MESH_ENABLED, + ) + self.assertEqual( + self._definition(enable_mesh=False).mesh, + DeploymentMesh.DEPLOYMENT_MESH_DISABLED, + ) + + def test_default_idle_timeout_scales_to_zero(self): + scaling = self._definition().scalings[0] + self.assertEqual(scaling.min, 0) + self.assertEqual(scaling.targets[0].sleep_idle_delay.deep_sleep_value, 300) + + def test_idle_timeout_zero_is_always_on(self): + scaling = self._definition(idle_timeout=0).scalings[0] + self.assertEqual(scaling.min, 1) + self.assertIsNone(scaling.targets) + + def test_light_sleep_mode(self): + delay = self._definition( + idle_timeout=120, _experimental_enable_light_sleep=True + ).scalings[0].targets[0].sleep_idle_delay + self.assertEqual(delay.light_sleep_value, 120) + self.assertEqual(delay.deep_sleep_value, 3900) + + class TestBuildEgressPolicy(unittest.TestCase): """Tests for build_network_policy validation and normalization.""" diff --git a/koyeb/sandbox/utils.py b/koyeb/sandbox/utils.py index 6bd2f6ce..533b184f 100644 --- a/koyeb/sandbox/utils.py +++ b/koyeb/sandbox/utils.py @@ -468,7 +468,7 @@ def create_deployment_definition( enable_tcp_proxy: bool = False, _experimental_enable_light_sleep: bool = False, _experimental_deep_sleep_value: int = 3900, - enable_mesh: bool = None, + enable_mesh: Optional[bool] = None, config_files: Optional[List[ConfigFile]] = None, network_policy: Optional[NetworkPolicy] = None, ) -> DeploymentDefinition: From aad42f33429d043b67e57635d874233109677736 Mon Sep 17 00:00:00 2001 From: sfroment Date: Fri, 25 Sep 2026 14:06:24 +0200 Subject: [PATCH 09/14] refactor: build deployment definition once per create twin _create_sync built the definition twice and the async twin rebuilt it inside every snapshot branch; the builders are pure, so one build per twin is behavior-identical. --- koyeb/sandbox/pool.py | 4 -- koyeb/sandbox/sandbox.py | 82 +--------------------------------------- koyeb/sandbox/utils.py | 7 ++-- 3 files changed, 4 insertions(+), 89 deletions(-) diff --git a/koyeb/sandbox/pool.py b/koyeb/sandbox/pool.py index b9154336..8d4c3781 100644 --- a/koyeb/sandbox/pool.py +++ b/koyeb/sandbox/pool.py @@ -70,10 +70,6 @@ def _claim_error_retryable(status: Any) -> bool: return status == 429 or (isinstance(status, int) and status >= 500) -def _status_value(status: Any) -> Any: - return getattr(status, "value", status) - - def claim( pool_id: str, request_id: Optional[str] = None, diff --git a/koyeb/sandbox/sandbox.py b/koyeb/sandbox/sandbox.py index 567d7537..0a9a0216 100644 --- a/koyeb/sandbox/sandbox.py +++ b/koyeb/sandbox/sandbox.py @@ -442,6 +442,7 @@ def _delete_created_app() -> None: ) try: + # Build deployment definition - used for both snapshot and non-snapshot cases env_vars = build_env_vars(env) config_file_objects = build_config_files(config_files) docker_source = create_docker_source( @@ -452,7 +453,6 @@ def _delete_created_app() -> None: command=command, args=args, ) - deployment_definition = create_deployment_definition( name=name, docker_source=docker_source, @@ -475,34 +475,6 @@ def _delete_created_app() -> None: delete_after_sleep=delete_after_inactivity_delay, ) - # Build deployment definition - used for both snapshot and non-snapshot cases - env_vars = build_env_vars(env) - config_file_objects = build_config_files(config_files) - docker_source = create_docker_source( - image, - privileged=privileged, - image_registry_secret=registry_secret, - entrypoint=entrypoint, - command=command, - args=args, - ) - deployment_definition = create_deployment_definition( - name=name, - docker_source=docker_source, - env_vars=env_vars, - instance_type=instance_type, - exposed_port_protocol=exposed_port_protocol, - region=region, - routes=routes, - idle_timeout=idle_timeout, - enable_tcp_proxy=enable_tcp_proxy, - _experimental_enable_light_sleep=_experimental_enable_light_sleep, - _experimental_deep_sleep_value=_experimental_deep_sleep_value, - enable_mesh=enable_mesh, - config_files=config_file_objects if config_file_objects else None, - network_policy=network_policy, - ) - # Handle snapshot creation based on snapshot type # For FULL snapshots, don't provide definition (API will infer it) # For FILESYSTEM snapshots, always provide definition with snapshot_id @@ -2079,32 +2051,6 @@ async def _delete_created_app() -> None: ) else: # For FILESYSTEM snapshots (or unknown), provide definition - env_vars = build_env_vars(env) - config_file_objects = build_config_files(config_files) - docker_source = create_docker_source( - image, - privileged=privileged, - image_registry_secret=registry_secret, - entrypoint=entrypoint, - command=command, - args=args, - ) - deployment_definition = create_deployment_definition( - name=name, - docker_source=docker_source, - env_vars=env_vars, - instance_type=instance_type, - exposed_port_protocol=exposed_port_protocol, - region=region, - routes=routes, - idle_timeout=idle_timeout, - enable_tcp_proxy=enable_tcp_proxy, - _experimental_enable_light_sleep=_experimental_enable_light_sleep, - _experimental_deep_sleep_value=_experimental_deep_sleep_value, - enable_mesh=enable_mesh, - config_files=config_file_objects if config_file_objects else None, - network_policy=network_policy, - ) create_service = AsyncCreateService( app_id=app_id, definition=deployment_definition.to_dict(), @@ -2114,32 +2060,6 @@ async def _delete_created_app() -> None: ) else: # No snapshot, create normally with definition - env_vars = build_env_vars(env) - config_file_objects = build_config_files(config_files) - docker_source = create_docker_source( - image, - privileged=privileged, - image_registry_secret=registry_secret, - entrypoint=entrypoint, - command=command, - args=args, - ) - deployment_definition = create_deployment_definition( - name=name, - docker_source=docker_source, - env_vars=env_vars, - instance_type=instance_type, - exposed_port_protocol=exposed_port_protocol, - region=region, - routes=routes, - idle_timeout=idle_timeout, - enable_tcp_proxy=enable_tcp_proxy, - _experimental_enable_light_sleep=_experimental_enable_light_sleep, - _experimental_deep_sleep_value=_experimental_deep_sleep_value, - enable_mesh=enable_mesh, - config_files=config_file_objects if config_file_objects else None, - network_policy=network_policy, - ) create_service = AsyncCreateService( app_id=app_id, definition=deployment_definition.to_dict(), diff --git a/koyeb/sandbox/utils.py b/koyeb/sandbox/utils.py index 533b184f..293e5dc3 100644 --- a/koyeb/sandbox/utils.py +++ b/koyeb/sandbox/utils.py @@ -491,7 +491,7 @@ def create_deployment_definition( Light Sleep reduces cold starts to ~200ms. After scaling to zero, the service stays in Light Sleep for idle_timeout seconds before going into Deep Sleep. _experimental_deep_sleep_value: Number of seconds for deep sleep when light sleep is enabled (default: 3900). Only used if _experimental_enable_light_sleep is True. Ignored otherwise. - enable_mesh: Enable or disable mesh for this sandbox. Disabled by default + enable_mesh: Mesh tri-state: None (default) = auto, True = enabled, False = disabled network_policy: Optional network policy restricting egress traffic Returns: @@ -544,13 +544,12 @@ def create_deployment_definition( scalings = [DeploymentScaling(min=min_scale, max=1, targets=targets)] # Set mesh configuration - mesh = DeploymentMesh.DEPLOYMENT_MESH_AUTO if enable_mesh is None: mesh = DeploymentMesh.DEPLOYMENT_MESH_AUTO - elif not enable_mesh: - mesh = DeploymentMesh.DEPLOYMENT_MESH_DISABLED elif enable_mesh: mesh = DeploymentMesh.DEPLOYMENT_MESH_ENABLED + else: + mesh = DeploymentMesh.DEPLOYMENT_MESH_DISABLED return DeploymentDefinition( name=name, From 12c573518e9f3bd17d3c71cdaef0efaa79fcf6b5 Mon Sep 17 00:00:00 2001 From: sfroment Date: Fri, 25 Sep 2026 12:15:07 +0200 Subject: [PATCH 10/14] fix: tell the truth when cleanup fails Cleanup helpers now report whether the delete happened so failure errors stop claiming the sandbox was deleted. Also document delete()'s app-vs-service semantics and pin the unknown-provenance (get_from_id/list) whole-app default. --- koyeb/sandbox/sandbox.py | 64 +++++++++++++------ koyeb/sandbox/test_create_cleanup.py | 93 ++++++++++++++++++++++++++++ 2 files changed, 139 insertions(+), 18 deletions(-) diff --git a/koyeb/sandbox/sandbox.py b/koyeb/sandbox/sandbox.py index 0a9a0216..c2f8e4c5 100644 --- a/koyeb/sandbox/sandbox.py +++ b/koyeb/sandbox/sandbox.py @@ -77,27 +77,32 @@ def __str__(self) -> str: return f"ExposedPort(port={self.port}, exposed_at='{self.exposed_at}')" -def _cleanup_after_failure(sandbox: "Sandbox") -> None: +def _cleanup_after_failure(sandbox: "Sandbox") -> bool: """Best-effort sandbox deletion after a failed create. Never raises: the original failure must be preserved and re-raised. + Returns whether the deletion actually happened. """ try: sandbox.delete() + return True except Exception as e: logger.warning( f"Cleanup failed, sandbox '{sandbox.name}' may still exist: {e}" ) + return False -async def _cleanup_after_failure_async(sandbox: "Sandbox") -> None: +async def _cleanup_after_failure_async(sandbox: "Sandbox") -> bool: """Async twin of _cleanup_after_failure for AsyncSandbox.delete.""" try: await sandbox.delete() + return True except Exception as e: logger.warning( f"Cleanup failed, sandbox '{sandbox.name}' may still exist: {e}" ) + return False class Sandbox: @@ -201,7 +206,6 @@ def create( - If _experimental_enable_light_sleep is True: sets light_sleep value (deep_sleep=3900) - If _experimental_enable_light_sleep is False: sets deep_sleep value - If 0: disables scale-to-zero (keep always-on) - - If None: uses default values enable_tcp_proxy: If True, enables TCP proxy for direct TCP access to port 3031 privileged: If True, run the container in privileged mode (default: False) registry_secret: Name of a Koyeb secret containing registry credentials for @@ -344,15 +348,25 @@ def create( is_ready = sandbox.wait_ready(timeout=timeout) except SandboxError as e: if cleanup_on_failure: - _cleanup_after_failure(sandbox) - e.args = (f"{e} The sandbox was deleted.",) + deleted = _cleanup_after_failure(sandbox) + outcome = ( + "The sandbox was deleted." + if deleted + else "The sandbox could not be deleted and may still exist." + ) + e.args = (f"{e} {outcome}",) raise if not is_ready: if cleanup_on_failure: - _cleanup_after_failure(sandbox) + deleted = _cleanup_after_failure(sandbox) + outcome = ( + "and was deleted" + if deleted + else "but could not be deleted and may still exist" + ) raise SandboxTimeoutError( f"Sandbox '{sandbox.name}' did not become ready within {timeout} seconds " - f"and was deleted. Create with cleanup_on_failure=False to keep a " + f"{outcome}. Create with cleanup_on_failure=False to keep a " f"timed-out sandbox for inspection." ) raise SandboxTimeoutError( @@ -396,10 +410,7 @@ def _create_sync( snapshot_type: Optional["SnapshotType"] = None, sandbox_secret: Optional[str] = None, ) -> Sandbox: - """ - Synchronous creation method that returns creation parameters. - Subclasses can override to return their own type. - """ + """Create the sandbox service and return the sandbox instance.""" network_policy = build_network_policy(block_network, outbound_allowlist) clients = get_api_clients(api_token, host) @@ -1051,7 +1062,11 @@ def wait_tcp_proxy_ready( return False def delete(self) -> None: - """Delete the sandbox instance.""" + """Delete the sandbox instance. + + Deletes the whole app for SDK-created sandboxes; only the service + when the sandbox lives in a caller-provided app. + """ clients = get_api_clients(self.api_token, self.host) if self._owns_app: clients.apps.delete_app(self.app_id) @@ -1864,7 +1879,6 @@ async def create( - If _experimental_enable_light_sleep is True: sets light_sleep value (deep_sleep uses _experimental_deep_sleep_value) - If _experimental_enable_light_sleep is False: sets deep_sleep value - If 0: disables scale-to-zero (keep always-on) - - If None: uses default values enable_tcp_proxy: If True, enables TCP proxy for direct TCP access to port 3031 privileged: If True, run the container in privileged mode (default: False) registry_secret: Name of a Koyeb secret containing registry credentials for @@ -2093,15 +2107,25 @@ async def _delete_created_app() -> None: is_ready = await sandbox.wait_ready(timeout=timeout) except SandboxError as e: if cleanup_on_failure: - await _cleanup_after_failure_async(sandbox) - e.args = (f"{e} The sandbox was deleted.",) + deleted = await _cleanup_after_failure_async(sandbox) + outcome = ( + "The sandbox was deleted." + if deleted + else "The sandbox could not be deleted and may still exist." + ) + e.args = (f"{e} {outcome}",) raise if not is_ready: if cleanup_on_failure: - await _cleanup_after_failure_async(sandbox) + deleted = await _cleanup_after_failure_async(sandbox) + outcome = ( + "and was deleted" + if deleted + else "but could not be deleted and may still exist" + ) raise SandboxTimeoutError( f"Sandbox '{sandbox.name}' did not become ready within {timeout} seconds " - f"and was deleted. Create with cleanup_on_failure=False to keep a " + f"{outcome}. Create with cleanup_on_failure=False to keep a " f"timed-out sandbox for inspection." ) raise SandboxTimeoutError( @@ -2312,7 +2336,11 @@ async def wait_tcp_proxy_ready( return False async def delete(self) -> None: - """Delete the sandbox instance asynchronously.""" + """Delete the sandbox instance asynchronously. + + Deletes the whole app for SDK-created sandboxes; only the service + when the sandbox lives in a caller-provided app. + """ from .utils import get_async_api_clients clients = get_async_api_clients(self.api_token, self.host) diff --git a/koyeb/sandbox/test_create_cleanup.py b/koyeb/sandbox/test_create_cleanup.py index 66fc5de1..44701645 100644 --- a/koyeb/sandbox/test_create_cleanup.py +++ b/koyeb/sandbox/test_create_cleanup.py @@ -184,6 +184,7 @@ def test_sync_cleanup_failure_preserves_original_error(self): Sandbox.create(api_token="tok", timeout=1) delete.assert_called_once() self.assertNotIsInstance(cm.exception, RuntimeError) + self.assertIn("could not be deleted", str(cm.exception)) def test_sync_success_does_not_delete(self): clients = self._create_ok_clients() @@ -225,6 +226,7 @@ def test_async_cleanup_failure_preserves_original_error(self): asyncio.run(AsyncSandbox.create(api_token="tok", timeout=1)) self.assertEqual(delete.await_count, 1) self.assertNotIsInstance(cm.exception, RuntimeError) + self.assertIn("could not be deleted", str(cm.exception)) def test_async_success_does_not_delete(self): clients = _fake_async_clients() @@ -322,6 +324,97 @@ def test_async_timeout_deletes_app_created_by_call(self): self.assertEqual(clients.apps.deleted, ["app-1"]) self.assertEqual(clients.services.deleted, []) + def test_sync_terminal_error_keeps_caller_app_deletes_service(self): + # The except-branch cleanup, unlike the timeout branch pinned above. + clients = _fake_sync_clients() + terminal = SandboxDeploymentError( + "Sandbox 'quick-sandbox' deployment reached status STOPPED " + "— it will not become ready; wake or redeploy the sandbox." + ) + with patch( + "koyeb.sandbox.sandbox.get_api_clients", return_value=clients + ): + with patch.object(Sandbox, "wait_ready", side_effect=terminal): + with self.assertRaises(SandboxDeploymentError) as cm: + Sandbox.create( + api_token="tok", app_id="existing-app", timeout=1 + ) + self.assertEqual(clients.apps.deleted, []) + self.assertEqual(clients.services.deleted, ["svc-1"]) + self.assertIn("The sandbox was deleted.", str(cm.exception)) + + def test_async_terminal_error_keeps_caller_app_deletes_service(self): + clients = _fake_async_clients() + terminal = SandboxDeploymentError( + "Sandbox 'quick-sandbox' deployment reached status STOPPED " + "— it will not become ready; wake or redeploy the sandbox." + ) + with patch( + "koyeb.sandbox.utils.get_async_api_clients", return_value=clients + ): + with patch.object(AsyncSandbox, "wait_ready", side_effect=terminal): + with self.assertRaises(SandboxDeploymentError) as cm: + asyncio.run( + AsyncSandbox.create( + api_token="tok", app_id="existing-app", timeout=1 + ) + ) + self.assertEqual(clients.apps.deleted, []) + self.assertEqual(clients.services.deleted, ["svc-1"]) + self.assertIn("The sandbox was deleted.", str(cm.exception)) + + def test_sync_cleanup_failure_keeps_caller_app_and_tells_truth(self): + clients = _fake_sync_clients() + + def boom(id): + raise RuntimeError("api down") + + clients.services.delete_service = boom + with patch( + "koyeb.sandbox.sandbox.get_api_clients", return_value=clients + ): + with patch.object(Sandbox, "wait_ready", return_value=False): + with self.assertRaises(SandboxTimeoutError) as cm: + Sandbox.create( + api_token="tok", app_id="existing-app", timeout=1 + ) + self.assertEqual(clients.apps.deleted, []) + self.assertIn("could not be deleted", str(cm.exception)) + + def test_async_cleanup_failure_keeps_caller_app_and_tells_truth(self): + clients = _fake_async_clients() + + async def boom(id): + raise RuntimeError("api down") + + clients.services.delete_service = boom + with patch( + "koyeb.sandbox.utils.get_async_api_clients", return_value=clients + ): + with patch.object(AsyncSandbox, "wait_ready", return_value=False): + with self.assertRaises(SandboxTimeoutError) as cm: + asyncio.run( + AsyncSandbox.create( + api_token="tok", app_id="existing-app", timeout=1 + ) + ) + self.assertEqual(clients.apps.deleted, []) + self.assertIn("could not be deleted", str(cm.exception)) + + def test_handle_built_from_id_keeps_app_delete_default(self): + # get_from_id()/list() handles have unknown provenance and keep the + # historical whole-app delete. + clients = _fake_sync_clients() + sandbox = Sandbox( + sandbox_id="s", app_id="app-x", service_id="svc-x", api_token="tok" + ) + with patch( + "koyeb.sandbox.sandbox.get_api_clients", return_value=clients + ): + sandbox.delete() + self.assertEqual(clients.apps.deleted, ["app-x"]) + self.assertEqual(clients.services.deleted, []) + if __name__ == "__main__": unittest.main() From 2f4e926af956c67e644cb630b2fbf8f9f8dc37c0 Mon Sep 17 00:00:00 2001 From: sfroment Date: Fri, 25 Sep 2026 12:15:08 +0200 Subject: [PATCH 11/14] test: pin file IO twins and matrix corners SandboxFileIO joins the class pairs; the sync-only allowlist now covers every pair; light-sleep override cells pinned. --- koyeb/sandbox/test_sync_async_parity.py | 26 ++++++++++++++++++++----- koyeb/sandbox/test_utils.py | 14 +++++++++++++ 2 files changed, 35 insertions(+), 5 deletions(-) diff --git a/koyeb/sandbox/test_sync_async_parity.py b/koyeb/sandbox/test_sync_async_parity.py index 3f8cac48..5a10c0de 100644 --- a/koyeb/sandbox/test_sync_async_parity.py +++ b/koyeb/sandbox/test_sync_async_parity.py @@ -12,7 +12,9 @@ from koyeb.sandbox.exec import AsyncSandboxExecutor, SandboxExecutor from koyeb.sandbox.executor_client import AsyncSandboxClient, SandboxClient from koyeb.sandbox.filesystem import ( + AsyncSandboxFileIO, AsyncSandboxFilesystem, + SandboxFileIO, SandboxFilesystem, ) from koyeb.sandbox.pool import ( @@ -45,6 +47,7 @@ ("ServicePool", ServicePool, AsyncServicePool), ("SandboxExecutor", SandboxExecutor, AsyncSandboxExecutor), ("SandboxFilesystem", SandboxFilesystem, AsyncSandboxFilesystem), + ("SandboxFileIO", SandboxFileIO, AsyncSandboxFileIO), ("SandboxClient", SandboxClient, AsyncSandboxClient), ] @@ -61,8 +64,16 @@ # AsyncSandbox.__init__ forwards to Sandbox.__init__ via *args/**kwargs. STRUCTURAL_ALLOWLIST = {("Sandbox", "__init__")} -# Sync-only public surface; async either inlines these or lacks a twin. -SYNC_ONLY_PUBLIC_ALLOWLIST = {"get_domain", "get_tcp_proxy_info", "template"} +# Sync-only public surface per class; async either inlines these or lacks +# a twin. New entries are deliberate decisions, not accidents. +SYNC_ONLY_PUBLIC_ALLOWLIST = { + "Sandbox": {"get_domain", "get_tcp_proxy_info", "template"}, + "ServicePool": set(), + "SandboxExecutor": set(), + "SandboxFilesystem": set(), + "SandboxFileIO": set(), + "SandboxClient": set(), +} def _params(fn): @@ -135,9 +146,14 @@ def test_module_function_twins_have_matching_signatures(self): def test_sync_only_public_methods_are_pinned(self): # Methods without an async override are invisible to the twins # check; adding one requires an explicit decision recorded here. - sync_only = _own_callable_names(Sandbox) - _own_callable_names(AsyncSandbox) - sync_only = {name for name in sync_only if not name.startswith("_")} - self.assertEqual(SYNC_ONLY_PUBLIC_ALLOWLIST, sync_only) + for name, sync_cls, async_cls in CLASS_PAIRS: + sync_only = _own_callable_names(sync_cls) - _own_callable_names(async_cls) + sync_only = {n for n in sync_only if not n.startswith("_")} + self.assertEqual( + SYNC_ONLY_PUBLIC_ALLOWLIST[name], + sync_only, + f"{name}: sync-only public methods", + ) class TestNoneDefaultsAreOptional(unittest.TestCase): diff --git a/koyeb/sandbox/test_utils.py b/koyeb/sandbox/test_utils.py index 28114eb5..8deddee8 100644 --- a/koyeb/sandbox/test_utils.py +++ b/koyeb/sandbox/test_utils.py @@ -110,6 +110,20 @@ def test_light_sleep_mode(self): self.assertEqual(delay.light_sleep_value, 120) self.assertEqual(delay.deep_sleep_value, 3900) + def test_custom_idle_timeout_deep_sleep_only(self): + delay = self._definition(idle_timeout=90).scalings[0].targets[0].sleep_idle_delay + self.assertEqual(delay.deep_sleep_value, 90) + self.assertIsNone(delay.light_sleep_value) + + def test_light_sleep_deep_sleep_override(self): + delay = self._definition( + idle_timeout=90, + _experimental_enable_light_sleep=True, + _experimental_deep_sleep_value=600, + ).scalings[0].targets[0].sleep_idle_delay + self.assertEqual(delay.light_sleep_value, 90) + self.assertEqual(delay.deep_sleep_value, 600) + class TestBuildEgressPolicy(unittest.TestCase): """Tests for build_network_policy validation and normalization.""" From 6317822b3fec5ff36da77dda12ab50b7c999d98f Mon Sep 17 00:00:00 2001 From: sfroment Date: Fri, 25 Sep 2026 14:06:24 +0200 Subject: [PATCH 12/14] docs: regenerate reference docs, scope out test modules Regenerated to match the current API surface (the earlier regen claim was empty), with an explicit module list in generate_docs.sh so test doubles never leak into the reference docs. --- docs/api.md | 12365 +++++++++++++++++++++++++------------ docs/api_async.md | 12319 ++++++++++++++++++++++++------------ docs/sandbox.md | 4474 ++++++++------ koyeb/sandbox/exec.py | 1 - scripts/generate_docs.sh | 13 +- 5 files changed, 19464 insertions(+), 9708 deletions(-) diff --git a/docs/api.md b/docs/api.md index 68d9187a..f9ef6841 100644 --- a/docs/api.md +++ b/docs/api.md @@ -71,7 +71,9 @@ This class contains various settings of the API client. :param tls_server_name: SSL/TLS Server Name Indication (SNI). Set this to the SNI value expected by the server. :param connection_pool_maxsize: Connection pool max size. None in the constructor is coerced to 100 for async and cpu_count * 5 for sync. :param proxy: Proxy URL. + :param no_proxy: Comma-separated hosts that bypass the proxy. :param proxy_headers: Proxy headers. + :param proxy_ssl_context: SSL context used only for the TLS handshake with the proxy itself, independent of the destination TLS settings. :param safe_chars_for_path_param: Safe characters for path parameter encoding. :param client_side_validation: Enable client-side validation. Default True. :param socket_options: Options to pass down to the underlying urllib3 socket. @@ -127,8 +129,10 @@ def __init__(host: Optional[str] = None, tls_server_name: Optional[str] = None, connection_pool_maxsize: Optional[int] = None, proxy: Optional[str] = None, + no_proxy: Optional[str] = None, proxy_headers: Optional[Any] = None, - safe_chars_for_path_param: str = '', + proxy_ssl_context: Optional[ssl.SSLContext] = None, + safe_chars_for_path_param: str = "", client_side_validation: bool = True, socket_options: Optional[Any] = None, datetime_format: str = "%Y-%m-%dT%H:%M:%S.%f%z", @@ -413,6 +417,63 @@ def host(value: str) -> None Fix base path. + + +#### proxy + +```python +@property +def proxy() -> Optional[str] +``` + +Proxy URL + + + +# koyeb/api.test.test\_service\_pool + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestServicePool Objects + +```python +class TestServicePool(unittest.TestCase) +``` + +ServicePool unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> ServicePool +``` + +Test ServicePool +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testServicePool + +```python +def testServicePool() +``` + +Test ServicePool + # koyeb/api.test.test\_get\_metrics\_reply\_metric @@ -538,6 +599,52 @@ def testKgitproxyIndexingStatus() Test KgitproxyIndexingStatus + + +# koyeb/api.test.test\_persistent\_volume\_region\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestPersistentVolumeRegionUsage Objects + +```python +class TestPersistentVolumeRegionUsage(unittest.TestCase) +``` + +PersistentVolumeRegionUsage unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> PersistentVolumeRegionUsage +``` + +Test PersistentVolumeRegionUsage +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testPersistentVolumeRegionUsage + +```python +def testPersistentVolumeRegionUsage() +``` + +Test PersistentVolumeRegionUsage + # koyeb/api.test.test\_declare\_stage\_progress\_request @@ -2512,6 +2619,52 @@ def testEgressPolicy() Test EgressPolicy + + +# koyeb/api.test.test\_create\_service\_pool + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestCreateServicePool Objects + +```python +class TestCreateServicePool(unittest.TestCase) +``` + +CreateServicePool unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> CreateServicePool +``` + +Test CreateServicePool +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testCreateServicePool + +```python +def testCreateServicePool() +``` + +Test CreateServicePool + # koyeb/api.test.test\_desired\_deployment @@ -3313,6 +3466,52 @@ def testNotificationList() Test NotificationList + + +# koyeb/api.test.test\_update\_service\_pool\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestUpdateServicePoolReply Objects + +```python +class TestUpdateServicePoolReply(unittest.TestCase) +``` + +UpdateServicePoolReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> UpdateServicePoolReply +``` + +Test UpdateServicePoolReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testUpdateServicePoolReply + +```python +def testUpdateServicePoolReply() +``` + +Test UpdateServicePoolReply + # koyeb/api.test.test\_user @@ -5633,6 +5832,52 @@ def testRegionalDeploymentEvent() Test RegionalDeploymentEvent + + +# koyeb/api.test.test\_mesh + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestMesh Objects + +```python +class TestMesh(unittest.TestCase) +``` + +Mesh unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> Mesh +``` + +Test Mesh +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testMesh + +```python +def testMesh() +``` + +Test Mesh + # koyeb/api.test.test\_reset\_password\_request @@ -7580,6 +7825,52 @@ Test case for remove_organization_member Remove an organization member + + +# koyeb/api.test.test\_update\_service\_pool + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestUpdateServicePool Objects + +```python +class TestUpdateServicePool(unittest.TestCase) +``` + +UpdateServicePool unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> UpdateServicePool +``` + +Test UpdateServicePool +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testUpdateServicePool + +```python +def testUpdateServicePool() +``` + +Test UpdateServicePool + # koyeb/api.test.test\_update\_organization\_reply @@ -7902,6 +8193,52 @@ def testCreateInstanceSnapshotRequest() Test CreateInstanceSnapshotRequest + + +# koyeb/api.test.test\_pool\_claim\_request + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestPoolClaimRequest Objects + +```python +class TestPoolClaimRequest(unittest.TestCase) +``` + +PoolClaimRequest unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> PoolClaimRequest +``` + +Test PoolClaimRequest +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testPoolClaimRequest + +```python +def testPoolClaimRequest() +``` + +Test PoolClaimRequest + # koyeb/api.test @@ -9280,6 +9617,39 @@ def testGitSource() Test GitSource + + +# koyeb/api.test.test\_mesh\_scope + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestMeshScope Objects + +```python +class TestMeshScope(unittest.TestCase) +``` + +MeshScope unit test stubs + + + +#### testMeshScope + +```python +def testMeshScope() +``` + +Test MeshScope + # koyeb/api.test.test\_instance\_event @@ -9372,6 +9742,52 @@ def testDockerBuilder() Test DockerBuilder + + +# koyeb/api.test.test\_create\_service\_pool\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestCreateServicePoolReply Objects + +```python +class TestCreateServicePoolReply(unittest.TestCase) +``` + +CreateServicePoolReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> CreateServicePoolReply +``` + +Test CreateServicePoolReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testCreateServicePoolReply + +```python +def testCreateServicePoolReply() +``` + +Test CreateServicePoolReply + # koyeb/api.test.test\_get\_region\_reply @@ -10594,6 +11010,98 @@ Test case for update_secret2 Update Secret + + +# koyeb/api.test.test\_instance\_type\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestInstanceTypeUsage Objects + +```python +class TestInstanceTypeUsage(unittest.TestCase) +``` + +InstanceTypeUsage unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> InstanceTypeUsage +``` + +Test InstanceTypeUsage +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testInstanceTypeUsage + +```python +def testInstanceTypeUsage() +``` + +Test InstanceTypeUsage + + + +# koyeb/api.test.test\_list\_service\_pools\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestListServicePoolsReply Objects + +```python +class TestListServicePoolsReply(unittest.TestCase) +``` + +ListServicePoolsReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> ListServicePoolsReply +``` + +Test ListServicePoolsReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testListServicePoolsReply + +```python +def testListServicePoolsReply() +``` + +Test ListServicePoolsReply + # koyeb/api.test.test\_update\_user\_settings\_request @@ -11929,6 +12437,52 @@ def testSecurityPolicies() Test SecurityPolicies + + +# koyeb/api.test.test\_instance\_snapshot\_type\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestInstanceSnapshotTypeUsage Objects + +```python +class TestInstanceSnapshotTypeUsage(unittest.TestCase) +``` + +InstanceSnapshotTypeUsage unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> InstanceSnapshotTypeUsage +``` + +Test InstanceSnapshotTypeUsage +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testInstanceSnapshotTypeUsage + +```python +def testInstanceSnapshotTypeUsage() +``` + +Test InstanceSnapshotTypeUsage + # koyeb/api.test.test\_credentials\_api @@ -12024,6 +12578,52 @@ Test case for update_credential2 Update credential + + +# koyeb/api.test.test\_get\_service\_pool\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestGetServicePoolReply Objects + +```python +class TestGetServicePoolReply(unittest.TestCase) +``` + +GetServicePoolReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> GetServicePoolReply +``` + +Test GetServicePoolReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testGetServicePoolReply + +```python +def testGetServicePoolReply() +``` + +Test GetServicePoolReply + # koyeb/api.test.test\_user\_role\_role @@ -13444,6 +14044,52 @@ def testRegionAvailability() Test RegionAvailability + + +# koyeb/api.test.test\_list\_pool\_claim\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestListPoolClaimReply Objects + +```python +class TestListPoolClaimReply(unittest.TestCase) +``` + +ListPoolClaimReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> ListPoolClaimReply +``` + +Test ListPoolClaimReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testListPoolClaimReply + +```python +def testListPoolClaimReply() +``` + +Test ListPoolClaimReply + # koyeb/api.test.test\_login\_method\_reply @@ -15011,6 +15657,39 @@ def testInstanceAvailability() Test InstanceAvailability + + +# koyeb/api.test.test\_service\_pool\_status + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestServicePoolStatus Objects + +```python +class TestServicePoolStatus(unittest.TestCase) +``` + +ServicePoolStatus unit test stubs + + + +#### testServicePoolStatus + +```python +def testServicePoolStatus() +``` + +Test ServicePoolStatus + # koyeb/api.test.test\_snapshot @@ -16442,6 +17121,52 @@ def testMetricName() Test MetricName + + +# koyeb/api.test.test\_pool\_claim + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestPoolClaim Objects + +```python +class TestPoolClaim(unittest.TestCase) +``` + +PoolClaim unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> PoolClaim +``` + +Test PoolClaim +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testPoolClaim + +```python +def testPoolClaim() +``` + +Test PoolClaim + # koyeb/api.test.test\_deployment\_scaling\_target\_requests\_per\_second @@ -16489,6 +17214,98 @@ def testDeploymentScalingTargetRequestsPerSecond() Test DeploymentScalingTargetRequestsPerSecond + + +# koyeb/api.test.test\_get\_pool\_claim\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestGetPoolClaimReply Objects + +```python +class TestGetPoolClaimReply(unittest.TestCase) +``` + +GetPoolClaimReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> GetPoolClaimReply +``` + +Test GetPoolClaimReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testGetPoolClaimReply + +```python +def testGetPoolClaimReply() +``` + +Test GetPoolClaimReply + + + +# koyeb/api.test.test\_quota\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestQuotaUsage Objects + +```python +class TestQuotaUsage(unittest.TestCase) +``` + +QuotaUsage unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> QuotaUsage +``` + +Test QuotaUsage +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testQuotaUsage + +```python +def testQuotaUsage() +``` + +Test QuotaUsage + # koyeb/api.test.test\_get\_organization\_reply @@ -17580,6 +18397,52 @@ def testDatabaseUsage() Test DatabaseUsage + + +# koyeb/api.test.test\_get\_organization\_quotas\_usage\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestGetOrganizationQuotasUsageReply Objects + +```python +class TestGetOrganizationQuotasUsageReply(unittest.TestCase) +``` + +GetOrganizationQuotasUsageReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> GetOrganizationQuotasUsageReply +``` + +Test GetOrganizationQuotasUsageReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testGetOrganizationQuotasUsageReply + +```python +def testGetOrganizationQuotasUsageReply() +``` + +Test GetOrganizationQuotasUsageReply + # koyeb/api.test.test\_kgitproxy\_git\_hub\_repository @@ -18631,6 +19494,52 @@ def testKsearchService() Test KsearchService + + +# koyeb/api.test.test\_pool\_claim\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestPoolClaimReply Objects + +```python +class TestPoolClaimReply(unittest.TestCase) +``` + +PoolClaimReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> PoolClaimReply +``` + +Test PoolClaimReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testPoolClaimReply + +```python +def testPoolClaimReply() +``` + +Test PoolClaimReply + # koyeb/api.test.test\_decline\_organization\_invitation\_reply @@ -19447,6 +20356,39 @@ def testDeactivateOrganizationReply() Test DeactivateOrganizationReply + + +# koyeb/api.test.test\_pool\_claim\_status + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestPoolClaimStatus Objects + +```python +class TestPoolClaimStatus(unittest.TestCase) +``` + +PoolClaimStatus unit test stubs + + + +#### testPoolClaimStatus + +```python +def testPoolClaimStatus() +``` + +Test PoolClaimStatus + # koyeb/api.test.test\_domain\_load\_balancer\_quotas @@ -20019,6 +20961,65 @@ def testCreateDomainReply() Test CreateDomainReply + + +# koyeb/api.test.test\_pool\_claims\_api + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestPoolClaimsApi Objects + +```python +class TestPoolClaimsApi(unittest.TestCase) +``` + +PoolClaimsApi unit test stubs + + + +#### test\_claim + +```python +def test_claim() -> None +``` + +Test case for claim + +Claim a sandbox from a service pool + + + +#### test\_get\_claim + +```python +def test_get_claim() -> None +``` + +Test case for get_claim + +Get a claim + + + +#### test\_list\_claim + +```python +def test_list_claim() -> None +``` + +Test case for list_claim + +List claims of a service pool + # koyeb/api.test.test\_accept\_organization\_invitation\_reply @@ -20635,6 +21636,75 @@ def testAppStatus() Test AppStatus + + +# koyeb/api.test.test\_service\_pools\_api + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestServicePoolsApi Objects + +```python +class TestServicePoolsApi(unittest.TestCase) +``` + +ServicePoolsApi unit test stubs + + + +#### test\_create\_service\_pool + +```python +def test_create_service_pool() -> None +``` + +Test case for create_service_pool + +Create a ServicePool + + + +#### test\_get\_service\_pool + +```python +def test_get_service_pool() -> None +``` + +Test case for get_service_pool + +Get a ServicePool + + + +#### test\_list\_service\_pools + +```python +def test_list_service_pools() -> None +``` + +Test case for list_service_pools + +List ServicePools + + + +#### test\_update\_service\_pool + +```python +def test_update_service_pool() -> None +``` + +Test case for update_service_pool + # koyeb/api.test.test\_persistent\_volume @@ -21223,6 +22293,37 @@ Generated by OpenAPI Generator (https://openapi-generator.tech) Do not edit the class manually. + + +#### contenttype\_matches + +```python +def contenttype_matches(contenttype, maintype, subtype) +``` + +Matches the given contenttype against the given type and subtype + +**Arguments**: + +- `contenttype`: the content type to match +- `maintype`: the expected maintype +- `subtype`: the expected subtype + +**Returns**: + +`bool`: `true` when the given content type matches the given type and subtype, +regardless of the presence of mime type parameters, otherwise returns `false`. + + + +#### should\_bypass\_proxies + +```python +def should_bypass_proxies(url: str, no_proxy: str) -> bool +``` + +Return whether ``url`` matches the comma-separated ``no_proxy`` rules. + ## RESTResponse Objects @@ -23963,6 +25064,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of ListSnapshotsReply from a dict + + +# koyeb/api.models.pool\_claim + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## PoolClaim Objects + +```python +class PoolClaim(BaseModel) +``` + +PoolClaim + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of PoolClaim from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of PoolClaim from a dict + # koyeb/api.models.canny\_auth\_reply @@ -26033,6 +27216,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of Token from a dict + + +# koyeb/api.models.get\_service\_pool\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## GetServicePoolReply Objects + +```python +class GetServicePoolReply(BaseModel) +``` + +GetServicePoolReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of GetServicePoolReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of GetServicePoolReply from a dict + # koyeb/api.models.deployment\_proxy\_port @@ -26675,6 +27940,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of CreateCompose from a dict + + +# koyeb/api.models.pool\_claim\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## PoolClaimReply Objects + +```python +class PoolClaimReply(BaseModel) +``` + +PoolClaimReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of PoolClaimReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of PoolClaimReply from a dict + # koyeb/api.models.payment\_method @@ -28151,6 +29498,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of NeonPostgresDatabase from a dict + + +# koyeb/api.models.update\_service\_pool + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## UpdateServicePool Objects + +```python +class UpdateServicePool(BaseModel) +``` + +UpdateServicePool + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of UpdateServicePool from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of UpdateServicePool from a dict + # koyeb/api.models.decline\_organization\_invitation\_reply @@ -29859,6 +31288,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of UpdateUserSettingsRequest from a dict + + +# koyeb/api.models.create\_service\_pool + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## CreateServicePool Objects + +```python +class CreateServicePool(BaseModel) +``` + +CreateServicePool + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of CreateServicePool from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of CreateServicePool from a dict + # koyeb/api.models.user\_role\_role @@ -31191,6 +32702,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of DigitalOceanRegistryConfiguration from a dict + + +# koyeb/api.models.instance\_snapshot\_type\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## InstanceSnapshotTypeUsage Objects + +```python +class InstanceSnapshotTypeUsage(BaseModel) +``` + +InstanceSnapshotTypeUsage + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of InstanceSnapshotTypeUsage from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of InstanceSnapshotTypeUsage from a dict + # koyeb/api.models.list\_user\_organization\_invitations\_reply @@ -33097,6 +34690,40 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of LoginRequest from a dict + + +# koyeb/api.models.pool\_claim\_status + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## PoolClaimStatus Objects + +```python +class PoolClaimStatus(str, Enum) +``` + +PoolClaimStatus + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Self +``` + +Create an instance of PoolClaimStatus from a JSON string + # koyeb/api.models.update\_snapshot\_request @@ -34456,6 +36083,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of GithubInstallationRequest from a dict + + +# koyeb/api.models.get\_pool\_claim\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## GetPoolClaimReply Objects + +```python +class GetPoolClaimReply(BaseModel) +``` + +GetPoolClaimReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of GetPoolClaimReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of GetPoolClaimReply from a dict + # koyeb/api.models.deployment\_scaling\_target\_average\_mem @@ -35426,6 +37135,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of PersistentVolume from a dict + + +# koyeb/api.models.list\_service\_pools\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## ListServicePoolsReply Objects + +```python +class ListServicePoolsReply(BaseModel) +``` + +ListServicePoolsReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of ListServicePoolsReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of ListServicePoolsReply from a dict + # koyeb/api.models.service\_state @@ -35672,6 +37463,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of LogEntry from a dict + + +# koyeb/api.models.mesh + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## Mesh Objects + +```python +class Mesh(BaseModel) +``` + +Mesh groups the mesh scope selector and the (optional) custom mesh name. Kept inside NetworkPolicy so scope/name and other network-policy dimensions (egress, future inbound) live together. + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of Mesh from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of Mesh from a dict + # koyeb/api.models.database\_deployment\_metadata @@ -35836,6 +37709,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of GitLabRegistryConfiguration from a dict + + +# koyeb/api.models.list\_pool\_claim\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## ListPoolClaimReply Objects + +```python +class ListPoolClaimReply(BaseModel) +``` + +ListPoolClaimReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of ListPoolClaimReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of ListPoolClaimReply from a dict + # koyeb/api.models.delete\_organization\_reply @@ -38206,6 +40161,88 @@ def from_json(cls, json_str: str) -> Self Create an instance of MetricName from a JSON string + + +# koyeb/api.models.quota\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## QuotaUsage Objects + +```python +class QuotaUsage(BaseModel) +``` + +QuotaUsage carries an organization's current resource consumption alongside the corresponding plan limits (from the caller's InternalToken.Quotas). Paused services are included in services_used but excluded from memory / instances_by_type / proxy_ports totals, matching enforcement semantics. + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of QuotaUsage from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of QuotaUsage from a dict + # koyeb/api.models.regional\_deployment @@ -38650,6 +40687,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of CreatePaymentAuthorizationReply from a dict + + +# koyeb/api.models.update\_service\_pool\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## UpdateServicePoolReply Objects + +```python +class UpdateServicePoolReply(BaseModel) +``` + +UpdateServicePoolReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of UpdateServicePoolReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of UpdateServicePoolReply from a dict + # koyeb/api.models.get\_idenfy\_token\_reply @@ -42496,6 +44615,40 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of DeploymentPort from a dict + + +# koyeb/api.models.mesh\_scope + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## MeshScope Objects + +```python +class MeshScope(str, Enum) +``` + +MeshScope selects which set of services can communicate over the mesh. Only meaningful when the mesh is on (i.e. DeploymentMesh is ENABLED, or AUTO and the service is eligible). UNSPECIFIED defers to the organization-level default (workspace-scoped since KOYEB-6062, legacy organizations opted back to organization scope via use_organization_level_mesh). - MESH_SCOPE_ORGANIZATION: Private communication between services in the same organization (mesh label k-). - MESH_SCOPE_WORKSPACE: Private communication between services in the same workspace/project (mesh label pr_). - MESH_SCOPE_APP: Private communication between services in the same app (mesh label app_). - MESH_SCOPE_CUSTOM: Private communication between services in the same workspace that share the same NetworkPolicy.mesh.name. Server-computed label is scoped by workspace, so the same custom name in different workspaces never collides. + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Self +``` + +Create an instance of MeshScope from a JSON string + # koyeb/api.models.stream\_result\_of\_log\_entry @@ -42961,7 +45114,7 @@ Do not edit the class manually. class GoogleProtobufAny(BaseModel) ``` -GoogleProtobufAny +`Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } @@ -43945,6 +46098,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of TriggerGitDeploymentMetadata from a dict + + +# koyeb/api.models.pool\_claim\_request + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## PoolClaimRequest Objects + +```python +class PoolClaimRequest(BaseModel) +``` + +PoolClaimRequest + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of PoolClaimRequest from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of PoolClaimRequest from a dict + # koyeb/api.models.update\_project\_reply @@ -44191,6 +46426,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of GetRegionReply from a dict + + +# koyeb/api.models.create\_service\_pool\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## CreateServicePoolReply Objects + +```python +class CreateServicePoolReply(BaseModel) +``` + +CreateServicePoolReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of CreateServicePoolReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of CreateServicePoolReply from a dict + # koyeb/api.models.autocomplete\_request @@ -46241,6 +48558,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of UpdateAppReply from a dict + + +# koyeb/api.models.persistent\_volume\_region\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## PersistentVolumeRegionUsage Objects + +```python +class PersistentVolumeRegionUsage(BaseModel) +``` + +PersistentVolumeRegionUsage + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of PersistentVolumeRegionUsage from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of PersistentVolumeRegionUsage from a dict + # koyeb/api.models.update\_organization\_reply @@ -47197,6 +49596,88 @@ def from_json(cls, json_str: str) -> Self Create an instance of DomainStatus from a JSON string + + +# koyeb/api.models.service\_pool + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## ServicePool Objects + +```python +class ServicePool(BaseModel) +``` + +ServicePool + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of ServicePool from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of ServicePool from a dict + # koyeb/api.models.next\_invoice\_reply\_line\_period @@ -47361,6 +49842,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of VerifyDockerImageReply from a dict + + +# koyeb/api.models.instance\_type\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## InstanceTypeUsage Objects + +```python +class InstanceTypeUsage(BaseModel) +``` + +InstanceTypeUsage + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of InstanceTypeUsage from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of InstanceTypeUsage from a dict + # koyeb/api.models.create\_instance\_snapshot\_reply @@ -47525,6 +50088,40 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of RevealSecretReply from a dict + + +# koyeb/api.models.service\_pool\_status + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## ServicePoolStatus Objects + +```python +class ServicePoolStatus(str, Enum) +``` + +ServicePoolStatus + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Self +``` + +Create an instance of ServicePoolStatus from a JSON string + # koyeb/api.models.compose\_reply @@ -48653,7 +51250,7 @@ ExecCommandIO #### data\_validate\_regular\_expression ```python -@field_validator('data') +@field_validator("data", mode="before") def data_validate_regular_expression(cls, value) ``` @@ -50508,6 +53105,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of KsearchGlobalDeployment from a dict + + +# koyeb/api.models.get\_organization\_quotas\_usage\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## GetOrganizationQuotasUsageReply Objects + +```python +class GetOrganizationQuotasUsageReply(BaseModel) +``` + +GetOrganizationQuotasUsageReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of GetOrganizationQuotasUsageReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of GetOrganizationQuotasUsageReply from a dict + # koyeb/api.models.organization\_member\_status @@ -51774,12 +54453,12 @@ Do not edit the class manually. @validate_call def canny_auth( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -51819,12 +54498,12 @@ Returns the result object. @validate_call def canny_auth_with_http_info( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -51864,12 +54543,12 @@ Returns the result object. @validate_call def canny_auth_without_preload_content( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -51909,12 +54588,12 @@ Returns the result object. @validate_call def discourse_auth( body: DiscourseAuthRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -51954,12 +54633,12 @@ Returns the result object. @validate_call def discourse_auth_with_http_info( body: DiscourseAuthRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -51999,12 +54678,12 @@ Returns the result object. @validate_call def discourse_auth_without_preload_content( body: DiscourseAuthRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52069,12 +54748,12 @@ Do not edit the class manually. ```python @validate_call def list_datacenters( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52112,12 +54791,12 @@ Returns the result object. ```python @validate_call def list_datacenters_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52155,12 +54834,12 @@ Returns the result object. ```python @validate_call def list_datacenters_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52226,12 +54905,12 @@ Do not edit the class manually. def get_subscription( id: Annotated[StrictStr, Field(description="The id of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52272,12 +54951,12 @@ Returns the result object. def get_subscription_with_http_info( id: Annotated[StrictStr, Field(description="The id of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52318,12 +54997,12 @@ Returns the result object. def get_subscription_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52390,12 +55069,12 @@ Do not edit the class manually. def get_region( id: Annotated[StrictStr, Field(description="The name of the region")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52436,12 +55115,12 @@ Returns the result object. def get_region_with_http_info( id: Annotated[StrictStr, Field(description="The name of the region")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52482,12 +55161,12 @@ Returns the result object. def get_region_without_preload_content( id: Annotated[StrictStr, Field(description="The name of the region")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52528,19 +55207,21 @@ Returns the result object. def list_regions( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, id: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for regions")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52583,19 +55264,21 @@ Returns the result object. def list_regions_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, id: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for regions")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52638,19 +55321,21 @@ Returns the result object. def list_regions_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, id: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for regions")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52719,12 +55404,12 @@ Do not edit the class manually. def get_regional_deployment( id: Annotated[StrictStr, Field(description="The id of the regional deployment")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52767,12 +55452,12 @@ Returns the result object. def get_regional_deployment_with_http_info( id: Annotated[StrictStr, Field(description="The id of the regional deployment")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52815,12 +55500,12 @@ Returns the result object. def get_regional_deployment_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the regional deployment")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52863,32 +55548,36 @@ Returns the result object. def list_regional_deployment_events( regional_deployment_id: Annotated[ Optional[StrictStr], - Field( - description="(Optional) Filter on regional deployment id")] = None, + Field(description="(Optional) Filter on regional deployment id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on regional deployment event types" - )] = None, + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52933,32 +55622,36 @@ Returns the result object. def list_regional_deployment_events_with_http_info( regional_deployment_id: Annotated[ Optional[StrictStr], - Field( - description="(Optional) Filter on regional deployment id")] = None, + Field(description="(Optional) Filter on regional deployment id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on regional deployment event types" - )] = None, + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53003,32 +55696,36 @@ Returns the result object. def list_regional_deployment_events_without_preload_content( regional_deployment_id: Annotated[ Optional[StrictStr], - Field( - description="(Optional) Filter on regional deployment id")] = None, + Field(description="(Optional) Filter on regional deployment id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on regional deployment event types" - )] = None, + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53076,17 +55773,23 @@ def list_regional_deployments( Field(description="(Optional) Filter on deployment id")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on regional deployment ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53103,6 +55806,7 @@ Experimental: use at your own risk - `deployment_id` (`str`): (Optional) Filter on deployment id - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return +- `ids` (`List[str]`): (Optional) Filter on regional deployment ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -53134,17 +55838,23 @@ def list_regional_deployments_with_http_info( Field(description="(Optional) Filter on deployment id")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on regional deployment ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53161,6 +55871,7 @@ Experimental: use at your own risk - `deployment_id` (`str`): (Optional) Filter on deployment id - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return +- `ids` (`List[str]`): (Optional) Filter on regional deployment ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -53192,17 +55903,23 @@ def list_regional_deployments_without_preload_content( Field(description="(Optional) Filter on deployment id")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on regional deployment ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53219,6 +55936,7 @@ Experimental: use at your own risk - `deployment_id` (`str`): (Optional) Filter on deployment id - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return +- `ids` (`List[str]`): (Optional) Filter on regional deployment ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -53279,13 +55997,14 @@ def verify_docker_image( Field( description= "(Optional) the id of the secret to use to authenticate to the registry" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53335,13 +56054,14 @@ def verify_docker_image_with_http_info( Field( description= "(Optional) the id of the secret to use to authenticate to the registry" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53391,13 +56111,14 @@ def verify_docker_image_without_preload_content( Field( description= "(Optional) the id of the secret to use to authenticate to the registry" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53467,12 +56188,12 @@ Do not edit the class manually. def get_account_activities( limit: Optional[StrictStr] = None, offset: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53514,12 +56235,12 @@ Returns the result object. def get_account_activities_with_http_info( limit: Optional[StrictStr] = None, offset: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53561,12 +56282,12 @@ Returns the result object. def get_account_activities_without_preload_content( limit: Optional[StrictStr] = None, offset: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53610,13 +56331,14 @@ def list_activities( offset: Optional[StrictStr] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on object type")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on object type"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53661,13 +56383,14 @@ def list_activities_with_http_info( offset: Optional[StrictStr] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on object type")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on object type"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53712,13 +56435,14 @@ def list_activities_without_preload_content( offset: Optional[StrictStr] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on object type")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on object type"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53765,12 +56489,12 @@ def list_notifications( mark_seen: Optional[StrictStr] = None, unread: Optional[StrictStr] = None, unseen: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53820,12 +56544,12 @@ def list_notifications_with_http_info( mark_seen: Optional[StrictStr] = None, unread: Optional[StrictStr] = None, unseen: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53875,12 +56599,12 @@ def list_notifications_without_preload_content( mark_seen: Optional[StrictStr] = None, unread: Optional[StrictStr] = None, unseen: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53951,12 +56675,12 @@ Do not edit the class manually. @validate_call def check_coupon( code: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53998,12 +56722,12 @@ Returns the result object. @validate_call def check_coupon_with_http_info( code: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54045,12 +56769,12 @@ Returns the result object. @validate_call def check_coupon_without_preload_content( code: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54092,12 +56816,12 @@ Returns the result object. @validate_call def redeem_coupon( body: RedeemCouponRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54138,12 +56862,12 @@ Returns the result object. @validate_call def redeem_coupon_with_http_info( body: RedeemCouponRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54185,12 +56909,12 @@ Returns the result object. @validate_call def redeem_coupon_without_preload_content( body: RedeemCouponRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54258,12 +56982,12 @@ Do not edit the class manually. @validate_call def create_credential( credential: CreateCredential, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54303,12 +57027,12 @@ Returns the result object. @validate_call def create_credential_with_http_info( credential: CreateCredential, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54348,12 +57072,12 @@ Returns the result object. @validate_call def create_credential_without_preload_content( credential: CreateCredential, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54393,12 +57117,12 @@ Returns the result object. @validate_call def delete_credential( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54437,12 +57161,12 @@ Returns the result object. @validate_call def delete_credential_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54482,12 +57206,12 @@ Returns the result object. @validate_call def delete_credential_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54527,12 +57251,12 @@ Returns the result object. @validate_call def get_credential( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54572,12 +57296,12 @@ Returns the result object. @validate_call def get_credential_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54617,12 +57341,12 @@ Returns the result object. @validate_call def get_credential_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54667,23 +57391,26 @@ def list_credentials( Field(description="(Optional) A filter for name")] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter for an organization")] = None, + Field(description="(Optional) Filter for an organization"), + ] = None, user_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter for an user")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54733,23 +57460,26 @@ def list_credentials_with_http_info( Field(description="(Optional) A filter for name")] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter for an organization")] = None, + Field(description="(Optional) Filter for an organization"), + ] = None, user_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter for an user")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54799,23 +57529,26 @@ def list_credentials_without_preload_content( Field(description="(Optional) A filter for name")] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter for an organization")] = None, + Field(description="(Optional) Filter for an organization"), + ] = None, user_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter for an user")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54862,12 +57595,12 @@ def update_credential( id: StrictStr, credential: Credential, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54911,12 +57644,12 @@ def update_credential_with_http_info( id: StrictStr, credential: Credential, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54960,12 +57693,12 @@ def update_credential_without_preload_content( id: StrictStr, credential: Credential, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55009,12 +57742,12 @@ def update_credential2( id: StrictStr, credential: Credential, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55058,12 +57791,12 @@ def update_credential2_with_http_info( id: StrictStr, credential: Credential, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55107,12 +57840,12 @@ def update_credential2_without_preload_content( id: StrictStr, credential: Credential, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55180,12 +57913,12 @@ Do not edit the class manually. @validate_call def confirm_organization_action( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55224,12 +57957,12 @@ Returns the result object. @validate_call def confirm_organization_action_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55269,12 +58002,12 @@ Returns the result object. @validate_call def confirm_organization_action_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55340,12 +58073,12 @@ Do not edit the class manually. @validate_call def create_domain( domain: CreateDomain, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55385,12 +58118,12 @@ Returns the result object. @validate_call def create_domain_with_http_info( domain: CreateDomain, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55430,12 +58163,12 @@ Returns the result object. @validate_call def create_domain_without_preload_content( domain: CreateDomain, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55475,12 +58208,12 @@ Returns the result object. @validate_call def delete_domain( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55519,12 +58252,12 @@ Returns the result object. @validate_call def delete_domain_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55564,12 +58297,12 @@ Returns the result object. @validate_call def delete_domain_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55609,12 +58342,12 @@ Returns the result object. @validate_call def get_domain( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55654,12 +58387,12 @@ Returns the result object. @validate_call def get_domain_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55699,12 +58432,12 @@ Returns the result object. @validate_call def get_domain_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55745,34 +58478,39 @@ Returns the result object. def list_domains( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, types: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) A filter for types - AUTOASSIGNED: Domain like -.koyeb.app" - )] = None, + ), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) A filter for statuses")] = None, + Field(description="(Optional) A filter for statuses"), + ] = None, app_ids: Annotated[Optional[List[StrictStr]], Field( description="(Optional) A filter for apps")] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on domain ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55790,7 +58528,7 @@ List Domains - `statuses` (`List[str]`): (Optional) A filter for statuses - `app_ids` (`List[str]`): (Optional) A filter for apps - `name` (`str`): (Optional) A filter for name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on domain ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -55819,34 +58557,39 @@ Returns the result object. def list_domains_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, types: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) A filter for types - AUTOASSIGNED: Domain like -.koyeb.app" - )] = None, + ), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) A filter for statuses")] = None, + Field(description="(Optional) A filter for statuses"), + ] = None, app_ids: Annotated[Optional[List[StrictStr]], Field( description="(Optional) A filter for apps")] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on domain ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55864,7 +58607,7 @@ List Domains - `statuses` (`List[str]`): (Optional) A filter for statuses - `app_ids` (`List[str]`): (Optional) A filter for apps - `name` (`str`): (Optional) A filter for name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on domain ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -55893,34 +58636,39 @@ Returns the result object. def list_domains_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, types: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) A filter for types - AUTOASSIGNED: Domain like -.koyeb.app" - )] = None, + ), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) A filter for statuses")] = None, + Field(description="(Optional) A filter for statuses"), + ] = None, app_ids: Annotated[Optional[List[StrictStr]], Field( description="(Optional) A filter for apps")] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on domain ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55938,7 +58686,7 @@ List Domains - `statuses` (`List[str]`): (Optional) A filter for statuses - `app_ids` (`List[str]`): (Optional) A filter for apps - `name` (`str`): (Optional) A filter for name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on domain ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -55966,12 +58714,12 @@ Returns the result object. @validate_call def refresh_domain_status( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56010,12 +58758,12 @@ Returns the result object. @validate_call def refresh_domain_status_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56055,12 +58803,12 @@ Returns the result object. @validate_call def refresh_domain_status_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56104,15 +58852,16 @@ def update_domain( update_mask: Optional[StrictStr] = None, dry_run: Annotated[ Optional[StrictBool], - Field(description= - "If set, run validation and check that the domain is available." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description= + "If set, run validation and check that the domain is available."), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56159,15 +58908,16 @@ def update_domain_with_http_info( update_mask: Optional[StrictStr] = None, dry_run: Annotated[ Optional[StrictBool], - Field(description= - "If set, run validation and check that the domain is available." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description= + "If set, run validation and check that the domain is available."), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56214,15 +58964,16 @@ def update_domain_without_preload_content( update_mask: Optional[StrictStr] = None, dry_run: Annotated[ Optional[StrictBool], - Field(description= - "If set, run validation and check that the domain is available." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description= + "If set, run validation and check that the domain is available."), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56294,94 +59045,106 @@ def query_logs( Optional[StrictStr], Field( description= - "Type of logs to retrieve, either \"build\" or \"runtime\". Defaults to \"runtime\"." - )] = None, + 'Type of logs to retrieve, either "build" or "runtime". Defaults to "runtime".' + ), + ] = None, app_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided app_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, service_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided service_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, regional_deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided regional_deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using instance_ids instead." - )] = None, + Field(description="Deprecated, prefer using instance_ids instead."), + ] = None, instance_ids: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter on the provided instance_ids. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, stream: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using streams instead.")] = None, + Field(description="Deprecated, prefer using streams instead."), + ] = None, streams: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on stream: either \"stdout\", \"stderr\" or \"koyeb\" (for system logs)." - )] = None, + '(Optional) Filter on stream: either "stdout", "stderr" or "koyeb" (for system logs).' + ), + ] = None, start: Annotated[ Optional[datetime], Field( description= "(Optional) Must always be before `end`. Defaults to 15 minutes ago." - )] = None, + ), + ] = None, end: Annotated[ Optional[datetime], Field(description= - "(Optional) Must always be after `start`. Defaults to now." - )] = None, + "(Optional) Must always be after `start`. Defaults to now."), + ] = None, order: Annotated[ Optional[StrictStr], - Field(description="(Optional) `asc` or `desc`. Defaults to `desc`." - )] = None, + Field(description="(Optional) `asc` or `desc`. Defaults to `desc`."), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) Defaults to 100. Maximum of 1000." - )] = None, + Field(description="(Optional) Defaults to 100. Maximum of 1000."), + ] = None, regex: Annotated[ Optional[StrictStr], Field( description= "(Optional) Apply a regex to filter logs. Can't be used with `text`." - )] = None, + ), + ] = None, text: Annotated[ Optional[StrictStr], Field( description= "(Optional) Looks for this string in logs. Can't be used with `regex`." - )] = None, + ), + ] = None, regions: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on the provided regions (e.g. [\"fra\", \"was\"])." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + '(Optional) Filter on the provided regions (e.g. ["fra", "was"]).' + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56439,94 +59202,106 @@ def query_logs_with_http_info( Optional[StrictStr], Field( description= - "Type of logs to retrieve, either \"build\" or \"runtime\". Defaults to \"runtime\"." - )] = None, + 'Type of logs to retrieve, either "build" or "runtime". Defaults to "runtime".' + ), + ] = None, app_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided app_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, service_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided service_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, regional_deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided regional_deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using instance_ids instead." - )] = None, + Field(description="Deprecated, prefer using instance_ids instead."), + ] = None, instance_ids: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter on the provided instance_ids. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, stream: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using streams instead.")] = None, + Field(description="Deprecated, prefer using streams instead."), + ] = None, streams: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on stream: either \"stdout\", \"stderr\" or \"koyeb\" (for system logs)." - )] = None, + '(Optional) Filter on stream: either "stdout", "stderr" or "koyeb" (for system logs).' + ), + ] = None, start: Annotated[ Optional[datetime], Field( description= "(Optional) Must always be before `end`. Defaults to 15 minutes ago." - )] = None, + ), + ] = None, end: Annotated[ Optional[datetime], Field(description= - "(Optional) Must always be after `start`. Defaults to now." - )] = None, + "(Optional) Must always be after `start`. Defaults to now."), + ] = None, order: Annotated[ Optional[StrictStr], - Field(description="(Optional) `asc` or `desc`. Defaults to `desc`." - )] = None, + Field(description="(Optional) `asc` or `desc`. Defaults to `desc`."), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) Defaults to 100. Maximum of 1000." - )] = None, + Field(description="(Optional) Defaults to 100. Maximum of 1000."), + ] = None, regex: Annotated[ Optional[StrictStr], Field( description= "(Optional) Apply a regex to filter logs. Can't be used with `text`." - )] = None, + ), + ] = None, text: Annotated[ Optional[StrictStr], Field( description= "(Optional) Looks for this string in logs. Can't be used with `regex`." - )] = None, + ), + ] = None, regions: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on the provided regions (e.g. [\"fra\", \"was\"])." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + '(Optional) Filter on the provided regions (e.g. ["fra", "was"]).' + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56584,94 +59359,106 @@ def query_logs_without_preload_content( Optional[StrictStr], Field( description= - "Type of logs to retrieve, either \"build\" or \"runtime\". Defaults to \"runtime\"." - )] = None, + 'Type of logs to retrieve, either "build" or "runtime". Defaults to "runtime".' + ), + ] = None, app_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided app_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, service_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided service_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, regional_deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided regional_deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using instance_ids instead." - )] = None, + Field(description="Deprecated, prefer using instance_ids instead."), + ] = None, instance_ids: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter on the provided instance_ids. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, stream: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using streams instead.")] = None, + Field(description="Deprecated, prefer using streams instead."), + ] = None, streams: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on stream: either \"stdout\", \"stderr\" or \"koyeb\" (for system logs)." - )] = None, + '(Optional) Filter on stream: either "stdout", "stderr" or "koyeb" (for system logs).' + ), + ] = None, start: Annotated[ Optional[datetime], Field( description= "(Optional) Must always be before `end`. Defaults to 15 minutes ago." - )] = None, + ), + ] = None, end: Annotated[ Optional[datetime], Field(description= - "(Optional) Must always be after `start`. Defaults to now." - )] = None, + "(Optional) Must always be after `start`. Defaults to now."), + ] = None, order: Annotated[ Optional[StrictStr], - Field(description="(Optional) `asc` or `desc`. Defaults to `desc`." - )] = None, + Field(description="(Optional) `asc` or `desc`. Defaults to `desc`."), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) Defaults to 100. Maximum of 1000." - )] = None, + Field(description="(Optional) Defaults to 100. Maximum of 1000."), + ] = None, regex: Annotated[ Optional[StrictStr], Field( description= "(Optional) Apply a regex to filter logs. Can't be used with `text`." - )] = None, + ), + ] = None, text: Annotated[ Optional[StrictStr], Field( description= "(Optional) Looks for this string in logs. Can't be used with `regex`." - )] = None, + ), + ] = None, regions: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on the provided regions (e.g. [\"fra\", \"was\"])." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + '(Optional) Filter on the provided regions (e.g. ["fra", "was"]).' + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56729,82 +59516,94 @@ def tail_logs( Optional[StrictStr], Field( description= - "Type of logs to retrieve, either \"build\" or \"runtime\". Defaults to \"runtime\"." - )] = None, + 'Type of logs to retrieve, either "build" or "runtime". Defaults to "runtime".' + ), + ] = None, app_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided app_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, service_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided service_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, regional_deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided regional_deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using instance_ids instead." - )] = None, + Field(description="Deprecated, prefer using instance_ids instead."), + ] = None, instance_ids: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter on the provided instance_ids. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, stream: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using streams instead.")] = None, + Field(description="Deprecated, prefer using streams instead."), + ] = None, streams: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on stream: either \"stdout\", \"stderr\" or \"koyeb\" (for system logs)." - )] = None, + '(Optional) Filter on stream: either "stdout", "stderr" or "koyeb" (for system logs).' + ), + ] = None, start: Annotated[ Optional[datetime], - Field(description="(Optional) Defaults to 24 hours ago.")] = None, + Field(description="(Optional) Defaults to 24 hours ago."), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) Defaults to 1000. Maximum of 1000." - )] = None, + Field(description="(Optional) Defaults to 1000. Maximum of 1000."), + ] = None, regex: Annotated[ Optional[StrictStr], Field( description= "(Optional) Apply a regex to filter logs. Can't be used with `text`." - )] = None, + ), + ] = None, text: Annotated[ Optional[StrictStr], Field( description= "(Optional) Looks for this string in logs. Can't be used with `regex`." - )] = None, + ), + ] = None, regions: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on the provided regions (e.g. [\"fra\", \"was\"])." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + '(Optional) Filter on the provided regions (e.g. ["fra", "was"]).' + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56860,82 +59659,94 @@ def tail_logs_with_http_info( Optional[StrictStr], Field( description= - "Type of logs to retrieve, either \"build\" or \"runtime\". Defaults to \"runtime\"." - )] = None, + 'Type of logs to retrieve, either "build" or "runtime". Defaults to "runtime".' + ), + ] = None, app_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided app_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, service_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided service_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, regional_deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided regional_deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using instance_ids instead." - )] = None, + Field(description="Deprecated, prefer using instance_ids instead."), + ] = None, instance_ids: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter on the provided instance_ids. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, stream: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using streams instead.")] = None, + Field(description="Deprecated, prefer using streams instead."), + ] = None, streams: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on stream: either \"stdout\", \"stderr\" or \"koyeb\" (for system logs)." - )] = None, + '(Optional) Filter on stream: either "stdout", "stderr" or "koyeb" (for system logs).' + ), + ] = None, start: Annotated[ Optional[datetime], - Field(description="(Optional) Defaults to 24 hours ago.")] = None, + Field(description="(Optional) Defaults to 24 hours ago."), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) Defaults to 1000. Maximum of 1000." - )] = None, + Field(description="(Optional) Defaults to 1000. Maximum of 1000."), + ] = None, regex: Annotated[ Optional[StrictStr], Field( description= "(Optional) Apply a regex to filter logs. Can't be used with `text`." - )] = None, + ), + ] = None, text: Annotated[ Optional[StrictStr], Field( description= "(Optional) Looks for this string in logs. Can't be used with `regex`." - )] = None, + ), + ] = None, regions: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on the provided regions (e.g. [\"fra\", \"was\"])." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + '(Optional) Filter on the provided regions (e.g. ["fra", "was"]).' + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56991,82 +59802,94 @@ def tail_logs_without_preload_content( Optional[StrictStr], Field( description= - "Type of logs to retrieve, either \"build\" or \"runtime\". Defaults to \"runtime\"." - )] = None, + 'Type of logs to retrieve, either "build" or "runtime". Defaults to "runtime".' + ), + ] = None, app_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided app_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, service_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided service_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, regional_deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided regional_deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using instance_ids instead." - )] = None, + Field(description="Deprecated, prefer using instance_ids instead."), + ] = None, instance_ids: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter on the provided instance_ids. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, stream: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using streams instead.")] = None, + Field(description="Deprecated, prefer using streams instead."), + ] = None, streams: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on stream: either \"stdout\", \"stderr\" or \"koyeb\" (for system logs)." - )] = None, + '(Optional) Filter on stream: either "stdout", "stderr" or "koyeb" (for system logs).' + ), + ] = None, start: Annotated[ Optional[datetime], - Field(description="(Optional) Defaults to 24 hours ago.")] = None, + Field(description="(Optional) Defaults to 24 hours ago."), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) Defaults to 1000. Maximum of 1000." - )] = None, + Field(description="(Optional) Defaults to 1000. Maximum of 1000."), + ] = None, regex: Annotated[ Optional[StrictStr], Field( description= "(Optional) Apply a regex to filter logs. Can't be used with `text`." - )] = None, + ), + ] = None, text: Annotated[ Optional[StrictStr], Field( description= "(Optional) Looks for this string in logs. Can't be used with `regex`." - )] = None, + ), + ] = None, regions: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on the provided regions (e.g. [\"fra\", \"was\"])." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + '(Optional) Filter on the provided regions (e.g. ["fra", "was"]).' + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57145,12 +59968,12 @@ Do not edit the class manually. @validate_call def autocomplete( body: AutocompleteRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57192,12 +60015,12 @@ Returns the result object. @validate_call def autocomplete_with_http_info( body: AutocompleteRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57239,12 +60062,12 @@ Returns the result object. @validate_call def autocomplete_without_preload_content( body: AutocompleteRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57288,12 +60111,12 @@ def create_service( service: CreateService, dry_run: Annotated[Optional[StrictBool], Field(description="If set only run validation")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57336,12 +60159,12 @@ def create_service_with_http_info( service: CreateService, dry_run: Annotated[Optional[StrictBool], Field(description="If set only run validation")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57384,12 +60207,12 @@ def create_service_without_preload_content( service: CreateService, dry_run: Annotated[Optional[StrictBool], Field(description="If set only run validation")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57431,12 +60254,12 @@ Returns the result object. def delete_service( id: Annotated[StrictStr, Field(description="The id of the entity to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57478,12 +60301,12 @@ Returns the result object. def delete_service_with_http_info( id: Annotated[StrictStr, Field(description="The id of the entity to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57526,12 +60349,12 @@ Returns the result object. def delete_service_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the entity to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57574,12 +60397,12 @@ Returns the result object. def delete_service_scaling( id: Annotated[StrictStr, Field(description="The id of the service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57621,12 +60444,12 @@ Returns the result object. def delete_service_scaling_with_http_info( id: Annotated[StrictStr, Field(description="The id of the service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57669,12 +60492,12 @@ Returns the result object. def delete_service_scaling_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57717,12 +60540,12 @@ Returns the result object. def get_service( id: Annotated[StrictStr, Field(description="The id of the Service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57763,12 +60586,12 @@ Returns the result object. def get_service_with_http_info( id: Annotated[StrictStr, Field(description="The id of the Service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57809,12 +60632,12 @@ Returns the result object. def get_service_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the Service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57855,12 +60678,12 @@ Returns the result object. def get_service_scaling( id: Annotated[StrictStr, Field(description="The id of the service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57903,12 +60726,12 @@ Returns the result object. def get_service_scaling_with_http_info( id: Annotated[StrictStr, Field(description="The id of the service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57951,12 +60774,12 @@ Returns the result object. def get_service_scaling_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58002,26 +60825,30 @@ def list_service_events( Field(description="(Optional) Filter on service id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service event types")] = None, + Field(description="(Optional) Filter on service event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58069,26 +60896,30 @@ def list_service_events_with_http_info( Field(description="(Optional) Filter on service id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service event types")] = None, + Field(description="(Optional) Filter on service event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58136,26 +60967,30 @@ def list_service_events_without_preload_content( Field(description="(Optional) Filter on service id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service event types")] = None, + Field(description="(Optional) Filter on service event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58203,31 +61038,36 @@ def list_services( description="(Optional) The id of the app")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service types")] = None, + Field(description="(Optional) Filter on service types"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service statuses")] = None, + Field(description="(Optional) Filter on service statuses"), + ] = None, regions: Annotated[Optional[List[StrictStr]], Field( description="(Optional) Filter on regions")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on service ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58246,7 +61086,7 @@ List Services - `types` (`List[str]`): (Optional) Filter on service types - `statuses` (`List[str]`): (Optional) Filter on service statuses - `regions` (`List[str]`): (Optional) Filter on regions -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on service ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -58278,31 +61118,36 @@ def list_services_with_http_info( description="(Optional) The id of the app")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service types")] = None, + Field(description="(Optional) Filter on service types"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service statuses")] = None, + Field(description="(Optional) Filter on service statuses"), + ] = None, regions: Annotated[Optional[List[StrictStr]], Field( description="(Optional) Filter on regions")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on service ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58321,7 +61166,7 @@ List Services - `types` (`List[str]`): (Optional) Filter on service types - `statuses` (`List[str]`): (Optional) Filter on service statuses - `regions` (`List[str]`): (Optional) Filter on regions -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on service ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -58353,31 +61198,36 @@ def list_services_without_preload_content( description="(Optional) The id of the app")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service types")] = None, + Field(description="(Optional) Filter on service types"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service statuses")] = None, + Field(description="(Optional) Filter on service statuses"), + ] = None, regions: Annotated[Optional[List[StrictStr]], Field( description="(Optional) Filter on regions")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on service ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58396,7 +61246,7 @@ List Services - `types` (`List[str]`): (Optional) Filter on service types - `statuses` (`List[str]`): (Optional) Filter on service statuses - `regions` (`List[str]`): (Optional) Filter on regions -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on service ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -58425,12 +61275,12 @@ Returns the result object. def pause_service( id: Annotated[StrictStr, Field(description="The id of the service to pause.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58472,12 +61322,12 @@ Returns the result object. def pause_service_with_http_info( id: Annotated[StrictStr, Field(description="The id of the service to pause.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58520,12 +61370,12 @@ Returns the result object. def pause_service_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the service to pause.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58568,12 +61418,12 @@ Returns the result object. def re_deploy( id: StrictStr, info: RedeployRequestInfo, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58615,12 +61465,12 @@ Returns the result object. def re_deploy_with_http_info( id: StrictStr, info: RedeployRequestInfo, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58662,12 +61512,12 @@ Returns the result object. def re_deploy_without_preload_content( id: StrictStr, info: RedeployRequestInfo, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58715,14 +61565,15 @@ def resume_service( Field( description= "If set to true, the build stage will be skipped and the image coming from the last successful build step will be used instead. The call fails if no previous successful builds happened." - )] = None, + ), + ] = None, use_cache: Optional[StrictBool] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58771,14 +61622,15 @@ def resume_service_with_http_info( Field( description= "If set to true, the build stage will be skipped and the image coming from the last successful build step will be used instead. The call fails if no previous successful builds happened." - )] = None, + ), + ] = None, use_cache: Optional[StrictBool] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58828,14 +61680,15 @@ def resume_service_without_preload_content( Field( description= "If set to true, the build stage will be skipped and the image coming from the last successful build step will be used instead. The call fails if no previous successful builds happened." - )] = None, + ), + ] = None, use_cache: Optional[StrictBool] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58885,14 +61738,14 @@ def update_service( dry_run: Annotated[ Optional[StrictBool], Field(description= - "If set, run validation and check that the service exists" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If set, run validation and check that the service exists"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58941,14 +61794,14 @@ def update_service_with_http_info( dry_run: Annotated[ Optional[StrictBool], Field(description= - "If set, run validation and check that the service exists" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If set, run validation and check that the service exists"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58997,14 +61850,14 @@ def update_service_without_preload_content( dry_run: Annotated[ Optional[StrictBool], Field(description= - "If set, run validation and check that the service exists" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If set, run validation and check that the service exists"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59053,14 +61906,14 @@ def update_service2( dry_run: Annotated[ Optional[StrictBool], Field(description= - "If set, run validation and check that the service exists" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If set, run validation and check that the service exists"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59109,14 +61962,14 @@ def update_service2_with_http_info( dry_run: Annotated[ Optional[StrictBool], Field(description= - "If set, run validation and check that the service exists" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If set, run validation and check that the service exists"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59165,14 +62018,14 @@ def update_service2_without_preload_content( dry_run: Annotated[ Optional[StrictBool], Field(description= - "If set, run validation and check that the service exists" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If set, run validation and check that the service exists"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59217,12 +62070,12 @@ def update_service_scaling( id: Annotated[StrictStr, Field(description="The id of the service to scale")], body: UpdateServiceScalingRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59266,12 +62119,12 @@ def update_service_scaling_with_http_info( id: Annotated[StrictStr, Field(description="The id of the service to scale")], body: UpdateServiceScalingRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59316,12 +62169,12 @@ def update_service_scaling_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the service to scale")], body: UpdateServiceScalingRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59391,12 +62244,12 @@ Do not edit the class manually. def get_organization_summary( organization_id: Annotated[StrictStr, Field(description="Organization ID")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59437,12 +62290,12 @@ Returns the result object. def get_organization_summary_with_http_info( organization_id: Annotated[StrictStr, Field(description="Organization ID")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59483,12 +62336,12 @@ Returns the result object. def get_organization_summary_without_preload_content( organization_id: Annotated[StrictStr, Field(description="Organization ID")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59554,12 +62407,12 @@ Do not edit the class manually. @validate_call def create_persistent_volume( body: CreatePersistentVolumeRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59599,12 +62452,12 @@ Returns the result object. @validate_call def create_persistent_volume_with_http_info( body: CreatePersistentVolumeRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59644,12 +62497,12 @@ Returns the result object. @validate_call def create_persistent_volume_without_preload_content( body: CreatePersistentVolumeRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59689,12 +62542,12 @@ Returns the result object. @validate_call def delete_persistent_volume( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59734,12 +62587,12 @@ Returns the result object. @validate_call def delete_persistent_volume_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59779,12 +62632,12 @@ Returns the result object. @validate_call def delete_persistent_volume_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59824,12 +62677,12 @@ Returns the result object. @validate_call def get_persistent_volume( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59869,12 +62722,12 @@ Returns the result object. @validate_call def get_persistent_volume_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59914,12 +62767,12 @@ Returns the result object. @validate_call def get_persistent_volume_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59960,30 +62813,35 @@ Returns the result object. def list_persistent_volume_events( persistent_volume_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on persistent volume id")] = None, + Field(description="(Optional) Filter on persistent volume id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on persistent volume event types" - )] = None, + Field( + description="(Optional) Filter on persistent volume event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60028,30 +62886,35 @@ Returns the result object. def list_persistent_volume_events_with_http_info( persistent_volume_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on persistent volume id")] = None, + Field(description="(Optional) Filter on persistent volume id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on persistent volume event types" - )] = None, + Field( + description="(Optional) Filter on persistent volume event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60096,30 +62959,35 @@ Returns the result object. def list_persistent_volume_events_without_preload_content( persistent_volume_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on persistent volume id")] = None, + Field(description="(Optional) Filter on persistent volume id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on persistent volume event types" - )] = None, + Field( + description="(Optional) Filter on persistent volume event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60164,29 +63032,33 @@ Returns the result object. def list_persistent_volumes( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, service_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) A filter for the service id")] = None, + Field(description="(Optional) A filter for the service id"), + ] = None, region: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the region")] = None, name: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on volume ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60203,7 +63075,7 @@ List all PersistentVolumes - `service_id` (`str`): (Optional) A filter for the service id - `region` (`str`): (Optional) A filter for the region - `name` (`str`): (Optional) A filter for the name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on volume ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60232,29 +63104,33 @@ Returns the result object. def list_persistent_volumes_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, service_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) A filter for the service id")] = None, + Field(description="(Optional) A filter for the service id"), + ] = None, region: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the region")] = None, name: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on volume ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60271,7 +63147,7 @@ List all PersistentVolumes - `service_id` (`str`): (Optional) A filter for the service id - `region` (`str`): (Optional) A filter for the region - `name` (`str`): (Optional) A filter for the name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on volume ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60300,29 +63176,33 @@ Returns the result object. def list_persistent_volumes_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, service_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) A filter for the service id")] = None, + Field(description="(Optional) A filter for the service id"), + ] = None, region: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the region")] = None, name: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on volume ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60339,7 +63219,7 @@ List all PersistentVolumes - `service_id` (`str`): (Optional) A filter for the service id - `region` (`str`): (Optional) A filter for the region - `name` (`str`): (Optional) A filter for the name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on volume ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60368,12 +63248,12 @@ Returns the result object. def update_persistent_volume( id: StrictStr, body: UpdatePersistentVolumeRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60415,12 +63295,12 @@ Returns the result object. def update_persistent_volume_with_http_info( id: StrictStr, body: UpdatePersistentVolumeRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60462,12 +63342,12 @@ Returns the result object. def update_persistent_volume_without_preload_content( id: StrictStr, body: UpdatePersistentVolumeRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60500,9 +63380,9 @@ in the spec for a single request. Returns the result object. - + -# koyeb/api.api.users\_api +# koyeb/api.api.pool\_claims\_api Koyeb Rest API @@ -60513,12 +63393,12 @@ Generated by OpenAPI Generator (https://openapi-generator.tech) Do not edit the class manually. - + -## UsersApi Objects +## PoolClaimsApi Objects ```python -class UsersApi() +class PoolClaimsApi() ``` NOTE: This class is auto generated by OpenAPI Generator @@ -60526,33 +63406,32 @@ Ref: https://openapi-generator.tech Do not edit the class manually. - + -#### delete\_user +#### claim ```python @validate_call -def delete_user( - id: Annotated[StrictStr, - Field(description="The id of the user")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, +def claim( + body: PoolClaimRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, - Field(ge=0, le=0)] = 0) -> DeleteUserReply + Field(ge=0, le=0)] = 0) -> PoolClaimReply ``` -Delete user +Claim a sandbox from a service pool **Arguments**: -- `id` (`str`): The id of the user (required) +- `body` (`PoolClaimRequest`): (required) - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60572,33 +63451,32 @@ in the spec for a single request. Returns the result object. - + -#### delete\_user\_with\_http\_info +#### claim\_with\_http\_info ```python @validate_call -def delete_user_with_http_info( - id: Annotated[StrictStr, - Field(description="The id of the user")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, +def claim_with_http_info( + body: PoolClaimRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 -) -> ApiResponse[DeleteUserReply] +) -> ApiResponse[PoolClaimReply] ``` -Delete user +Claim a sandbox from a service pool **Arguments**: -- `id` (`str`): The id of the user (required) +- `body` (`PoolClaimRequest`): (required) - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60618,21 +63496,20 @@ in the spec for a single request. Returns the result object. - + -#### delete\_user\_without\_preload\_content +#### claim\_without\_preload\_content ```python @validate_call -def delete_user_without_preload_content( - id: Annotated[StrictStr, - Field(description="The id of the user")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, +def claim_without_preload_content( + body: PoolClaimRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60640,11 +63517,11 @@ def delete_user_without_preload_content( Field(ge=0, le=0)] = 0) -> RESTResponseType ``` -Delete user +Claim a sandbox from a service pool **Arguments**: -- `id` (`str`): The id of the user (required) +- `body` (`PoolClaimRequest`): (required) - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60664,33 +63541,32 @@ in the spec for a single request. Returns the result object. - + -#### delete\_user\_v2 +#### get\_claim ```python @validate_call -def delete_user_v2( - id: Annotated[StrictStr, - Field(description="The id of the user")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, +def get_claim( + claim_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, - Field(ge=0, le=0)] = 0) -> DeleteUserReply + Field(ge=0, le=0)] = 0) -> GetPoolClaimReply ``` -V2 Delete user +Get a claim **Arguments**: -- `id` (`str`): The id of the user (required) +- `claim_id` (`str`): (required) - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60710,33 +63586,32 @@ in the spec for a single request. Returns the result object. - + -#### delete\_user\_v2\_with\_http\_info +#### get\_claim\_with\_http\_info ```python @validate_call -def delete_user_v2_with_http_info( - id: Annotated[StrictStr, - Field(description="The id of the user")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, +def get_claim_with_http_info( + claim_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 -) -> ApiResponse[DeleteUserReply] +) -> ApiResponse[GetPoolClaimReply] ``` -V2 Delete user +Get a claim **Arguments**: -- `id` (`str`): The id of the user (required) +- `claim_id` (`str`): (required) - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60756,29 +63631,483 @@ in the spec for a single request. Returns the result object. - + -#### delete\_user\_v2\_without\_preload\_content +#### get\_claim\_without\_preload\_content ```python @validate_call -def delete_user_v2_without_preload_content( +def get_claim_without_preload_content( + claim_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +Get a claim + +**Arguments**: + +- `claim_id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### list\_claim + +```python +@validate_call +def list_claim( + pool_id: StrictStr, + status: Optional[StrictStr] = None, + limit: Optional[StrictStr] = None, + offset: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ListPoolClaimReply +``` + +List claims of a service pool + +**Arguments**: + +- `pool_id` (`str`): (required) +- `status` (`str`): +- `limit` (`str`): +- `offset` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### list\_claim\_with\_http\_info + +```python +@validate_call +def list_claim_with_http_info( + pool_id: StrictStr, + status: Optional[StrictStr] = None, + limit: Optional[StrictStr] = None, + offset: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[ListPoolClaimReply] +``` + +List claims of a service pool + +**Arguments**: + +- `pool_id` (`str`): (required) +- `status` (`str`): +- `limit` (`str`): +- `offset` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### list\_claim\_without\_preload\_content + +```python +@validate_call +def list_claim_without_preload_content( + pool_id: StrictStr, + status: Optional[StrictStr] = None, + limit: Optional[StrictStr] = None, + offset: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +List claims of a service pool + +**Arguments**: + +- `pool_id` (`str`): (required) +- `status` (`str`): +- `limit` (`str`): +- `offset` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +# koyeb/api.api.users\_api + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## UsersApi Objects + +```python +class UsersApi() +``` + +NOTE: This class is auto generated by OpenAPI Generator +Ref: https://openapi-generator.tech + +Do not edit the class manually. + + + +#### delete\_user + +```python +@validate_call +def delete_user( id: Annotated[StrictStr, Field(description="The id of the user")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, - Field(ge=0, le=0)] = 0) -> RESTResponseType + Field(ge=0, le=0)] = 0) -> DeleteUserReply ``` -V2 Delete user +Delete user + +**Arguments**: + +- `id` (`str`): The id of the user (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_user\_with\_http\_info + +```python +@validate_call +def delete_user_with_http_info( + id: Annotated[StrictStr, + Field(description="The id of the user")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[DeleteUserReply] +``` + +Delete user + +**Arguments**: + +- `id` (`str`): The id of the user (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_user\_without\_preload\_content + +```python +@validate_call +def delete_user_without_preload_content( + id: Annotated[StrictStr, + Field(description="The id of the user")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +Delete user + +**Arguments**: + +- `id` (`str`): The id of the user (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_user\_v2 + +```python +@validate_call +def delete_user_v2( + id: Annotated[StrictStr, + Field(description="The id of the user")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> DeleteUserReply +``` + +V2 Delete user + +**Arguments**: + +- `id` (`str`): The id of the user (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_user\_v2\_with\_http\_info + +```python +@validate_call +def delete_user_v2_with_http_info( + id: Annotated[StrictStr, + Field(description="The id of the user")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[DeleteUserReply] +``` + +V2 Delete user + +**Arguments**: + +- `id` (`str`): The id of the user (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_user\_v2\_without\_preload\_content + +```python +@validate_call +def delete_user_v2_without_preload_content( + id: Annotated[StrictStr, + Field(description="The id of the user")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +V2 Delete user **Arguments**: @@ -60836,12 +64165,12 @@ Do not edit the class manually. @validate_call def create_archive( archive: CreateArchive, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60883,12 +64212,12 @@ Returns the result object. @validate_call def create_archive_with_http_info( archive: CreateArchive, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60930,12 +64259,12 @@ Returns the result object. @validate_call def create_archive_without_preload_content( archive: CreateArchive, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61007,16 +64336,18 @@ def get_metrics( Field( description= "ID of the service to query instances metrics for. Ignored if instance_id is set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="ID of the instance to query metrics for.")] = None, + Field(description="ID of the instance to query metrics for."), + ] = None, name: Annotated[Optional[StrictStr], Field(description="Metric to query.")] = None, start: Annotated[ Optional[datetime], - Field(description="(Optional) Defaults to an hour prior to end." - )] = None, + Field(description="(Optional) Defaults to an hour prior to end."), + ] = None, end: Annotated[Optional[datetime], Field(description="(Optional) Defaults to now.")] = None, step: Annotated[ @@ -61024,13 +64355,14 @@ def get_metrics( Field( description= "(Optional) Must be a valid duration in hours (h) or minutes (m). Defaulst to 5m." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61079,16 +64411,18 @@ def get_metrics_with_http_info( Field( description= "ID of the service to query instances metrics for. Ignored if instance_id is set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="ID of the instance to query metrics for.")] = None, + Field(description="ID of the instance to query metrics for."), + ] = None, name: Annotated[Optional[StrictStr], Field(description="Metric to query.")] = None, start: Annotated[ Optional[datetime], - Field(description="(Optional) Defaults to an hour prior to end." - )] = None, + Field(description="(Optional) Defaults to an hour prior to end."), + ] = None, end: Annotated[Optional[datetime], Field(description="(Optional) Defaults to now.")] = None, step: Annotated[ @@ -61096,13 +64430,14 @@ def get_metrics_with_http_info( Field( description= "(Optional) Must be a valid duration in hours (h) or minutes (m). Defaulst to 5m." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61151,16 +64486,18 @@ def get_metrics_without_preload_content( Field( description= "ID of the service to query instances metrics for. Ignored if instance_id is set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="ID of the instance to query metrics for.")] = None, + Field(description="ID of the instance to query metrics for."), + ] = None, name: Annotated[Optional[StrictStr], Field(description="Metric to query.")] = None, start: Annotated[ Optional[datetime], - Field(description="(Optional) Defaults to an hour prior to end." - )] = None, + Field(description="(Optional) Defaults to an hour prior to end."), + ] = None, end: Annotated[Optional[datetime], Field(description="(Optional) Defaults to now.")] = None, step: Annotated[ @@ -61168,13 +64505,14 @@ def get_metrics_without_preload_content( Field( description= "(Optional) Must be a valid duration in hours (h) or minutes (m). Defaulst to 5m." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61246,12 +64584,12 @@ Do not edit the class manually. def confirm_payment_authorization( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61293,12 +64631,12 @@ Returns the result object. def confirm_payment_authorization_with_http_info( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61340,12 +64678,12 @@ Returns the result object. def confirm_payment_authorization_without_preload_content( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61386,12 +64724,12 @@ Returns the result object. @validate_call def create_payment_authorization( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61431,12 +64769,12 @@ Returns the result object. @validate_call def create_payment_authorization_with_http_info( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61476,12 +64814,12 @@ Returns the result object. @validate_call def create_payment_authorization_without_preload_content( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61521,12 +64859,12 @@ Returns the result object. @validate_call def delete_payment_method( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61565,12 +64903,12 @@ Returns the result object. @validate_call def delete_payment_method_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61610,12 +64948,12 @@ Returns the result object. @validate_call def delete_payment_method_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61655,12 +64993,12 @@ Returns the result object. @validate_call def get_payment_method( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61700,12 +65038,12 @@ Returns the result object. @validate_call def get_payment_method_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61745,12 +65083,12 @@ Returns the result object. @validate_call def get_payment_method_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61791,21 +65129,23 @@ Returns the result object. def list_payment_methods( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on payment method statuses" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on payment method statuses"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61848,21 +65188,23 @@ Returns the result object. def list_payment_methods_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on payment method statuses" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on payment method statuses"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61905,21 +65247,23 @@ Returns the result object. def list_payment_methods_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on payment method statuses" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on payment method statuses"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61990,12 +65334,12 @@ def create_stage_attempt( stage: StrictStr, attempt: StrictStr, body: CreateStageAttemptRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62040,12 +65384,12 @@ def create_stage_attempt_with_http_info( stage: StrictStr, attempt: StrictStr, body: CreateStageAttemptRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62091,12 +65435,12 @@ def create_stage_attempt_without_preload_content( stage: StrictStr, attempt: StrictStr, body: CreateStageAttemptRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62142,12 +65486,12 @@ def declare_stage_progress( stage: StrictStr, attempt: StrictStr, body: DeclareStageProgressRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62192,12 +65536,12 @@ def declare_stage_progress_with_http_info( stage: StrictStr, attempt: StrictStr, body: DeclareStageProgressRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62243,12 +65587,12 @@ def declare_stage_progress_without_preload_content( stage: StrictStr, attempt: StrictStr, body: DeclareStageProgressRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62295,12 +65639,12 @@ def declare_step_progress( attempt: StrictStr, step: StrictStr, body: DeclareStepProgressRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62347,12 +65691,12 @@ def declare_step_progress_with_http_info( attempt: StrictStr, step: StrictStr, body: DeclareStepProgressRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62400,12 +65744,12 @@ def declare_step_progress_without_preload_content( attempt: StrictStr, step: StrictStr, body: DeclareStepProgressRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62479,12 +65823,12 @@ Do not edit the class manually. @validate_call def create_organization_invitation( body: CreateOrganizationInvitationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62524,12 +65868,12 @@ Returns the result object. @validate_call def create_organization_invitation_with_http_info( body: CreateOrganizationInvitationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62569,12 +65913,12 @@ Returns the result object. @validate_call def create_organization_invitation_without_preload_content( body: CreateOrganizationInvitationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62615,14 +65959,15 @@ Returns the result object. def delete_organization_invitation( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to delete" - )], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description="The id of the organization invitation to delete"), + ], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62662,13 +66007,14 @@ Returns the result object. def delete_organization_invitation_with_http_info( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="The id of the organization invitation to delete"), + ], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62709,13 +66055,14 @@ Returns the result object. def delete_organization_invitation_without_preload_content( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="The id of the organization invitation to delete"), + ], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62756,12 +66103,12 @@ Returns the result object. def get_organization_invitation( id: Annotated[StrictStr, Field(description="The id of the invitation to get")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62802,12 +66149,12 @@ Returns the result object. def get_organization_invitation_with_http_info( id: Annotated[StrictStr, Field(description="The id of the invitation to get")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62848,12 +66195,12 @@ Returns the result object. def get_organization_invitation_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the invitation to get")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62894,28 +66241,32 @@ Returns the result object. def list_organization_invitations( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on organization invitation statuses" - )] = None, + ), + ] = None, user_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on invitee ID. Will match both invitations sent to that user_id and invitations sent to the email of that user_id. The only valid value is the requester's user_id" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62959,28 +66310,32 @@ Returns the result object. def list_organization_invitations_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on organization invitation statuses" - )] = None, + ), + ] = None, user_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on invitee ID. Will match both invitations sent to that user_id and invitations sent to the email of that user_id. The only valid value is the requester's user_id" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63024,28 +66379,32 @@ Returns the result object. def list_organization_invitations_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on organization invitation statuses" - )] = None, + ), + ] = None, user_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on invitee ID. Will match both invitations sent to that user_id and invitations sent to the email of that user_id. The only valid value is the requester's user_id" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63089,14 +66448,15 @@ Returns the result object. def resend_organization_invitation( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to resend")], + Field(description="The id of the organization invitation to resend"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63138,14 +66498,15 @@ Returns the result object. def resend_organization_invitation_with_http_info( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to resend")], + Field(description="The id of the organization invitation to resend"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63187,14 +66548,15 @@ Returns the result object. def resend_organization_invitation_without_preload_content( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to resend")], + Field(description="The id of the organization invitation to resend"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63261,12 +66623,12 @@ Do not edit the class manually. @validate_call def list_usage( region: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63306,12 +66668,12 @@ Returns the result object. @validate_call def list_usage_with_http_info( region: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63351,12 +66713,12 @@ Returns the result object. @validate_call def list_usage_without_preload_content( region: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63388,6 +66750,730 @@ in the spec for a single request. Returns the result object. + + +# koyeb/api.api.service\_pools\_api + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## ServicePoolsApi Objects + +```python +class ServicePoolsApi() +``` + +NOTE: This class is auto generated by OpenAPI Generator +Ref: https://openapi-generator.tech + +Do not edit the class manually. + + + +#### create\_service\_pool + +```python +@validate_call +def create_service_pool( + service_pool: CreateServicePool, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> CreateServicePoolReply +``` + +Create a ServicePool + +**Arguments**: + +- `service_pool` (`CreateServicePool`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### create\_service\_pool\_with\_http\_info + +```python +@validate_call +def create_service_pool_with_http_info( + service_pool: CreateServicePool, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[CreateServicePoolReply] +``` + +Create a ServicePool + +**Arguments**: + +- `service_pool` (`CreateServicePool`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### create\_service\_pool\_without\_preload\_content + +```python +@validate_call +def create_service_pool_without_preload_content( + service_pool: CreateServicePool, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +Create a ServicePool + +**Arguments**: + +- `service_pool` (`CreateServicePool`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_service\_pool + +```python +@validate_call +def delete_service_pool( + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0) -> object +``` + +Delete a ServicePool + +**Arguments**: + +- `id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_service\_pool\_with\_http\_info + +```python +@validate_call +def delete_service_pool_with_http_info( + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[object] +``` + +Delete a ServicePool + +**Arguments**: + +- `id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_service\_pool\_without\_preload\_content + +```python +@validate_call +def delete_service_pool_without_preload_content( + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +Delete a ServicePool + +**Arguments**: + +- `id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### get\_service\_pool + +```python +@validate_call +def get_service_pool( + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> GetServicePoolReply +``` + +Get a ServicePool + +**Arguments**: + +- `id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### get\_service\_pool\_with\_http\_info + +```python +@validate_call +def get_service_pool_with_http_info( + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[GetServicePoolReply] +``` + +Get a ServicePool + +**Arguments**: + +- `id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### get\_service\_pool\_without\_preload\_content + +```python +@validate_call +def get_service_pool_without_preload_content( + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +Get a ServicePool + +**Arguments**: + +- `id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### list\_service\_pools + +```python +@validate_call +def list_service_pools( + name: Optional[StrictStr] = None, + limit: Optional[StrictStr] = None, + offset: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ListServicePoolsReply +``` + +List ServicePools + +**Arguments**: + +- `name` (`str`): +- `limit` (`str`): +- `offset` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### list\_service\_pools\_with\_http\_info + +```python +@validate_call +def list_service_pools_with_http_info( + name: Optional[StrictStr] = None, + limit: Optional[StrictStr] = None, + offset: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[ListServicePoolsReply] +``` + +List ServicePools + +**Arguments**: + +- `name` (`str`): +- `limit` (`str`): +- `offset` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### list\_service\_pools\_without\_preload\_content + +```python +@validate_call +def list_service_pools_without_preload_content( + name: Optional[StrictStr] = None, + limit: Optional[StrictStr] = None, + offset: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +List ServicePools + +**Arguments**: + +- `name` (`str`): +- `limit` (`str`): +- `offset` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### update\_service\_pool + +```python +@validate_call +def update_service_pool( + id: StrictStr, + service_pool: UpdateServicePool, + update_mask: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> UpdateServicePoolReply +``` + +update_service_pool + +**Arguments**: + +- `id` (`str`): (required) +- `service_pool` (`UpdateServicePool`): (required) +- `update_mask` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### update\_service\_pool\_with\_http\_info + +```python +@validate_call +def update_service_pool_with_http_info( + id: StrictStr, + service_pool: UpdateServicePool, + update_mask: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[UpdateServicePoolReply] +``` + +update_service_pool + +**Arguments**: + +- `id` (`str`): (required) +- `service_pool` (`UpdateServicePool`): (required) +- `update_mask` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### update\_service\_pool\_without\_preload\_content + +```python +@validate_call +def update_service_pool_without_preload_content( + id: StrictStr, + service_pool: UpdateServicePool, + update_mask: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +update_service_pool + +**Arguments**: + +- `id` (`str`): (required) +- `service_pool` (`UpdateServicePool`): (required) +- `update_mask` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + # koyeb/api.api.intercom\_api @@ -63421,12 +67507,12 @@ Do not edit the class manually. ```python @validate_call def get_intercom_profile( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63464,12 +67550,12 @@ Returns the result object. ```python @validate_call def get_intercom_profile_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63507,12 +67593,12 @@ Returns the result object. ```python @validate_call def get_intercom_profile_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63577,12 +67663,12 @@ Do not edit the class manually. @validate_call def create_app( app: CreateApp, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63622,12 +67708,12 @@ Returns the result object. @validate_call def create_app_with_http_info( app: CreateApp, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63667,12 +67753,12 @@ Returns the result object. @validate_call def create_app_without_preload_content( app: CreateApp, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63713,12 +67799,12 @@ Returns the result object. def delete_app( id: Annotated[StrictStr, Field(description="The id of the App to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63760,12 +67846,12 @@ Returns the result object. def delete_app_with_http_info( id: Annotated[StrictStr, Field(description="The id of the App to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63808,12 +67894,12 @@ Returns the result object. def delete_app_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the App to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63856,12 +67942,12 @@ Returns the result object. def get_app( id: Annotated[StrictStr, Field(description="The id of the App")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63901,12 +67987,12 @@ Returns the result object. @validate_call def get_app_with_http_info( id: Annotated[StrictStr, Field(description="The id of the App")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63946,12 +68032,12 @@ Returns the result object. @validate_call def get_app_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the App")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63994,26 +68080,30 @@ def list_app_events( Field(description="(Optional) Filter on app id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on app event types")] = None, + Field(description="(Optional) Filter on app event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64060,26 +68150,30 @@ def list_app_events_with_http_info( Field(description="(Optional) Filter on app id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on app event types")] = None, + Field(description="(Optional) Filter on app event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64126,26 +68220,30 @@ def list_app_events_without_preload_content( Field(description="(Optional) Filter on app id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on app event types")] = None, + Field(description="(Optional) Filter on app event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64190,26 +68288,25 @@ Returns the result object. def list_apps( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return" - )] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field( - description= - "(Optional) The offset in the list of item to return")] = None, + Field(description= + "(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field( - description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[Optional[List[StrictStr]], + Field( + description="(Optional) Filter on app ids")] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64224,7 +68321,7 @@ List App - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return - `name` (`str`): (Optional) A filter for name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on app ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -64253,22 +68350,23 @@ Returns the result object. def list_apps_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[Optional[List[StrictStr]], + Field(description="(Optional) Filter on app ids")] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64283,7 +68381,7 @@ List App - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return - `name` (`str`): (Optional) A filter for name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on app ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -64312,22 +68410,23 @@ Returns the result object. def list_apps_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[Optional[List[StrictStr]], + Field(description="(Optional) Filter on app ids")] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64342,7 +68441,7 @@ List App - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return - `name` (`str`): (Optional) A filter for name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on app ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -64371,12 +68470,12 @@ Returns the result object. def pause_app( id: Annotated[StrictStr, Field(description="The id of the app to pause.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64418,12 +68517,12 @@ Returns the result object. def pause_app_with_http_info( id: Annotated[StrictStr, Field(description="The id of the app to pause.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64466,12 +68565,12 @@ Returns the result object. def pause_app_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the app to pause.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64514,12 +68613,12 @@ Returns the result object. def resume_app( id: Annotated[StrictStr, Field(description="The id of the app to resume.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64561,12 +68660,12 @@ Returns the result object. def resume_app_with_http_info( id: Annotated[StrictStr, Field(description="The id of the app to resume.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64609,12 +68708,12 @@ Returns the result object. def resume_app_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the app to resume.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64659,12 +68758,12 @@ def update_app( Field(description="The id of the app to update.")], app: UpdateApp, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64709,12 +68808,12 @@ def update_app_with_http_info( Field(description="The id of the app to update.")], app: UpdateApp, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64759,12 +68858,12 @@ def update_app_without_preload_content( Field(description="The id of the app to update.")], app: UpdateApp, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64809,12 +68908,12 @@ def update_app2( Field(description="The id of the app to update.")], app: UpdateApp, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64859,12 +68958,12 @@ def update_app2_with_http_info( Field(description="The id of the app to update.")], app: UpdateApp, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64909,12 +69008,12 @@ def update_app2_without_preload_content( Field(description="The id of the app to update.")], app: UpdateApp, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64982,12 +69081,12 @@ Do not edit the class manually. @validate_call def create_invite( body: InviteUserRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65026,12 +69125,12 @@ Returns the result object. @validate_call def create_invite_with_http_info( body: InviteUserRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65071,12 +69170,12 @@ Returns the result object. @validate_call def create_invite_without_preload_content( body: InviteUserRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65144,12 +69243,12 @@ def cancel_deployment( id: Annotated[StrictStr, Field( description="The id of the deployment to cancel.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65191,12 +69290,12 @@ Returns the result object. def cancel_deployment_with_http_info( id: Annotated[StrictStr, Field(description="The id of the deployment to cancel.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65239,12 +69338,12 @@ Returns the result object. def cancel_deployment_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the deployment to cancel.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65287,12 +69386,12 @@ Returns the result object. def get_deployment( id: Annotated[StrictStr, Field(description="The id of the deployment")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65333,12 +69432,12 @@ Returns the result object. def get_deployment_with_http_info( id: Annotated[StrictStr, Field(description="The id of the deployment")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65379,12 +69478,12 @@ Returns the result object. def get_deployment_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the deployment")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65429,12 +69528,12 @@ def get_deployment_scaling( replica_index: Annotated[ Optional[StrictInt], Field(description="(Optional) Filter on replica_index")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65481,12 +69580,12 @@ def get_deployment_scaling_with_http_info( replica_index: Annotated[ Optional[StrictInt], Field(description="(Optional) Filter on replica_index")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65533,12 +69632,12 @@ def get_deployment_scaling_without_preload_content( replica_index: Annotated[ Optional[StrictInt], Field(description="(Optional) Filter on replica_index")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65584,27 +69683,30 @@ def list_deployment_events( Field(description="(Optional) Filter on deployment id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field( - description="(Optional) Filter on deployment event types")] = None, + Field(description="(Optional) Filter on deployment event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65652,27 +69754,30 @@ def list_deployment_events_with_http_info( Field(description="(Optional) Filter on deployment id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field( - description="(Optional) Filter on deployment event types")] = None, + Field(description="(Optional) Filter on deployment event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65720,27 +69825,30 @@ def list_deployment_events_without_preload_content( Field(description="(Optional) Filter on deployment id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field( - description="(Optional) Filter on deployment event types")] = None, + Field(description="(Optional) Filter on deployment event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65785,26 +69893,34 @@ Returns the result object. def list_deployments( app_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on application id")] = None, + Field(description="(Optional) Filter on application id"), + ] = None, service_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on service id")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on statuses")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on statuses"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on deployment ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65821,6 +69937,7 @@ List Deployments - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return - `statuses` (`List[str]`): (Optional) Filter on statuses +- `ids` (`List[str]`): (Optional) Filter on deployment ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -65849,26 +69966,34 @@ Returns the result object. def list_deployments_with_http_info( app_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on application id")] = None, + Field(description="(Optional) Filter on application id"), + ] = None, service_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on service id")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on statuses")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on statuses"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on deployment ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65885,6 +70010,7 @@ List Deployments - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return - `statuses` (`List[str]`): (Optional) Filter on statuses +- `ids` (`List[str]`): (Optional) Filter on deployment ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -65913,26 +70039,34 @@ Returns the result object. def list_deployments_without_preload_content( app_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on application id")] = None, + Field(description="(Optional) Filter on application id"), + ] = None, service_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on service id")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on statuses")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on statuses"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on deployment ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65949,6 +70083,7 @@ List Deployments - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return - `statuses` (`List[str]`): (Optional) Filter on statuses +- `ids` (`List[str]`): (Optional) Filter on deployment ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -66002,12 +70137,12 @@ Do not edit the class manually. @validate_call def create_project( project: CreateProject, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66047,12 +70182,12 @@ Returns the result object. @validate_call def create_project_with_http_info( project: CreateProject, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66092,12 +70227,12 @@ Returns the result object. @validate_call def create_project_without_preload_content( project: CreateProject, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66137,12 +70272,12 @@ Returns the result object. @validate_call def delete_project( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66181,12 +70316,12 @@ Returns the result object. @validate_call def delete_project_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66226,12 +70361,12 @@ Returns the result object. @validate_call def delete_project_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66271,12 +70406,12 @@ Returns the result object. @validate_call def get_project( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66316,12 +70451,12 @@ Returns the result object. @validate_call def get_project_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66361,12 +70496,12 @@ Returns the result object. @validate_call def get_project_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66407,20 +70542,22 @@ Returns the result object. def list_projects( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter by project name")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66463,20 +70600,22 @@ Returns the result object. def list_projects_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter by project name")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66519,20 +70658,22 @@ Returns the result object. def list_projects_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter by project name")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66576,12 +70717,12 @@ def update_project( id: StrictStr, project: Project, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66625,12 +70766,12 @@ def update_project_with_http_info( id: StrictStr, project: Project, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66674,12 +70815,12 @@ def update_project_without_preload_content( id: StrictStr, project: Project, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66723,12 +70864,12 @@ def update_project2( id: StrictStr, project: Project, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66772,12 +70913,12 @@ def update_project2_with_http_info( id: StrictStr, project: Project, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66821,12 +70962,12 @@ def update_project2_without_preload_content( id: StrictStr, project: Project, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66895,27 +71036,30 @@ Do not edit the class manually. def list_organization_members( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter for an organization")] = None, + Field(description="(Optional) Filter for an organization"), + ] = None, user_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter for an user")] = None, organization_statuses: Annotated[ Optional[List[StrictStr]], - Field( - description="(Optional) Filter for organization statuses")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter for organization statuses"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66960,27 +71104,30 @@ Returns the result object. def list_organization_members_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter for an organization")] = None, + Field(description="(Optional) Filter for an organization"), + ] = None, user_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter for an user")] = None, organization_statuses: Annotated[ Optional[List[StrictStr]], - Field( - description="(Optional) Filter for organization statuses")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter for organization statuses"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67025,27 +71172,30 @@ Returns the result object. def list_organization_members_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter for an organization")] = None, + Field(description="(Optional) Filter for an organization"), + ] = None, user_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter for an user")] = None, organization_statuses: Annotated[ Optional[List[StrictStr]], - Field( - description="(Optional) Filter for organization statuses")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter for organization statuses"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67089,12 +71239,12 @@ Returns the result object. @validate_call def remove_organization_member( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67134,12 +71284,12 @@ Returns the result object. @validate_call def remove_organization_member_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67179,12 +71329,12 @@ Returns the result object. @validate_call def remove_organization_member_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67253,12 +71403,12 @@ def create_access_token( Field( description="Organization id for ephemeral credential")], body: CreateAccessTokenRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67304,12 +71454,12 @@ def create_access_token_with_http_info( Field( description="Organization id for ephemeral credential")], body: CreateAccessTokenRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67355,12 +71505,12 @@ def create_access_token_without_preload_content( Field( description="Organization id for ephemeral credential")], body: CreateAccessTokenRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67404,12 +71554,12 @@ Returns the result object. def create_budget( organization_id: StrictStr, body: UpdateBudgetRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67451,12 +71601,12 @@ Returns the result object. def create_budget_with_http_info( organization_id: StrictStr, body: UpdateBudgetRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67498,12 +71648,12 @@ Returns the result object. def create_budget_without_preload_content( organization_id: StrictStr, body: UpdateBudgetRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67544,12 +71694,12 @@ Returns the result object. @validate_call def create_organization( body: CreateOrganizationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67589,12 +71739,12 @@ Returns the result object. @validate_call def create_organization_with_http_info( body: CreateOrganizationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67634,12 +71784,12 @@ Returns the result object. @validate_call def create_organization_without_preload_content( body: CreateOrganizationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67680,12 +71830,12 @@ Returns the result object. def deactivate_organization( id: StrictStr, body: DeactivateOrganizationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67727,12 +71877,12 @@ Returns the result object. def deactivate_organization_with_http_info( id: StrictStr, body: DeactivateOrganizationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67774,12 +71924,12 @@ Returns the result object. def deactivate_organization_without_preload_content( id: StrictStr, body: DeactivateOrganizationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67820,12 +71970,12 @@ Returns the result object. @validate_call def delete_budget( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67864,12 +72014,12 @@ Returns the result object. @validate_call def delete_budget_with_http_info( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67909,12 +72059,12 @@ Returns the result object. @validate_call def delete_budget_without_preload_content( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67954,12 +72104,12 @@ Returns the result object. @validate_call def delete_organization( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67999,12 +72149,12 @@ Returns the result object. @validate_call def delete_organization_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68044,12 +72194,12 @@ Returns the result object. @validate_call def delete_organization_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68089,12 +72239,12 @@ Returns the result object. @validate_call def get_budget( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68134,12 +72284,12 @@ Returns the result object. @validate_call def get_budget_with_http_info( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68179,12 +72329,12 @@ Returns the result object. @validate_call def get_budget_without_preload_content( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68223,12 +72373,12 @@ Returns the result object. ```python @validate_call def get_github_installation( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68266,12 +72416,12 @@ Returns the result object. ```python @validate_call def get_github_installation_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68309,12 +72459,12 @@ Returns the result object. ```python @validate_call def get_github_installation_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68353,12 +72503,12 @@ Returns the result object. @validate_call def get_organization( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68398,12 +72548,12 @@ Returns the result object. @validate_call def get_organization_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68443,12 +72593,12 @@ Returns the result object. @validate_call def get_organization_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68488,12 +72638,12 @@ Returns the result object. @validate_call def github_installation( body: GithubInstallationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68533,12 +72683,12 @@ Returns the result object. @validate_call def github_installation_with_http_info( body: GithubInstallationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68578,12 +72728,12 @@ Returns the result object. @validate_call def github_installation_without_preload_content( body: GithubInstallationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68624,12 +72774,12 @@ Returns the result object. def reactivate_organization( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68671,12 +72821,12 @@ Returns the result object. def reactivate_organization_with_http_info( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68718,12 +72868,12 @@ Returns the result object. def reactivate_organization_without_preload_content( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68767,12 +72917,12 @@ def switch_organization( body: Dict[str, Any], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68817,12 +72967,12 @@ def switch_organization_with_http_info( body: Dict[str, Any], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68867,12 +73017,12 @@ def switch_organization_without_preload_content( body: Dict[str, Any], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68916,12 +73066,12 @@ def unscope_organization_token( body: Dict[str, Any], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68966,12 +73116,12 @@ def unscope_organization_token_with_http_info( body: Dict[str, Any], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69016,12 +73166,12 @@ def unscope_organization_token_without_preload_content( body: Dict[str, Any], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69065,12 +73215,12 @@ Returns the result object. def update_budget( organization_id: StrictStr, body: UpdateBudgetRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69112,12 +73262,12 @@ Returns the result object. def update_budget_with_http_info( organization_id: StrictStr, body: UpdateBudgetRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69159,12 +73309,12 @@ Returns the result object. def update_budget_without_preload_content( organization_id: StrictStr, body: UpdateBudgetRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69207,12 +73357,12 @@ def update_organization( id: StrictStr, organization: Organization, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69256,12 +73406,12 @@ def update_organization_with_http_info( id: StrictStr, organization: Organization, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69305,12 +73455,12 @@ def update_organization_without_preload_content( id: StrictStr, organization: Organization, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69354,12 +73504,12 @@ def update_organization2( id: StrictStr, organization: Organization, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69403,12 +73553,12 @@ def update_organization2_with_http_info( id: StrictStr, organization: Organization, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69452,12 +73602,12 @@ def update_organization2_without_preload_content( id: StrictStr, organization: Organization, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69500,12 +73650,12 @@ Returns the result object. def update_organization_default_project( id: StrictStr, body: UpdateOrganizationDefaultProjectRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69547,12 +73697,12 @@ Returns the result object. def update_organization_default_project_with_http_info( id: StrictStr, body: UpdateOrganizationDefaultProjectRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69594,12 +73744,12 @@ Returns the result object. def update_organization_default_project_without_preload_content( id: StrictStr, body: UpdateOrganizationDefaultProjectRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69641,12 +73791,12 @@ Returns the result object. def update_organization_name( id: StrictStr, body: UpdateOrganizationNameRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69688,12 +73838,12 @@ Returns the result object. def update_organization_name_with_http_info( id: StrictStr, body: UpdateOrganizationNameRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69735,12 +73885,12 @@ Returns the result object. def update_organization_name_without_preload_content( id: StrictStr, body: UpdateOrganizationNameRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69782,12 +73932,12 @@ Returns the result object. def update_organization_plan( id: StrictStr, body: UpdateOrganizationPlanRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69829,12 +73979,12 @@ Returns the result object. def update_organization_plan_with_http_info( id: StrictStr, body: UpdateOrganizationPlanRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69876,12 +74026,12 @@ Returns the result object. def update_organization_plan_without_preload_content( id: StrictStr, body: UpdateOrganizationPlanRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69923,12 +74073,12 @@ Returns the result object. def upsert_signup_qualification( id: StrictStr, body: UpsertSignupQualificationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69970,12 +74120,12 @@ Returns the result object. def upsert_signup_qualification_with_http_info( id: StrictStr, body: UpsertSignupQualificationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70017,12 +74167,12 @@ Returns the result object. def upsert_signup_qualification_without_preload_content( id: StrictStr, body: UpsertSignupQualificationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70081,6 +74231,141 @@ Ref: https://openapi-generator.tech Do not edit the class manually. + + +#### get\_organization\_quotas\_usage + +```python +@validate_call +def get_organization_quotas_usage( + organization_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> GetOrganizationQuotasUsageReply +``` + +Return the organization's current quota usage alongside the plan's limits. Response is cached in Redis for 60s. Accept text/plain (or ?format=prometheus) to receive the response rendered as Prometheus text exposition format ("koyeb_quota_" for usage, "koyeb_quota__limit" for the plan limit) suitable for scraping into an external Prometheus. + +**Arguments**: + +- `organization_id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### get\_organization\_quotas\_usage\_with\_http\_info + +```python +@validate_call +def get_organization_quotas_usage_with_http_info( + organization_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[GetOrganizationQuotasUsageReply] +``` + +Return the organization's current quota usage alongside the plan's limits. Response is cached in Redis for 60s. Accept text/plain (or ?format=prometheus) to receive the response rendered as Prometheus text exposition format ("koyeb_quota_" for usage, "koyeb_quota__limit" for the plan limit) suitable for scraping into an external Prometheus. + +**Arguments**: + +- `organization_id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### get\_organization\_quotas\_usage\_without\_preload\_content + +```python +@validate_call +def get_organization_quotas_usage_without_preload_content( + organization_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +Return the organization's current quota usage alongside the plan's limits. Response is cached in Redis for 60s. Accept text/plain (or ?format=prometheus) to receive the response rendered as Prometheus text exposition format ("koyeb_quota_" for usage, "koyeb_quota__limit" for the plan limit) suitable for scraping into an external Prometheus. + +**Arguments**: + +- `organization_id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + #### review\_organization\_capacity @@ -70089,12 +74374,12 @@ Do not edit the class manually. @validate_call def review_organization_capacity( body: ReviewOrganizationCapacityRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70134,12 +74419,12 @@ Returns the result object. @validate_call def review_organization_capacity_with_http_info( body: ReviewOrganizationCapacityRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70179,12 +74464,12 @@ Returns the result object. @validate_call def review_organization_capacity_without_preload_content( body: ReviewOrganizationCapacityRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70251,18 +74536,18 @@ Do not edit the class manually. def get_organization_usage( starting_time: Annotated[ Optional[datetime], - Field(description="The starting time of the period to get data from" - )] = None, + Field(description="The starting time of the period to get data from"), + ] = None, ending_time: Annotated[ Optional[datetime], - Field(description="The ending time of the period to get data from" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="The ending time of the period to get data from"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70304,18 +74589,18 @@ Returns the result object. def get_organization_usage_with_http_info( starting_time: Annotated[ Optional[datetime], - Field(description="The starting time of the period to get data from" - )] = None, + Field(description="The starting time of the period to get data from"), + ] = None, ending_time: Annotated[ Optional[datetime], - Field(description="The ending time of the period to get data from" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="The ending time of the period to get data from"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70357,18 +74642,18 @@ Returns the result object. def get_organization_usage_without_preload_content( starting_time: Annotated[ Optional[datetime], - Field(description="The starting time of the period to get data from" - )] = None, + Field(description="The starting time of the period to get data from"), + ] = None, ending_time: Annotated[ Optional[datetime], - Field(description="The ending time of the period to get data from" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="The ending time of the period to get data from"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70410,36 +74695,39 @@ Returns the result object. def get_organization_usage_details( starting_time: Annotated[ Optional[datetime], - Field(description="The starting time of the period to get data from" - )] = None, + Field(description="The starting time of the period to get data from"), + ] = None, ending_time: Annotated[ Optional[datetime], - Field(description="The ending time of the period to get data from" - )] = None, + Field(description="The ending time of the period to get data from"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, accept: Annotated[ Optional[StrictStr], Field(description= - "If defined with the value 'text/csv', a csv file is returned" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If defined with the value 'text/csv', a csv file is returned"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70485,36 +74773,39 @@ Returns the result object. def get_organization_usage_details_with_http_info( starting_time: Annotated[ Optional[datetime], - Field(description="The starting time of the period to get data from" - )] = None, + Field(description="The starting time of the period to get data from"), + ] = None, ending_time: Annotated[ Optional[datetime], - Field(description="The ending time of the period to get data from" - )] = None, + Field(description="The ending time of the period to get data from"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, accept: Annotated[ Optional[StrictStr], Field(description= - "If defined with the value 'text/csv', a csv file is returned" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If defined with the value 'text/csv', a csv file is returned"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70560,36 +74851,39 @@ Returns the result object. def get_organization_usage_details_without_preload_content( starting_time: Annotated[ Optional[datetime], - Field(description="The starting time of the period to get data from" - )] = None, + Field(description="The starting time of the period to get data from"), + ] = None, ending_time: Annotated[ Optional[datetime], - Field(description="The ending time of the period to get data from" - )] = None, + Field(description="The ending time of the period to get data from"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, accept: Annotated[ Optional[StrictStr], Field(description= - "If defined with the value 'text/csv', a csv file is returned" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If defined with the value 'text/csv', a csv file is returned"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70662,12 +74956,12 @@ def login( body: LoginRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70710,12 +75004,12 @@ def login_with_http_info( body: LoginRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70758,12 +75052,12 @@ def login_without_preload_content( body: LoginRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70802,12 +75096,12 @@ Returns the result object. ```python @validate_call -def logout(_request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, +def logout(_request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], +] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70844,12 +75138,12 @@ Returns the result object. ```python @validate_call def logout_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70887,12 +75181,12 @@ Returns the result object. ```python @validate_call def logout_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70930,12 +75224,12 @@ Returns the result object. ```python @validate_call def new_session( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70975,12 +75269,12 @@ Returns the result object. ```python @validate_call def new_session_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71020,12 +75314,12 @@ Returns the result object. ```python @validate_call def new_session_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71065,12 +75359,12 @@ Returns the result object. ```python @validate_call def refresh_token( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71108,12 +75402,12 @@ Returns the result object. ```python @validate_call def refresh_token_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71151,12 +75445,12 @@ Returns the result object. ```python @validate_call def refresh_token_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71221,12 +75515,12 @@ Do not edit the class manually. @validate_call def create_secret( secret: CreateSecret, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71266,12 +75560,12 @@ Returns the result object. @validate_call def create_secret_with_http_info( secret: CreateSecret, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71311,12 +75605,12 @@ Returns the result object. @validate_call def create_secret_without_preload_content( secret: CreateSecret, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71356,12 +75650,12 @@ Returns the result object. @validate_call def delete_secret( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71400,12 +75694,12 @@ Returns the result object. @validate_call def delete_secret_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71445,12 +75739,12 @@ Returns the result object. @validate_call def delete_secret_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71490,12 +75784,12 @@ Returns the result object. @validate_call def get_secret( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71535,12 +75829,12 @@ Returns the result object. @validate_call def get_secret_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71580,12 +75874,12 @@ Returns the result object. @validate_call def get_secret_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71629,15 +75923,16 @@ def list_secrets( offset: Optional[StrictStr] = None, types: Annotated[Optional[List[StrictStr]], Field(description="Filter by secret types")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on secret ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71653,7 +75948,7 @@ List Secrets - `limit` (`str`): - `offset` (`str`): - `types` (`List[str]`): Filter by secret types -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on secret ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -71685,15 +75980,16 @@ def list_secrets_with_http_info( offset: Optional[StrictStr] = None, types: Annotated[Optional[List[StrictStr]], Field(description="Filter by secret types")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on secret ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71709,7 +76005,7 @@ List Secrets - `limit` (`str`): - `offset` (`str`): - `types` (`List[str]`): Filter by secret types -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on secret ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -71741,15 +76037,16 @@ def list_secrets_without_preload_content( offset: Optional[StrictStr] = None, types: Annotated[Optional[List[StrictStr]], Field(description="Filter by secret types")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on secret ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71765,7 +76062,7 @@ List Secrets - `limit` (`str`): - `offset` (`str`): - `types` (`List[str]`): Filter by secret types -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on secret ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -71794,12 +76091,12 @@ Returns the result object. def reveal_secret( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71841,12 +76138,12 @@ Returns the result object. def reveal_secret_with_http_info( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71888,12 +76185,12 @@ Returns the result object. def reveal_secret_without_preload_content( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71936,12 +76233,12 @@ def update_secret( id: StrictStr, secret: Secret, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71985,12 +76282,12 @@ def update_secret_with_http_info( id: StrictStr, secret: Secret, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72034,12 +76331,12 @@ def update_secret_without_preload_content( id: StrictStr, secret: Secret, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72083,12 +76380,12 @@ def update_secret2( id: StrictStr, secret: Secret, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72132,12 +76429,12 @@ def update_secret2_with_http_info( id: StrictStr, secret: Secret, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72181,12 +76478,12 @@ def update_secret2_without_preload_content( id: StrictStr, secret: Secret, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72255,14 +76552,15 @@ Do not edit the class manually. def accept_organization_invitation( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to accept")], + Field(description="The id of the organization invitation to accept"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72304,14 +76602,15 @@ Returns the result object. def accept_organization_invitation_with_http_info( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to accept")], + Field(description="The id of the organization invitation to accept"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72353,14 +76652,15 @@ Returns the result object. def accept_organization_invitation_without_preload_content( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to accept")], + Field(description="The id of the organization invitation to accept"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72401,12 +76701,12 @@ Returns the result object. @validate_call def clear_idenfy_verification_result( body: ClearIdenfyVerificationResultRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72445,12 +76745,12 @@ Returns the result object. @validate_call def clear_idenfy_verification_result_with_http_info( body: ClearIdenfyVerificationResultRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72490,12 +76790,12 @@ Returns the result object. @validate_call def clear_idenfy_verification_result_without_preload_content( body: ClearIdenfyVerificationResultRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72536,14 +76836,15 @@ Returns the result object. def decline_organization_invitation( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to decline")], + Field(description="The id of the organization invitation to decline"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72585,14 +76886,15 @@ Returns the result object. def decline_organization_invitation_with_http_info( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to decline")], + Field(description="The id of the organization invitation to decline"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72634,14 +76936,15 @@ Returns the result object. def decline_organization_invitation_without_preload_content( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to decline")], + Field(description="The id of the organization invitation to decline"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72681,12 +76984,12 @@ Returns the result object. ```python @validate_call def get_current_organization( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72724,12 +77027,12 @@ Returns the result object. ```python @validate_call def get_current_organization_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72767,12 +77070,12 @@ Returns the result object. ```python @validate_call def get_current_organization_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72812,12 +77115,12 @@ Returns the result object. def get_current_user( seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72857,12 +77160,12 @@ Returns the result object. def get_current_user_with_http_info( seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72903,12 +77206,12 @@ Returns the result object. def get_current_user_without_preload_content( seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72947,12 +77250,12 @@ Returns the result object. ```python @validate_call def get_idenfy_token( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72990,12 +77293,12 @@ Returns the result object. ```python @validate_call def get_idenfy_token_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73033,12 +77336,12 @@ Returns the result object. ```python @validate_call def get_idenfy_token_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73078,20 +77381,21 @@ Returns the result object. def get_o_auth_options( action: Annotated[ Optional[StrictStr], - Field(description="Which authentication flow is being initiated" - )] = None, + Field(description="Which authentication flow is being initiated"), + ] = None, metadata: Annotated[ Optional[StrictStr], Field( description= "A small (limited to 400 characters) string of arbitrary metadata which will be encoded in the state" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73133,20 +77437,21 @@ Returns the result object. def get_o_auth_options_with_http_info( action: Annotated[ Optional[StrictStr], - Field(description="Which authentication flow is being initiated" - )] = None, + Field(description="Which authentication flow is being initiated"), + ] = None, metadata: Annotated[ Optional[StrictStr], Field( description= "A small (limited to 400 characters) string of arbitrary metadata which will be encoded in the state" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73188,20 +77493,21 @@ Returns the result object. def get_o_auth_options_without_preload_content( action: Annotated[ Optional[StrictStr], - Field(description="Which authentication flow is being initiated" - )] = None, + Field(description="Which authentication flow is being initiated"), + ] = None, metadata: Annotated[ Optional[StrictStr], Field( description= "A small (limited to 400 characters) string of arbitrary metadata which will be encoded in the state" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73244,12 +77550,12 @@ def get_user_organization_invitation( id: Annotated[ StrictStr, Field(description="The id of the organization invitation to get")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73291,12 +77597,12 @@ def get_user_organization_invitation_with_http_info( id: Annotated[ StrictStr, Field(description="The id of the organization invitation to get")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73338,12 +77644,12 @@ def get_user_organization_invitation_without_preload_content( id: Annotated[ StrictStr, Field(description="The id of the organization invitation to get")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73382,12 +77688,12 @@ Returns the result object. ```python @validate_call def get_user_settings( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73425,12 +77731,12 @@ Returns the result object. ```python @validate_call def get_user_settings_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73468,12 +77774,12 @@ Returns the result object. ```python @validate_call def get_user_settings_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73513,22 +77819,25 @@ Returns the result object. def list_user_organization_invitations( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on organization invitation statuses" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73571,22 +77880,25 @@ Returns the result object. def list_user_organization_invitations_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on organization invitation statuses" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73629,22 +77941,25 @@ Returns the result object. def list_user_organization_invitations_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on organization invitation statuses" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73690,31 +78005,35 @@ def list_user_organizations( Field(description="(Optional) Define pagination limit")] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) Define pagination offset")] = None, + Field(description="(Optional) Define pagination offset"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, search: Annotated[ Optional[StrictStr], Field( description= "(Optional) Fuzzy case-insensitive search based on organization name or organization id" - )] = None, + ), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Only return organizations which status match one in the list" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73764,31 +78083,35 @@ def list_user_organizations_with_http_info( Field(description="(Optional) Define pagination limit")] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) Define pagination offset")] = None, + Field(description="(Optional) Define pagination offset"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, search: Annotated[ Optional[StrictStr], Field( description= "(Optional) Fuzzy case-insensitive search based on organization name or organization id" - )] = None, + ), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Only return organizations which status match one in the list" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73838,31 +78161,35 @@ def list_user_organizations_without_preload_content( Field(description="(Optional) Define pagination limit")] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) Define pagination offset")] = None, + Field(description="(Optional) Define pagination offset"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, search: Annotated[ Optional[StrictStr], Field( description= "(Optional) Fuzzy case-insensitive search based on organization name or organization id" - )] = None, + ), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Only return organizations which status match one in the list" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73908,12 +78235,12 @@ Returns the result object. @validate_call def login_method( email: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73953,12 +78280,12 @@ Returns the result object. @validate_call def login_method_with_http_info( email: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73998,12 +78325,12 @@ Returns the result object. @validate_call def login_method_without_preload_content( email: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74045,12 +78372,12 @@ def o_auth_callback( body: OAuthCallbackRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74093,12 +78420,12 @@ def o_auth_callback_with_http_info( body: OAuthCallbackRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74141,12 +78468,12 @@ def o_auth_callback_without_preload_content( body: OAuthCallbackRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74187,12 +78514,12 @@ Returns the result object. @validate_call def resend_email_validation( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74231,12 +78558,12 @@ Returns the result object. @validate_call def resend_email_validation_with_http_info( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74276,12 +78603,12 @@ Returns the result object. @validate_call def resend_email_validation_without_preload_content( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74321,12 +78648,12 @@ Returns the result object. @validate_call def reset_password( body: ResetPasswordRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74365,12 +78692,12 @@ Returns the result object. @validate_call def reset_password_with_http_info( body: ResetPasswordRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74410,12 +78737,12 @@ Returns the result object. @validate_call def reset_password_without_preload_content( body: ResetPasswordRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74458,12 +78785,12 @@ def signup( Field(description="Create new account")], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74507,12 +78834,12 @@ def signup_with_http_info( Field(description="Create new account")], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74556,12 +78883,12 @@ def signup_without_preload_content( Field(description="Create new account")], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74604,12 +78931,12 @@ def update_password( body: UpdatePasswordRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74652,12 +78979,12 @@ def update_password_with_http_info( body: UpdatePasswordRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74700,12 +79027,12 @@ def update_password_without_preload_content( body: UpdatePasswordRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74747,12 +79074,12 @@ Returns the result object. def update_user( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74793,12 +79120,12 @@ Returns the result object. def update_user_with_http_info( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74840,12 +79167,12 @@ Returns the result object. def update_user_without_preload_content( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74887,12 +79214,12 @@ Returns the result object. def update_user2( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74933,12 +79260,12 @@ Returns the result object. def update_user2_with_http_info( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74980,12 +79307,12 @@ Returns the result object. def update_user2_without_preload_content( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75026,12 +79353,12 @@ Returns the result object. @validate_call def update_user_settings( body: UpdateUserSettingsRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75071,12 +79398,12 @@ Returns the result object. @validate_call def update_user_settings_with_http_info( body: UpdateUserSettingsRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75116,12 +79443,12 @@ Returns the result object. @validate_call def update_user_settings_without_preload_content( body: UpdateUserSettingsRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75162,12 +79489,12 @@ Returns the result object. def update_user_v2( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75208,12 +79535,12 @@ Returns the result object. def update_user_v2_with_http_info( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75255,12 +79582,12 @@ Returns the result object. def update_user_v2_without_preload_content( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75302,12 +79629,12 @@ Returns the result object. def update_user_v22( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75348,12 +79675,12 @@ Returns the result object. def update_user_v22_with_http_info( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75395,12 +79722,12 @@ Returns the result object. def update_user_v22_without_preload_content( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75443,12 +79770,12 @@ def validate( id: StrictStr, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75491,12 +79818,12 @@ def validate_with_http_info( id: StrictStr, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75539,12 +79866,12 @@ def validate_without_preload_content( id: StrictStr, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75610,12 +79937,12 @@ Do not edit the class manually. ```python @validate_call def test_anon( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75652,12 +79979,12 @@ Returns the result object. ```python @validate_call def test_anon_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75695,12 +80022,12 @@ Returns the result object. ```python @validate_call def test_anon_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75739,12 +80066,12 @@ Returns the result object. @validate_call def test_auth( body: KtestTestAuthRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75784,12 +80111,12 @@ Returns the result object. @validate_call def test_auth_with_http_info( body: KtestTestAuthRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75829,12 +80156,12 @@ Returns the result object. @validate_call def test_auth_without_preload_content( body: KtestTestAuthRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75901,12 +80228,12 @@ Do not edit the class manually. def get_catalog_instance( id: Annotated[StrictStr, Field(description="The name of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75947,12 +80274,12 @@ Returns the result object. def get_catalog_instance_with_http_info( id: Annotated[StrictStr, Field(description="The name of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75993,12 +80320,12 @@ Returns the result object. def get_catalog_instance_without_preload_content( id: Annotated[StrictStr, Field(description="The name of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76039,20 +80366,22 @@ Returns the result object. def list_catalog_instances( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, id: Annotated[Optional[StrictStr], Field( description="(Optional) A filter for instances")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76095,20 +80424,22 @@ Returns the result object. def list_catalog_instances_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, id: Annotated[Optional[StrictStr], Field( description="(Optional) A filter for instances")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76151,20 +80482,22 @@ Returns the result object. def list_catalog_instances_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, id: Annotated[Optional[StrictStr], Field( description="(Optional) A filter for instances")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76235,33 +80568,36 @@ def exec_command( Field(description="ID of the resource to exec on.")] = None, body_command: Annotated[ Optional[List[StrictStr]], - Field(description="Command to exec. Mandatory in the first frame sent" - )] = None, + Field( + description="Command to exec. Mandatory in the first frame sent"), + ] = None, body_tty_size_height: Optional[StrictInt] = None, body_tty_size_width: Optional[StrictInt] = None, body_stdin_data: Annotated[ Optional[Union[StrictBytes, StrictStr]], - Field(description="Data is base64 encoded")] = None, + Field(description="Data is base64 encoded"), + ] = None, body_stdin_close: Annotated[ Optional[StrictBool], Field(description="Indicate last data frame")] = None, body_disable_tty: Annotated[ Optional[StrictBool], Field(description= - "Disable TTY. It's enough to specify it in the first frame" - )] = None, + "Disable TTY. It's enough to specify it in the first frame"), + ] = None, id_type: Annotated[ Optional[StrictStr], Field( description= "When specified, it is used to determine if the kind of resource the id refers to. If missing, defaults to the instance id." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76313,33 +80649,36 @@ def exec_command_with_http_info( Field(description="ID of the resource to exec on.")] = None, body_command: Annotated[ Optional[List[StrictStr]], - Field(description="Command to exec. Mandatory in the first frame sent" - )] = None, + Field( + description="Command to exec. Mandatory in the first frame sent"), + ] = None, body_tty_size_height: Optional[StrictInt] = None, body_tty_size_width: Optional[StrictInt] = None, body_stdin_data: Annotated[ Optional[Union[StrictBytes, StrictStr]], - Field(description="Data is base64 encoded")] = None, + Field(description="Data is base64 encoded"), + ] = None, body_stdin_close: Annotated[ Optional[StrictBool], Field(description="Indicate last data frame")] = None, body_disable_tty: Annotated[ Optional[StrictBool], Field(description= - "Disable TTY. It's enough to specify it in the first frame" - )] = None, + "Disable TTY. It's enough to specify it in the first frame"), + ] = None, id_type: Annotated[ Optional[StrictStr], Field( description= "When specified, it is used to determine if the kind of resource the id refers to. If missing, defaults to the instance id." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76391,33 +80730,36 @@ def exec_command_without_preload_content( Field(description="ID of the resource to exec on.")] = None, body_command: Annotated[ Optional[List[StrictStr]], - Field(description="Command to exec. Mandatory in the first frame sent" - )] = None, + Field( + description="Command to exec. Mandatory in the first frame sent"), + ] = None, body_tty_size_height: Optional[StrictInt] = None, body_tty_size_width: Optional[StrictInt] = None, body_stdin_data: Annotated[ Optional[Union[StrictBytes, StrictStr]], - Field(description="Data is base64 encoded")] = None, + Field(description="Data is base64 encoded"), + ] = None, body_stdin_close: Annotated[ Optional[StrictBool], Field(description="Indicate last data frame")] = None, body_disable_tty: Annotated[ Optional[StrictBool], Field(description= - "Disable TTY. It's enough to specify it in the first frame" - )] = None, + "Disable TTY. It's enough to specify it in the first frame"), + ] = None, id_type: Annotated[ Optional[StrictStr], Field( description= "When specified, it is used to determine if the kind of resource the id refers to. If missing, defaults to the instance id." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76467,12 +80809,12 @@ Returns the result object. def get_instance( id: Annotated[StrictStr, Field(description="The id of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76513,12 +80855,12 @@ Returns the result object. def get_instance_with_http_info( id: Annotated[StrictStr, Field(description="The id of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76559,12 +80901,12 @@ Returns the result object. def get_instance_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76605,29 +80947,34 @@ Returns the result object. def list_instance_events( instance_ids: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on list of instance id")] = None, + Field(description="(Optional) Filter on list of instance id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance event types")] = None, + Field(description="(Optional) Filter on instance event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76672,29 +81019,34 @@ Returns the result object. def list_instance_events_with_http_info( instance_ids: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on list of instance id")] = None, + Field(description="(Optional) Filter on list of instance id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance event types")] = None, + Field(description="(Optional) Filter on instance event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76739,29 +81091,34 @@ Returns the result object. def list_instance_events_without_preload_content( instance_ids: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on list of instance id")] = None, + Field(description="(Optional) Filter on list of instance id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance event types")] = None, + Field(description="(Optional) Filter on instance event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76806,7 +81163,8 @@ Returns the result object. def list_instances( app_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on application id")] = None, + Field(description="(Optional) Filter on application id"), + ] = None, service_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on service id")] = None, @@ -76815,8 +81173,8 @@ def list_instances( Field(description="(Optional) Filter on deployment id")] = None, regional_deployment_id: Annotated[ Optional[StrictStr], - Field( - description="(Optional) Filter on regional deployment id")] = None, + Field(description="(Optional) Filter on regional deployment id"), + ] = None, allocation_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on allocation id")] = None, @@ -76825,36 +81183,45 @@ def list_instances( Field(description="(Optional) Filter on replica index")] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance statuses")] = None, + Field(description="(Optional) Filter on instance statuses"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, starting_time: Annotated[ Optional[datetime], - Field(description= - "(Optional) The starting time of the period of running instance" - )] = None, + Field( + description= + "(Optional) The starting time of the period of running instance"), + ] = None, ending_time: Annotated[ Optional[datetime], Field(description= - "(Optional) The ending time of the period of running instance" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "(Optional) The ending time of the period of running instance"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on instance ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76878,6 +81245,7 @@ List Instances - `order` (`str`): (Optional) Sorts the list in the ascending or the descending order - `starting_time` (`datetime`): (Optional) The starting time of the period of running instance - `ending_time` (`datetime`): (Optional) The ending time of the period of running instance +- `ids` (`List[str]`): (Optional) Filter on instance ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -76906,7 +81274,8 @@ Returns the result object. def list_instances_with_http_info( app_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on application id")] = None, + Field(description="(Optional) Filter on application id"), + ] = None, service_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on service id")] = None, @@ -76915,8 +81284,8 @@ def list_instances_with_http_info( Field(description="(Optional) Filter on deployment id")] = None, regional_deployment_id: Annotated[ Optional[StrictStr], - Field( - description="(Optional) Filter on regional deployment id")] = None, + Field(description="(Optional) Filter on regional deployment id"), + ] = None, allocation_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on allocation id")] = None, @@ -76925,36 +81294,45 @@ def list_instances_with_http_info( Field(description="(Optional) Filter on replica index")] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance statuses")] = None, + Field(description="(Optional) Filter on instance statuses"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, starting_time: Annotated[ Optional[datetime], - Field(description= - "(Optional) The starting time of the period of running instance" - )] = None, + Field( + description= + "(Optional) The starting time of the period of running instance"), + ] = None, ending_time: Annotated[ Optional[datetime], Field(description= - "(Optional) The ending time of the period of running instance" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "(Optional) The ending time of the period of running instance"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on instance ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76978,6 +81356,7 @@ List Instances - `order` (`str`): (Optional) Sorts the list in the ascending or the descending order - `starting_time` (`datetime`): (Optional) The starting time of the period of running instance - `ending_time` (`datetime`): (Optional) The ending time of the period of running instance +- `ids` (`List[str]`): (Optional) Filter on instance ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -77006,7 +81385,8 @@ Returns the result object. def list_instances_without_preload_content( app_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on application id")] = None, + Field(description="(Optional) Filter on application id"), + ] = None, service_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on service id")] = None, @@ -77015,8 +81395,8 @@ def list_instances_without_preload_content( Field(description="(Optional) Filter on deployment id")] = None, regional_deployment_id: Annotated[ Optional[StrictStr], - Field( - description="(Optional) Filter on regional deployment id")] = None, + Field(description="(Optional) Filter on regional deployment id"), + ] = None, allocation_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on allocation id")] = None, @@ -77025,36 +81405,45 @@ def list_instances_without_preload_content( Field(description="(Optional) Filter on replica index")] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance statuses")] = None, + Field(description="(Optional) Filter on instance statuses"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, starting_time: Annotated[ Optional[datetime], - Field(description= - "(Optional) The starting time of the period of running instance" - )] = None, + Field( + description= + "(Optional) The starting time of the period of running instance"), + ] = None, ending_time: Annotated[ Optional[datetime], Field(description= - "(Optional) The ending time of the period of running instance" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "(Optional) The ending time of the period of running instance"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on instance ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77078,6 +81467,7 @@ List Instances - `order` (`str`): (Optional) Sorts the list in the ascending or the descending order - `starting_time` (`datetime`): (Optional) The starting time of the period of running instance - `ending_time` (`datetime`): (Optional) The ending time of the period of running instance +- `ids` (`List[str]`): (Optional) Filter on instance ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -77131,12 +81521,12 @@ Do not edit the class manually. @validate_call def compose( compose: CreateCompose, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77176,12 +81566,12 @@ Returns the result object. @validate_call def compose_with_http_info( compose: CreateCompose, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77221,12 +81611,12 @@ Returns the result object. @validate_call def compose_without_preload_content( compose: CreateCompose, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77291,12 +81681,12 @@ Do not edit the class manually. ```python @validate_call def has_unpaid_invoices( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77336,12 +81726,12 @@ Returns the result object. ```python @validate_call def has_unpaid_invoices_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77381,12 +81771,12 @@ Returns the result object. ```python @validate_call def has_unpaid_invoices_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77426,12 +81816,12 @@ Returns the result object. ```python @validate_call def manage( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77469,12 +81859,12 @@ Returns the result object. ```python @validate_call def manage_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77512,12 +81902,12 @@ Returns the result object. ```python @validate_call def manage_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77555,12 +81945,12 @@ Returns the result object. ```python @validate_call def next_invoice( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77600,12 +81990,12 @@ Returns the result object. ```python @validate_call def next_invoice_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77645,12 +82035,12 @@ Returns the result object. ```python @validate_call def next_invoice_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77718,12 +82108,12 @@ Do not edit the class manually. def search( query: Annotated[Optional[StrictStr], Field(description="(Optional) Search query")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77764,12 +82154,12 @@ Returns the result object. def search_with_http_info( query: Annotated[Optional[StrictStr], Field(description="(Optional) Search query")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77810,12 +82200,12 @@ Returns the result object. def search_without_preload_content( query: Annotated[Optional[StrictStr], Field(description="(Optional) Search query")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77882,27 +82272,31 @@ Do not edit the class manually. def list_branches( repository_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on one repository.")] = None, + Field(description="(Optional) Filter on one repository."), + ] = None, name: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on branch name using a fuzzy search. Repository filter is required to enable this filter." - )] = None, + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return.")] = None, + Field(description="(Optional) The number of items to return."), + ] = None, offset: Annotated[ Optional[StrictStr], Field( description="(Optional) The offset in the list of item to return." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77946,27 +82340,31 @@ Returns the result object. def list_branches_with_http_info( repository_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on one repository.")] = None, + Field(description="(Optional) Filter on one repository."), + ] = None, name: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on branch name using a fuzzy search. Repository filter is required to enable this filter." - )] = None, + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return.")] = None, + Field(description="(Optional) The number of items to return."), + ] = None, offset: Annotated[ Optional[StrictStr], Field( description="(Optional) The offset in the list of item to return." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78010,27 +82408,31 @@ Returns the result object. def list_branches_without_preload_content( repository_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on one repository.")] = None, + Field(description="(Optional) Filter on one repository."), + ] = None, name: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on branch name using a fuzzy search. Repository filter is required to enable this filter." - )] = None, + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return.")] = None, + Field(description="(Optional) The number of items to return."), + ] = None, offset: Annotated[ Optional[StrictStr], Field( description="(Optional) The offset in the list of item to return." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78075,28 +82477,31 @@ def list_repositories( name: Annotated[ Optional[StrictStr], Field(description= - "(Optional) Filter on repository name using a fuzzy search." - )] = None, + "(Optional) Filter on repository name using a fuzzy search."), + ] = None, name_search_op: Annotated[ Optional[StrictStr], Field( description= - "(Optional) Define search operation for repository name. Accept either \"fuzzy\" or \"equality\", use \"fuzzy\" by default." - )] = None, + '(Optional) Define search operation for repository name. Accept either "fuzzy" or "equality", use "fuzzy" by default.' + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return.")] = None, + Field(description="(Optional) The number of items to return."), + ] = None, offset: Annotated[ Optional[StrictStr], Field( description="(Optional) The offset in the list of item to return." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78141,28 +82546,31 @@ def list_repositories_with_http_info( name: Annotated[ Optional[StrictStr], Field(description= - "(Optional) Filter on repository name using a fuzzy search." - )] = None, + "(Optional) Filter on repository name using a fuzzy search."), + ] = None, name_search_op: Annotated[ Optional[StrictStr], Field( description= - "(Optional) Define search operation for repository name. Accept either \"fuzzy\" or \"equality\", use \"fuzzy\" by default." - )] = None, + '(Optional) Define search operation for repository name. Accept either "fuzzy" or "equality", use "fuzzy" by default.' + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return.")] = None, + Field(description="(Optional) The number of items to return."), + ] = None, offset: Annotated[ Optional[StrictStr], Field( description="(Optional) The offset in the list of item to return." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78207,28 +82615,31 @@ def list_repositories_without_preload_content( name: Annotated[ Optional[StrictStr], Field(description= - "(Optional) Filter on repository name using a fuzzy search." - )] = None, + "(Optional) Filter on repository name using a fuzzy search."), + ] = None, name_search_op: Annotated[ Optional[StrictStr], Field( description= - "(Optional) Define search operation for repository name. Accept either \"fuzzy\" or \"equality\", use \"fuzzy\" by default." - )] = None, + '(Optional) Define search operation for repository name. Accept either "fuzzy" or "equality", use "fuzzy" by default.' + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return.")] = None, + Field(description="(Optional) The number of items to return."), + ] = None, offset: Annotated[ Optional[StrictStr], Field( description="(Optional) The offset in the list of item to return." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78271,12 +82682,12 @@ Returns the result object. @validate_call def resync_organization( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78315,12 +82726,12 @@ Returns the result object. @validate_call def resync_organization_with_http_info( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78360,12 +82771,12 @@ Returns the result object. @validate_call def resync_organization_without_preload_content( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78431,12 +82842,12 @@ Do not edit the class manually. @validate_call def create_instance_snapshot( body: CreateInstanceSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78476,12 +82887,12 @@ Returns the result object. @validate_call def create_instance_snapshot_with_http_info( body: CreateInstanceSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78521,12 +82932,12 @@ Returns the result object. @validate_call def create_instance_snapshot_without_preload_content( body: CreateInstanceSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78566,12 +82977,12 @@ Returns the result object. @validate_call def delete_instance_snapshot( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78611,12 +83022,12 @@ Returns the result object. @validate_call def delete_instance_snapshot_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78656,12 +83067,12 @@ Returns the result object. @validate_call def delete_instance_snapshot_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78701,12 +83112,12 @@ Returns the result object. @validate_call def get_instance_snapshot( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78746,12 +83157,12 @@ Returns the result object. @validate_call def get_instance_snapshot_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78791,12 +83202,12 @@ Returns the result object. @validate_call def get_instance_snapshot_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78837,30 +83248,35 @@ Returns the result object. def list_instance_snapshot_events( instance_snapshot_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on instance snapshot id")] = None, + Field(description="(Optional) Filter on instance snapshot id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance snapshot event types" - )] = None, + Field( + description="(Optional) Filter on instance snapshot event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78905,30 +83321,35 @@ Returns the result object. def list_instance_snapshot_events_with_http_info( instance_snapshot_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on instance snapshot id")] = None, + Field(description="(Optional) Filter on instance snapshot id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance snapshot event types" - )] = None, + Field( + description="(Optional) Filter on instance snapshot event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78973,30 +83394,35 @@ Returns the result object. def list_instance_snapshot_events_without_preload_content( instance_snapshot_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on instance snapshot id")] = None, + Field(description="(Optional) Filter on instance snapshot id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance snapshot event types" - )] = None, + Field( + description="(Optional) Filter on instance snapshot event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79044,12 +83470,13 @@ def list_instance_snapshots( name: Optional[StrictStr] = None, statuses: Optional[List[StrictStr]] = None, type: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Optional[List[StrictStr]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79066,6 +83493,7 @@ list_instance_snapshots - `name` (`str`): - `statuses` (`List[str]`): - `type` (`str`): +- `ids` (`List[str]`): - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -79097,12 +83525,13 @@ def list_instance_snapshots_with_http_info( name: Optional[StrictStr] = None, statuses: Optional[List[StrictStr]] = None, type: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Optional[List[StrictStr]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79119,6 +83548,7 @@ list_instance_snapshots - `name` (`str`): - `statuses` (`List[str]`): - `type` (`str`): +- `ids` (`List[str]`): - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -79150,12 +83580,13 @@ def list_instance_snapshots_without_preload_content( name: Optional[StrictStr] = None, statuses: Optional[List[StrictStr]] = None, type: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Optional[List[StrictStr]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79172,6 +83603,7 @@ list_instance_snapshots - `name` (`str`): - `statuses` (`List[str]`): - `type` (`str`): +- `ids` (`List[str]`): - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -79225,12 +83657,12 @@ Do not edit the class manually. @validate_call def create_snapshot( body: CreateSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79270,12 +83702,12 @@ Returns the result object. @validate_call def create_snapshot_with_http_info( body: CreateSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79315,12 +83747,12 @@ Returns the result object. @validate_call def create_snapshot_without_preload_content( body: CreateSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79360,12 +83792,12 @@ Returns the result object. @validate_call def delete_snapshot( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79405,12 +83837,12 @@ Returns the result object. @validate_call def delete_snapshot_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79450,12 +83882,12 @@ Returns the result object. @validate_call def delete_snapshot_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79495,12 +83927,12 @@ Returns the result object. @validate_call def get_snapshot( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79540,12 +83972,12 @@ Returns the result object. @validate_call def get_snapshot_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79585,12 +84017,12 @@ Returns the result object. @validate_call def get_snapshot_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79631,29 +84063,37 @@ Returns the result object. def list_snapshots( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter by organization_id")] = None, + Field(description="(Optional) Filter by organization_id"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter by status - SNAPSHOT_STATUS_INVALID: zero value, invalid - SNAPSHOT_STATUS_CREATING: the snapshot is being created - SNAPSHOT_STATUS_AVAILABLE: the snapshot is complete and available - SNAPSHOT_STATUS_MIGRATING: the snapshot is being migrated - SNAPSHOT_STATUS_DELETING: the snapshot is being deleted - SNAPSHOT_STATUS_DELETED: the snapshot is deleted" - )] = None, + ), + ] = None, region: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the region")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on snapshot ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79670,6 +84110,7 @@ List all Snapshots - `organization_id` (`str`): (Optional) Filter by organization_id - `statuses` (`List[str]`): (Optional) Filter by status - SNAPSHOT_STATUS_INVALID: zero value, invalid - SNAPSHOT_STATUS_CREATING: the snapshot is being created - SNAPSHOT_STATUS_AVAILABLE: the snapshot is complete and available - SNAPSHOT_STATUS_MIGRATING: the snapshot is being migrated - SNAPSHOT_STATUS_DELETING: the snapshot is being deleted - SNAPSHOT_STATUS_DELETED: the snapshot is deleted - `region` (`str`): (Optional) A filter for the region +- `ids` (`List[str]`): (Optional) Filter on snapshot ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -79698,29 +84139,37 @@ Returns the result object. def list_snapshots_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter by organization_id")] = None, + Field(description="(Optional) Filter by organization_id"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter by status - SNAPSHOT_STATUS_INVALID: zero value, invalid - SNAPSHOT_STATUS_CREATING: the snapshot is being created - SNAPSHOT_STATUS_AVAILABLE: the snapshot is complete and available - SNAPSHOT_STATUS_MIGRATING: the snapshot is being migrated - SNAPSHOT_STATUS_DELETING: the snapshot is being deleted - SNAPSHOT_STATUS_DELETED: the snapshot is deleted" - )] = None, + ), + ] = None, region: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the region")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on snapshot ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79737,6 +84186,7 @@ List all Snapshots - `organization_id` (`str`): (Optional) Filter by organization_id - `statuses` (`List[str]`): (Optional) Filter by status - SNAPSHOT_STATUS_INVALID: zero value, invalid - SNAPSHOT_STATUS_CREATING: the snapshot is being created - SNAPSHOT_STATUS_AVAILABLE: the snapshot is complete and available - SNAPSHOT_STATUS_MIGRATING: the snapshot is being migrated - SNAPSHOT_STATUS_DELETING: the snapshot is being deleted - SNAPSHOT_STATUS_DELETED: the snapshot is deleted - `region` (`str`): (Optional) A filter for the region +- `ids` (`List[str]`): (Optional) Filter on snapshot ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -79765,29 +84215,37 @@ Returns the result object. def list_snapshots_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter by organization_id")] = None, + Field(description="(Optional) Filter by organization_id"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter by status - SNAPSHOT_STATUS_INVALID: zero value, invalid - SNAPSHOT_STATUS_CREATING: the snapshot is being created - SNAPSHOT_STATUS_AVAILABLE: the snapshot is complete and available - SNAPSHOT_STATUS_MIGRATING: the snapshot is being migrated - SNAPSHOT_STATUS_DELETING: the snapshot is being deleted - SNAPSHOT_STATUS_DELETED: the snapshot is deleted" - )] = None, + ), + ] = None, region: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the region")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on snapshot ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79804,6 +84262,7 @@ List all Snapshots - `organization_id` (`str`): (Optional) Filter by organization_id - `statuses` (`List[str]`): (Optional) Filter by status - SNAPSHOT_STATUS_INVALID: zero value, invalid - SNAPSHOT_STATUS_CREATING: the snapshot is being created - SNAPSHOT_STATUS_AVAILABLE: the snapshot is complete and available - SNAPSHOT_STATUS_MIGRATING: the snapshot is being migrated - SNAPSHOT_STATUS_DELETING: the snapshot is being deleted - SNAPSHOT_STATUS_DELETED: the snapshot is deleted - `region` (`str`): (Optional) A filter for the region +- `ids` (`List[str]`): (Optional) Filter on snapshot ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -79833,12 +84292,12 @@ def update_snapshot( id: Annotated[StrictStr, Field(description="The id of the snapshot")], body: UpdateSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79881,12 +84340,12 @@ def update_snapshot_with_http_info( id: Annotated[StrictStr, Field(description="The id of the snapshot")], body: UpdateSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79929,12 +84388,12 @@ def update_snapshot_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the snapshot")], body: UpdateSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -80001,12 +84460,12 @@ Do not edit the class manually. @validate_call def get_quotas( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -80046,12 +84505,12 @@ Returns the result object. @validate_call def get_quotas_with_http_info( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -80091,12 +84550,12 @@ Returns the result object. @validate_call def get_quotas_without_preload_content( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, diff --git a/docs/api_async.md b/docs/api_async.md index 3b2caad0..a143b221 100644 --- a/docs/api_async.md +++ b/docs/api_async.md @@ -128,7 +128,7 @@ def __init__(host: Optional[str] = None, connection_pool_maxsize: Optional[int] = None, proxy: Optional[str] = None, proxy_headers: Optional[Any] = None, - safe_chars_for_path_param: str = '', + safe_chars_for_path_param: str = "", client_side_validation: bool = True, socket_options: Optional[Any] = None, datetime_format: str = "%Y-%m-%dT%H:%M:%S.%f%z", @@ -413,6 +413,52 @@ def host(value: str) -> None Fix base path. + + +# koyeb/api\_async.test.test\_service\_pool + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestServicePool Objects + +```python +class TestServicePool(unittest.TestCase) +``` + +ServicePool unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> ServicePool +``` + +Test ServicePool +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testServicePool + +```python +def testServicePool() +``` + +Test ServicePool + # koyeb/api\_async.test.test\_get\_metrics\_reply\_metric @@ -538,6 +584,52 @@ def testKgitproxyIndexingStatus() Test KgitproxyIndexingStatus + + +# koyeb/api\_async.test.test\_persistent\_volume\_region\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestPersistentVolumeRegionUsage Objects + +```python +class TestPersistentVolumeRegionUsage(unittest.TestCase) +``` + +PersistentVolumeRegionUsage unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> PersistentVolumeRegionUsage +``` + +Test PersistentVolumeRegionUsage +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testPersistentVolumeRegionUsage + +```python +def testPersistentVolumeRegionUsage() +``` + +Test PersistentVolumeRegionUsage + # koyeb/api\_async.test.test\_declare\_stage\_progress\_request @@ -2512,6 +2604,52 @@ def testEgressPolicy() Test EgressPolicy + + +# koyeb/api\_async.test.test\_create\_service\_pool + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestCreateServicePool Objects + +```python +class TestCreateServicePool(unittest.TestCase) +``` + +CreateServicePool unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> CreateServicePool +``` + +Test CreateServicePool +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testCreateServicePool + +```python +def testCreateServicePool() +``` + +Test CreateServicePool + # koyeb/api\_async.test.test\_desired\_deployment @@ -3313,6 +3451,52 @@ def testNotificationList() Test NotificationList + + +# koyeb/api\_async.test.test\_update\_service\_pool\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestUpdateServicePoolReply Objects + +```python +class TestUpdateServicePoolReply(unittest.TestCase) +``` + +UpdateServicePoolReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> UpdateServicePoolReply +``` + +Test UpdateServicePoolReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testUpdateServicePoolReply + +```python +def testUpdateServicePoolReply() +``` + +Test UpdateServicePoolReply + # koyeb/api\_async.test.test\_user @@ -5633,6 +5817,52 @@ def testRegionalDeploymentEvent() Test RegionalDeploymentEvent + + +# koyeb/api\_async.test.test\_mesh + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestMesh Objects + +```python +class TestMesh(unittest.TestCase) +``` + +Mesh unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> Mesh +``` + +Test Mesh +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testMesh + +```python +def testMesh() +``` + +Test Mesh + # koyeb/api\_async.test.test\_reset\_password\_request @@ -7606,6 +7836,52 @@ Test case for remove_organization_member Remove an organization member + + +# koyeb/api\_async.test.test\_update\_service\_pool + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestUpdateServicePool Objects + +```python +class TestUpdateServicePool(unittest.TestCase) +``` + +UpdateServicePool unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> UpdateServicePool +``` + +Test UpdateServicePool +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testUpdateServicePool + +```python +def testUpdateServicePool() +``` + +Test UpdateServicePool + # koyeb/api\_async.test.test\_update\_organization\_reply @@ -7928,6 +8204,52 @@ def testCreateInstanceSnapshotRequest() Test CreateInstanceSnapshotRequest + + +# koyeb/api\_async.test.test\_pool\_claim\_request + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestPoolClaimRequest Objects + +```python +class TestPoolClaimRequest(unittest.TestCase) +``` + +PoolClaimRequest unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> PoolClaimRequest +``` + +Test PoolClaimRequest +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testPoolClaimRequest + +```python +def testPoolClaimRequest() +``` + +Test PoolClaimRequest + # koyeb/api\_async.test @@ -9318,6 +9640,39 @@ def testGitSource() Test GitSource + + +# koyeb/api\_async.test.test\_mesh\_scope + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestMeshScope Objects + +```python +class TestMeshScope(unittest.TestCase) +``` + +MeshScope unit test stubs + + + +#### testMeshScope + +```python +def testMeshScope() +``` + +Test MeshScope + # koyeb/api\_async.test.test\_instance\_event @@ -9410,6 +9765,52 @@ def testDockerBuilder() Test DockerBuilder + + +# koyeb/api\_async.test.test\_create\_service\_pool\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestCreateServicePoolReply Objects + +```python +class TestCreateServicePoolReply(unittest.TestCase) +``` + +CreateServicePoolReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> CreateServicePoolReply +``` + +Test CreateServicePoolReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testCreateServicePoolReply + +```python +def testCreateServicePoolReply() +``` + +Test CreateServicePoolReply + # koyeb/api\_async.test.test\_get\_region\_reply @@ -10632,6 +11033,98 @@ Test case for update_secret2 Update Secret + + +# koyeb/api\_async.test.test\_instance\_type\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestInstanceTypeUsage Objects + +```python +class TestInstanceTypeUsage(unittest.TestCase) +``` + +InstanceTypeUsage unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> InstanceTypeUsage +``` + +Test InstanceTypeUsage +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testInstanceTypeUsage + +```python +def testInstanceTypeUsage() +``` + +Test InstanceTypeUsage + + + +# koyeb/api\_async.test.test\_list\_service\_pools\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestListServicePoolsReply Objects + +```python +class TestListServicePoolsReply(unittest.TestCase) +``` + +ListServicePoolsReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> ListServicePoolsReply +``` + +Test ListServicePoolsReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testListServicePoolsReply + +```python +def testListServicePoolsReply() +``` + +Test ListServicePoolsReply + # koyeb/api\_async.test.test\_update\_user\_settings\_request @@ -11967,6 +12460,52 @@ def testSecurityPolicies() Test SecurityPolicies + + +# koyeb/api\_async.test.test\_instance\_snapshot\_type\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestInstanceSnapshotTypeUsage Objects + +```python +class TestInstanceSnapshotTypeUsage(unittest.TestCase) +``` + +InstanceSnapshotTypeUsage unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> InstanceSnapshotTypeUsage +``` + +Test InstanceSnapshotTypeUsage +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testInstanceSnapshotTypeUsage + +```python +def testInstanceSnapshotTypeUsage() +``` + +Test InstanceSnapshotTypeUsage + # koyeb/api\_async.test.test\_credentials\_api @@ -12062,6 +12601,52 @@ Test case for update_credential2 Update credential + + +# koyeb/api\_async.test.test\_get\_service\_pool\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestGetServicePoolReply Objects + +```python +class TestGetServicePoolReply(unittest.TestCase) +``` + +GetServicePoolReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> GetServicePoolReply +``` + +Test GetServicePoolReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testGetServicePoolReply + +```python +def testGetServicePoolReply() +``` + +Test GetServicePoolReply + # koyeb/api\_async.test.test\_user\_role\_role @@ -13482,6 +14067,52 @@ def testRegionAvailability() Test RegionAvailability + + +# koyeb/api\_async.test.test\_list\_pool\_claim\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestListPoolClaimReply Objects + +```python +class TestListPoolClaimReply(unittest.TestCase) +``` + +ListPoolClaimReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> ListPoolClaimReply +``` + +Test ListPoolClaimReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testListPoolClaimReply + +```python +def testListPoolClaimReply() +``` + +Test ListPoolClaimReply + # koyeb/api\_async.test.test\_login\_method\_reply @@ -15049,6 +15680,39 @@ def testInstanceAvailability() Test InstanceAvailability + + +# koyeb/api\_async.test.test\_service\_pool\_status + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestServicePoolStatus Objects + +```python +class TestServicePoolStatus(unittest.TestCase) +``` + +ServicePoolStatus unit test stubs + + + +#### testServicePoolStatus + +```python +def testServicePoolStatus() +``` + +Test ServicePoolStatus + # koyeb/api\_async.test.test\_snapshot @@ -16480,6 +17144,52 @@ def testMetricName() Test MetricName + + +# koyeb/api\_async.test.test\_pool\_claim + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestPoolClaim Objects + +```python +class TestPoolClaim(unittest.TestCase) +``` + +PoolClaim unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> PoolClaim +``` + +Test PoolClaim +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testPoolClaim + +```python +def testPoolClaim() +``` + +Test PoolClaim + # koyeb/api\_async.test.test\_deployment\_scaling\_target\_requests\_per\_second @@ -16527,6 +17237,98 @@ def testDeploymentScalingTargetRequestsPerSecond() Test DeploymentScalingTargetRequestsPerSecond + + +# koyeb/api\_async.test.test\_get\_pool\_claim\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestGetPoolClaimReply Objects + +```python +class TestGetPoolClaimReply(unittest.TestCase) +``` + +GetPoolClaimReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> GetPoolClaimReply +``` + +Test GetPoolClaimReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testGetPoolClaimReply + +```python +def testGetPoolClaimReply() +``` + +Test GetPoolClaimReply + + + +# koyeb/api\_async.test.test\_quota\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestQuotaUsage Objects + +```python +class TestQuotaUsage(unittest.TestCase) +``` + +QuotaUsage unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> QuotaUsage +``` + +Test QuotaUsage +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testQuotaUsage + +```python +def testQuotaUsage() +``` + +Test QuotaUsage + # koyeb/api\_async.test.test\_get\_organization\_reply @@ -17618,6 +18420,52 @@ def testDatabaseUsage() Test DatabaseUsage + + +# koyeb/api\_async.test.test\_get\_organization\_quotas\_usage\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestGetOrganizationQuotasUsageReply Objects + +```python +class TestGetOrganizationQuotasUsageReply(unittest.TestCase) +``` + +GetOrganizationQuotasUsageReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> GetOrganizationQuotasUsageReply +``` + +Test GetOrganizationQuotasUsageReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testGetOrganizationQuotasUsageReply + +```python +def testGetOrganizationQuotasUsageReply() +``` + +Test GetOrganizationQuotasUsageReply + # koyeb/api\_async.test.test\_kgitproxy\_git\_hub\_repository @@ -18705,6 +19553,52 @@ def testKsearchService() Test KsearchService + + +# koyeb/api\_async.test.test\_pool\_claim\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestPoolClaimReply Objects + +```python +class TestPoolClaimReply(unittest.TestCase) +``` + +PoolClaimReply unit test stubs + + + +#### make\_instance + +```python +def make_instance(include_optional) -> PoolClaimReply +``` + +Test PoolClaimReply +include_optional is a boolean, when False only required +params are included, when True both required and +optional params are included + + + +#### testPoolClaimReply + +```python +def testPoolClaimReply() +``` + +Test PoolClaimReply + # koyeb/api\_async.test.test\_decline\_organization\_invitation\_reply @@ -19521,6 +20415,39 @@ def testDeactivateOrganizationReply() Test DeactivateOrganizationReply + + +# koyeb/api\_async.test.test\_pool\_claim\_status + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestPoolClaimStatus Objects + +```python +class TestPoolClaimStatus(unittest.TestCase) +``` + +PoolClaimStatus unit test stubs + + + +#### testPoolClaimStatus + +```python +def testPoolClaimStatus() +``` + +Test PoolClaimStatus + # koyeb/api\_async.test.test\_domain\_load\_balancer\_quotas @@ -20093,6 +21020,65 @@ def testCreateDomainReply() Test CreateDomainReply + + +# koyeb/api\_async.test.test\_pool\_claims\_api + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestPoolClaimsApi Objects + +```python +class TestPoolClaimsApi(unittest.IsolatedAsyncioTestCase) +``` + +PoolClaimsApi unit test stubs + + + +#### test\_claim + +```python +async def test_claim() -> None +``` + +Test case for claim + +Claim a sandbox from a service pool + + + +#### test\_get\_claim + +```python +async def test_get_claim() -> None +``` + +Test case for get_claim + +Get a claim + + + +#### test\_list\_claim + +```python +async def test_list_claim() -> None +``` + +Test case for list_claim + +List claims of a service pool + # koyeb/api\_async.test.test\_accept\_organization\_invitation\_reply @@ -20709,6 +21695,75 @@ def testAppStatus() Test AppStatus + + +# koyeb/api\_async.test.test\_service\_pools\_api + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## TestServicePoolsApi Objects + +```python +class TestServicePoolsApi(unittest.IsolatedAsyncioTestCase) +``` + +ServicePoolsApi unit test stubs + + + +#### test\_create\_service\_pool + +```python +async def test_create_service_pool() -> None +``` + +Test case for create_service_pool + +Create a ServicePool + + + +#### test\_get\_service\_pool + +```python +async def test_get_service_pool() -> None +``` + +Test case for get_service_pool + +Get a ServicePool + + + +#### test\_list\_service\_pools + +```python +async def test_list_service_pools() -> None +``` + +Test case for list_service_pools + +List ServicePools + + + +#### test\_update\_service\_pool + +```python +async def test_update_service_pool() -> None +``` + +Test case for update_service_pool + # koyeb/api\_async.test.test\_persistent\_volume @@ -24037,6 +25092,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of ListSnapshotsReply from a dict + + +# koyeb/api\_async.models.pool\_claim + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## PoolClaim Objects + +```python +class PoolClaim(BaseModel) +``` + +PoolClaim + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of PoolClaim from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of PoolClaim from a dict + # koyeb/api\_async.models.canny\_auth\_reply @@ -26107,6 +27244,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of Token from a dict + + +# koyeb/api\_async.models.get\_service\_pool\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## GetServicePoolReply Objects + +```python +class GetServicePoolReply(BaseModel) +``` + +GetServicePoolReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of GetServicePoolReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of GetServicePoolReply from a dict + # koyeb/api\_async.models.deployment\_proxy\_port @@ -26749,6 +27968,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of CreateCompose from a dict + + +# koyeb/api\_async.models.pool\_claim\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## PoolClaimReply Objects + +```python +class PoolClaimReply(BaseModel) +``` + +PoolClaimReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of PoolClaimReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of PoolClaimReply from a dict + # koyeb/api\_async.models.payment\_method @@ -28225,6 +29526,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of NeonPostgresDatabase from a dict + + +# koyeb/api\_async.models.update\_service\_pool + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## UpdateServicePool Objects + +```python +class UpdateServicePool(BaseModel) +``` + +UpdateServicePool + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of UpdateServicePool from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of UpdateServicePool from a dict + # koyeb/api\_async.models.decline\_organization\_invitation\_reply @@ -29933,6 +31316,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of UpdateUserSettingsRequest from a dict + + +# koyeb/api\_async.models.create\_service\_pool + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## CreateServicePool Objects + +```python +class CreateServicePool(BaseModel) +``` + +CreateServicePool + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of CreateServicePool from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of CreateServicePool from a dict + # koyeb/api\_async.models.user\_role\_role @@ -31265,6 +32730,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of DigitalOceanRegistryConfiguration from a dict + + +# koyeb/api\_async.models.instance\_snapshot\_type\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## InstanceSnapshotTypeUsage Objects + +```python +class InstanceSnapshotTypeUsage(BaseModel) +``` + +InstanceSnapshotTypeUsage + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of InstanceSnapshotTypeUsage from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of InstanceSnapshotTypeUsage from a dict + # koyeb/api\_async.models.list\_user\_organization\_invitations\_reply @@ -33171,6 +34718,40 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of LoginRequest from a dict + + +# koyeb/api\_async.models.pool\_claim\_status + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## PoolClaimStatus Objects + +```python +class PoolClaimStatus(str, Enum) +``` + +PoolClaimStatus + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Self +``` + +Create an instance of PoolClaimStatus from a JSON string + # koyeb/api\_async.models.update\_snapshot\_request @@ -34530,6 +36111,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of GithubInstallationRequest from a dict + + +# koyeb/api\_async.models.get\_pool\_claim\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## GetPoolClaimReply Objects + +```python +class GetPoolClaimReply(BaseModel) +``` + +GetPoolClaimReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of GetPoolClaimReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of GetPoolClaimReply from a dict + # koyeb/api\_async.models.deployment\_scaling\_target\_average\_mem @@ -35500,6 +37163,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of PersistentVolume from a dict + + +# koyeb/api\_async.models.list\_service\_pools\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## ListServicePoolsReply Objects + +```python +class ListServicePoolsReply(BaseModel) +``` + +ListServicePoolsReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of ListServicePoolsReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of ListServicePoolsReply from a dict + # koyeb/api\_async.models.service\_state @@ -35746,6 +37491,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of LogEntry from a dict + + +# koyeb/api\_async.models.mesh + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## Mesh Objects + +```python +class Mesh(BaseModel) +``` + +Mesh groups the mesh scope selector and the (optional) custom mesh name. Kept inside NetworkPolicy so scope/name and other network-policy dimensions (egress, future inbound) live together. + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of Mesh from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of Mesh from a dict + # koyeb/api\_async.models.database\_deployment\_metadata @@ -35910,6 +37737,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of GitLabRegistryConfiguration from a dict + + +# koyeb/api\_async.models.list\_pool\_claim\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## ListPoolClaimReply Objects + +```python +class ListPoolClaimReply(BaseModel) +``` + +ListPoolClaimReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of ListPoolClaimReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of ListPoolClaimReply from a dict + # koyeb/api\_async.models.delete\_organization\_reply @@ -38280,6 +40189,88 @@ def from_json(cls, json_str: str) -> Self Create an instance of MetricName from a JSON string + + +# koyeb/api\_async.models.quota\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## QuotaUsage Objects + +```python +class QuotaUsage(BaseModel) +``` + +QuotaUsage carries an organization's current resource consumption alongside the corresponding plan limits (from the caller's InternalToken.Quotas). Paused services are included in services_used but excluded from memory / instances_by_type / proxy_ports totals, matching enforcement semantics. + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of QuotaUsage from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of QuotaUsage from a dict + # koyeb/api\_async.models.regional\_deployment @@ -38724,6 +40715,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of CreatePaymentAuthorizationReply from a dict + + +# koyeb/api\_async.models.update\_service\_pool\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## UpdateServicePoolReply Objects + +```python +class UpdateServicePoolReply(BaseModel) +``` + +UpdateServicePoolReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of UpdateServicePoolReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of UpdateServicePoolReply from a dict + # koyeb/api\_async.models.get\_idenfy\_token\_reply @@ -42570,6 +44643,40 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of DeploymentPort from a dict + + +# koyeb/api\_async.models.mesh\_scope + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## MeshScope Objects + +```python +class MeshScope(str, Enum) +``` + +MeshScope selects which set of services can communicate over the mesh. Only meaningful when the mesh is on (i.e. DeploymentMesh is ENABLED, or AUTO and the service is eligible). UNSPECIFIED defers to the organization-level default (workspace-scoped since KOYEB-6062, legacy organizations opted back to organization scope via use_organization_level_mesh). - MESH_SCOPE_ORGANIZATION: Private communication between services in the same organization (mesh label k-). - MESH_SCOPE_WORKSPACE: Private communication between services in the same workspace/project (mesh label pr_). - MESH_SCOPE_APP: Private communication between services in the same app (mesh label app_). - MESH_SCOPE_CUSTOM: Private communication between services in the same workspace that share the same NetworkPolicy.mesh.name. Server-computed label is scoped by workspace, so the same custom name in different workspaces never collides. + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Self +``` + +Create an instance of MeshScope from a JSON string + # koyeb/api\_async.models.stream\_result\_of\_log\_entry @@ -43035,7 +45142,7 @@ Do not edit the class manually. class GoogleProtobufAny(BaseModel) ``` -GoogleProtobufAny +`Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := anypb.New(foo) if err != nil { ... } ... foo := &pb.Foo{} if err := any.UnmarshalTo(foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } @@ -44019,6 +46126,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of TriggerGitDeploymentMetadata from a dict + + +# koyeb/api\_async.models.pool\_claim\_request + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## PoolClaimRequest Objects + +```python +class PoolClaimRequest(BaseModel) +``` + +PoolClaimRequest + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of PoolClaimRequest from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of PoolClaimRequest from a dict + # koyeb/api\_async.models.update\_project\_reply @@ -44265,6 +46454,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of GetRegionReply from a dict + + +# koyeb/api\_async.models.create\_service\_pool\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## CreateServicePoolReply Objects + +```python +class CreateServicePoolReply(BaseModel) +``` + +CreateServicePoolReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of CreateServicePoolReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of CreateServicePoolReply from a dict + # koyeb/api\_async.models.autocomplete\_request @@ -46315,6 +48586,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of UpdateAppReply from a dict + + +# koyeb/api\_async.models.persistent\_volume\_region\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## PersistentVolumeRegionUsage Objects + +```python +class PersistentVolumeRegionUsage(BaseModel) +``` + +PersistentVolumeRegionUsage + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of PersistentVolumeRegionUsage from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of PersistentVolumeRegionUsage from a dict + # koyeb/api\_async.models.update\_organization\_reply @@ -47271,6 +49624,88 @@ def from_json(cls, json_str: str) -> Self Create an instance of DomainStatus from a JSON string + + +# koyeb/api\_async.models.service\_pool + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## ServicePool Objects + +```python +class ServicePool(BaseModel) +``` + +ServicePool + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of ServicePool from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of ServicePool from a dict + # koyeb/api\_async.models.next\_invoice\_reply\_line\_period @@ -47435,6 +49870,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of VerifyDockerImageReply from a dict + + +# koyeb/api\_async.models.instance\_type\_usage + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## InstanceTypeUsage Objects + +```python +class InstanceTypeUsage(BaseModel) +``` + +InstanceTypeUsage + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of InstanceTypeUsage from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of InstanceTypeUsage from a dict + # koyeb/api\_async.models.create\_instance\_snapshot\_reply @@ -47599,6 +50116,40 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of RevealSecretReply from a dict + + +# koyeb/api\_async.models.service\_pool\_status + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## ServicePoolStatus Objects + +```python +class ServicePoolStatus(str, Enum) +``` + +ServicePoolStatus + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Self +``` + +Create an instance of ServicePoolStatus from a JSON string + # koyeb/api\_async.models.compose\_reply @@ -48727,7 +51278,7 @@ ExecCommandIO #### data\_validate\_regular\_expression ```python -@field_validator('data') +@field_validator("data", mode="before") def data_validate_regular_expression(cls, value) ``` @@ -50582,6 +53133,88 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] Create an instance of KsearchGlobalDeployment from a dict + + +# koyeb/api\_async.models.get\_organization\_quotas\_usage\_reply + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## GetOrganizationQuotasUsageReply Objects + +```python +class GetOrganizationQuotasUsageReply(BaseModel) +``` + +GetOrganizationQuotasUsageReply + + + +#### to\_str + +```python +def to_str() -> str +``` + +Returns the string representation of the model using alias + + + +#### to\_json + +```python +def to_json() -> str +``` + +Returns the JSON representation of the model using alias + + + +#### from\_json + +```python +@classmethod +def from_json(cls, json_str: str) -> Optional[Self] +``` + +Create an instance of GetOrganizationQuotasUsageReply from a JSON string + + + +#### to\_dict + +```python +def to_dict() -> Dict[str, Any] +``` + +Return the dictionary representation of the model using alias. + +This has the following differences from calling pydantic's +`self.model_dump(by_alias=True)`: + +* `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + + + +#### from\_dict + +```python +@classmethod +def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self] +``` + +Create an instance of GetOrganizationQuotasUsageReply from a dict + # koyeb/api\_async.models.organization\_member\_status @@ -51848,12 +54481,12 @@ Do not edit the class manually. @validate_call async def canny_auth( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -51893,12 +54526,12 @@ Returns the result object. @validate_call async def canny_auth_with_http_info( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -51938,12 +54571,12 @@ Returns the result object. @validate_call async def canny_auth_without_preload_content( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -51983,12 +54616,12 @@ Returns the result object. @validate_call async def discourse_auth( body: DiscourseAuthRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52028,12 +54661,12 @@ Returns the result object. @validate_call async def discourse_auth_with_http_info( body: DiscourseAuthRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52073,12 +54706,12 @@ Returns the result object. @validate_call async def discourse_auth_without_preload_content( body: DiscourseAuthRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52143,12 +54776,12 @@ Do not edit the class manually. ```python @validate_call async def list_datacenters( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52186,12 +54819,12 @@ Returns the result object. ```python @validate_call async def list_datacenters_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52229,12 +54862,12 @@ Returns the result object. ```python @validate_call async def list_datacenters_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52300,12 +54933,12 @@ Do not edit the class manually. async def get_subscription( id: Annotated[StrictStr, Field(description="The id of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52346,12 +54979,12 @@ Returns the result object. async def get_subscription_with_http_info( id: Annotated[StrictStr, Field(description="The id of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52392,12 +55025,12 @@ Returns the result object. async def get_subscription_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52464,12 +55097,12 @@ Do not edit the class manually. async def get_region( id: Annotated[StrictStr, Field(description="The name of the region")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52510,12 +55143,12 @@ Returns the result object. async def get_region_with_http_info( id: Annotated[StrictStr, Field(description="The name of the region")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52556,12 +55189,12 @@ Returns the result object. async def get_region_without_preload_content( id: Annotated[StrictStr, Field(description="The name of the region")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52602,19 +55235,21 @@ Returns the result object. async def list_regions( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, id: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for regions")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52657,19 +55292,21 @@ Returns the result object. async def list_regions_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, id: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for regions")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52712,19 +55349,21 @@ Returns the result object. async def list_regions_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, id: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for regions")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52793,12 +55432,12 @@ Do not edit the class manually. async def get_regional_deployment( id: Annotated[StrictStr, Field(description="The id of the regional deployment")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52841,12 +55480,12 @@ Returns the result object. async def get_regional_deployment_with_http_info( id: Annotated[StrictStr, Field(description="The id of the regional deployment")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52889,12 +55528,12 @@ Returns the result object. async def get_regional_deployment_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the regional deployment")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -52937,32 +55576,36 @@ Returns the result object. async def list_regional_deployment_events( regional_deployment_id: Annotated[ Optional[StrictStr], - Field( - description="(Optional) Filter on regional deployment id")] = None, + Field(description="(Optional) Filter on regional deployment id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on regional deployment event types" - )] = None, + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53007,32 +55650,36 @@ Returns the result object. async def list_regional_deployment_events_with_http_info( regional_deployment_id: Annotated[ Optional[StrictStr], - Field( - description="(Optional) Filter on regional deployment id")] = None, + Field(description="(Optional) Filter on regional deployment id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on regional deployment event types" - )] = None, + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53077,32 +55724,36 @@ Returns the result object. async def list_regional_deployment_events_without_preload_content( regional_deployment_id: Annotated[ Optional[StrictStr], - Field( - description="(Optional) Filter on regional deployment id")] = None, + Field(description="(Optional) Filter on regional deployment id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on regional deployment event types" - )] = None, + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53150,17 +55801,23 @@ async def list_regional_deployments( Field(description="(Optional) Filter on deployment id")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on regional deployment ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53177,6 +55834,7 @@ Experimental: use at your own risk - `deployment_id` (`str`): (Optional) Filter on deployment id - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return +- `ids` (`List[str]`): (Optional) Filter on regional deployment ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -53208,17 +55866,23 @@ async def list_regional_deployments_with_http_info( Field(description="(Optional) Filter on deployment id")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on regional deployment ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53235,6 +55899,7 @@ Experimental: use at your own risk - `deployment_id` (`str`): (Optional) Filter on deployment id - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return +- `ids` (`List[str]`): (Optional) Filter on regional deployment ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -53266,17 +55931,23 @@ async def list_regional_deployments_without_preload_content( Field(description="(Optional) Filter on deployment id")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on regional deployment ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53293,6 +55964,7 @@ Experimental: use at your own risk - `deployment_id` (`str`): (Optional) Filter on deployment id - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return +- `ids` (`List[str]`): (Optional) Filter on regional deployment ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -53353,13 +56025,14 @@ async def verify_docker_image( Field( description= "(Optional) the id of the secret to use to authenticate to the registry" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53409,13 +56082,14 @@ async def verify_docker_image_with_http_info( Field( description= "(Optional) the id of the secret to use to authenticate to the registry" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53465,13 +56139,14 @@ async def verify_docker_image_without_preload_content( Field( description= "(Optional) the id of the secret to use to authenticate to the registry" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53541,12 +56216,12 @@ Do not edit the class manually. async def get_account_activities( limit: Optional[StrictStr] = None, offset: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53588,12 +56263,12 @@ Returns the result object. async def get_account_activities_with_http_info( limit: Optional[StrictStr] = None, offset: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53635,12 +56310,12 @@ Returns the result object. async def get_account_activities_without_preload_content( limit: Optional[StrictStr] = None, offset: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53684,13 +56359,14 @@ async def list_activities( offset: Optional[StrictStr] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on object type")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on object type"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53735,13 +56411,14 @@ async def list_activities_with_http_info( offset: Optional[StrictStr] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on object type")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on object type"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53786,13 +56463,14 @@ async def list_activities_without_preload_content( offset: Optional[StrictStr] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on object type")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on object type"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53839,12 +56517,12 @@ async def list_notifications( mark_seen: Optional[StrictStr] = None, unread: Optional[StrictStr] = None, unseen: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53894,12 +56572,12 @@ async def list_notifications_with_http_info( mark_seen: Optional[StrictStr] = None, unread: Optional[StrictStr] = None, unseen: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -53949,12 +56627,12 @@ async def list_notifications_without_preload_content( mark_seen: Optional[StrictStr] = None, unread: Optional[StrictStr] = None, unseen: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54025,12 +56703,12 @@ Do not edit the class manually. @validate_call async def check_coupon( code: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54072,12 +56750,12 @@ Returns the result object. @validate_call async def check_coupon_with_http_info( code: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54119,12 +56797,12 @@ Returns the result object. @validate_call async def check_coupon_without_preload_content( code: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54166,12 +56844,12 @@ Returns the result object. @validate_call async def redeem_coupon( body: RedeemCouponRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54212,12 +56890,12 @@ Returns the result object. @validate_call async def redeem_coupon_with_http_info( body: RedeemCouponRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54259,12 +56937,12 @@ Returns the result object. @validate_call async def redeem_coupon_without_preload_content( body: RedeemCouponRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54332,12 +57010,12 @@ Do not edit the class manually. @validate_call async def create_credential( credential: CreateCredential, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54377,12 +57055,12 @@ Returns the result object. @validate_call async def create_credential_with_http_info( credential: CreateCredential, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54422,12 +57100,12 @@ Returns the result object. @validate_call async def create_credential_without_preload_content( credential: CreateCredential, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54467,12 +57145,12 @@ Returns the result object. @validate_call async def delete_credential( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54511,12 +57189,12 @@ Returns the result object. @validate_call async def delete_credential_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54556,12 +57234,12 @@ Returns the result object. @validate_call async def delete_credential_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54601,12 +57279,12 @@ Returns the result object. @validate_call async def get_credential( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54646,12 +57324,12 @@ Returns the result object. @validate_call async def get_credential_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54691,12 +57369,12 @@ Returns the result object. @validate_call async def get_credential_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54741,23 +57419,26 @@ async def list_credentials( Field(description="(Optional) A filter for name")] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter for an organization")] = None, + Field(description="(Optional) Filter for an organization"), + ] = None, user_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter for an user")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54807,23 +57488,26 @@ async def list_credentials_with_http_info( Field(description="(Optional) A filter for name")] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter for an organization")] = None, + Field(description="(Optional) Filter for an organization"), + ] = None, user_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter for an user")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54873,23 +57557,26 @@ async def list_credentials_without_preload_content( Field(description="(Optional) A filter for name")] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter for an organization")] = None, + Field(description="(Optional) Filter for an organization"), + ] = None, user_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter for an user")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54936,12 +57623,12 @@ async def update_credential( id: StrictStr, credential: Credential, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -54985,12 +57672,12 @@ async def update_credential_with_http_info( id: StrictStr, credential: Credential, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55034,12 +57721,12 @@ async def update_credential_without_preload_content( id: StrictStr, credential: Credential, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55083,12 +57770,12 @@ async def update_credential2( id: StrictStr, credential: Credential, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55132,12 +57819,12 @@ async def update_credential2_with_http_info( id: StrictStr, credential: Credential, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55181,12 +57868,12 @@ async def update_credential2_without_preload_content( id: StrictStr, credential: Credential, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55254,12 +57941,12 @@ Do not edit the class manually. @validate_call async def confirm_organization_action( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55298,12 +57985,12 @@ Returns the result object. @validate_call async def confirm_organization_action_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55343,12 +58030,12 @@ Returns the result object. @validate_call async def confirm_organization_action_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55414,12 +58101,12 @@ Do not edit the class manually. @validate_call async def create_domain( domain: CreateDomain, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55459,12 +58146,12 @@ Returns the result object. @validate_call async def create_domain_with_http_info( domain: CreateDomain, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55504,12 +58191,12 @@ Returns the result object. @validate_call async def create_domain_without_preload_content( domain: CreateDomain, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55549,12 +58236,12 @@ Returns the result object. @validate_call async def delete_domain( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55593,12 +58280,12 @@ Returns the result object. @validate_call async def delete_domain_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55638,12 +58325,12 @@ Returns the result object. @validate_call async def delete_domain_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55683,12 +58370,12 @@ Returns the result object. @validate_call async def get_domain( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55728,12 +58415,12 @@ Returns the result object. @validate_call async def get_domain_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55773,12 +58460,12 @@ Returns the result object. @validate_call async def get_domain_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55819,34 +58506,39 @@ Returns the result object. async def list_domains( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, types: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) A filter for types - AUTOASSIGNED: Domain like -.koyeb.app" - )] = None, + ), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) A filter for statuses")] = None, + Field(description="(Optional) A filter for statuses"), + ] = None, app_ids: Annotated[Optional[List[StrictStr]], Field( description="(Optional) A filter for apps")] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on domain ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55864,7 +58556,7 @@ List Domains - `statuses` (`List[str]`): (Optional) A filter for statuses - `app_ids` (`List[str]`): (Optional) A filter for apps - `name` (`str`): (Optional) A filter for name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on domain ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -55893,34 +58585,39 @@ Returns the result object. async def list_domains_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, types: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) A filter for types - AUTOASSIGNED: Domain like -.koyeb.app" - )] = None, + ), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) A filter for statuses")] = None, + Field(description="(Optional) A filter for statuses"), + ] = None, app_ids: Annotated[Optional[List[StrictStr]], Field( description="(Optional) A filter for apps")] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on domain ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -55938,7 +58635,7 @@ List Domains - `statuses` (`List[str]`): (Optional) A filter for statuses - `app_ids` (`List[str]`): (Optional) A filter for apps - `name` (`str`): (Optional) A filter for name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on domain ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -55967,34 +58664,39 @@ Returns the result object. async def list_domains_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, types: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) A filter for types - AUTOASSIGNED: Domain like -.koyeb.app" - )] = None, + ), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) A filter for statuses")] = None, + Field(description="(Optional) A filter for statuses"), + ] = None, app_ids: Annotated[Optional[List[StrictStr]], Field( description="(Optional) A filter for apps")] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on domain ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56012,7 +58714,7 @@ List Domains - `statuses` (`List[str]`): (Optional) A filter for statuses - `app_ids` (`List[str]`): (Optional) A filter for apps - `name` (`str`): (Optional) A filter for name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on domain ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -56040,12 +58742,12 @@ Returns the result object. @validate_call async def refresh_domain_status( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56084,12 +58786,12 @@ Returns the result object. @validate_call async def refresh_domain_status_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56129,12 +58831,12 @@ Returns the result object. @validate_call async def refresh_domain_status_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56178,15 +58880,16 @@ async def update_domain( update_mask: Optional[StrictStr] = None, dry_run: Annotated[ Optional[StrictBool], - Field(description= - "If set, run validation and check that the domain is available." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description= + "If set, run validation and check that the domain is available."), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56233,15 +58936,16 @@ async def update_domain_with_http_info( update_mask: Optional[StrictStr] = None, dry_run: Annotated[ Optional[StrictBool], - Field(description= - "If set, run validation and check that the domain is available." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description= + "If set, run validation and check that the domain is available."), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56288,15 +58992,16 @@ async def update_domain_without_preload_content( update_mask: Optional[StrictStr] = None, dry_run: Annotated[ Optional[StrictBool], - Field(description= - "If set, run validation and check that the domain is available." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description= + "If set, run validation and check that the domain is available."), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56368,94 +59073,106 @@ async def query_logs( Optional[StrictStr], Field( description= - "Type of logs to retrieve, either \"build\" or \"runtime\". Defaults to \"runtime\"." - )] = None, + 'Type of logs to retrieve, either "build" or "runtime". Defaults to "runtime".' + ), + ] = None, app_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided app_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, service_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided service_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, regional_deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided regional_deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using instance_ids instead." - )] = None, + Field(description="Deprecated, prefer using instance_ids instead."), + ] = None, instance_ids: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter on the provided instance_ids. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, stream: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using streams instead.")] = None, + Field(description="Deprecated, prefer using streams instead."), + ] = None, streams: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on stream: either \"stdout\", \"stderr\" or \"koyeb\" (for system logs)." - )] = None, + '(Optional) Filter on stream: either "stdout", "stderr" or "koyeb" (for system logs).' + ), + ] = None, start: Annotated[ Optional[datetime], Field( description= "(Optional) Must always be before `end`. Defaults to 15 minutes ago." - )] = None, + ), + ] = None, end: Annotated[ Optional[datetime], Field(description= - "(Optional) Must always be after `start`. Defaults to now." - )] = None, + "(Optional) Must always be after `start`. Defaults to now."), + ] = None, order: Annotated[ Optional[StrictStr], - Field(description="(Optional) `asc` or `desc`. Defaults to `desc`." - )] = None, + Field(description="(Optional) `asc` or `desc`. Defaults to `desc`."), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) Defaults to 100. Maximum of 1000." - )] = None, + Field(description="(Optional) Defaults to 100. Maximum of 1000."), + ] = None, regex: Annotated[ Optional[StrictStr], Field( description= "(Optional) Apply a regex to filter logs. Can't be used with `text`." - )] = None, + ), + ] = None, text: Annotated[ Optional[StrictStr], Field( description= "(Optional) Looks for this string in logs. Can't be used with `regex`." - )] = None, + ), + ] = None, regions: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on the provided regions (e.g. [\"fra\", \"was\"])." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + '(Optional) Filter on the provided regions (e.g. ["fra", "was"]).' + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56513,94 +59230,106 @@ async def query_logs_with_http_info( Optional[StrictStr], Field( description= - "Type of logs to retrieve, either \"build\" or \"runtime\". Defaults to \"runtime\"." - )] = None, + 'Type of logs to retrieve, either "build" or "runtime". Defaults to "runtime".' + ), + ] = None, app_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided app_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, service_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided service_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, regional_deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided regional_deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using instance_ids instead." - )] = None, + Field(description="Deprecated, prefer using instance_ids instead."), + ] = None, instance_ids: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter on the provided instance_ids. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, stream: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using streams instead.")] = None, + Field(description="Deprecated, prefer using streams instead."), + ] = None, streams: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on stream: either \"stdout\", \"stderr\" or \"koyeb\" (for system logs)." - )] = None, + '(Optional) Filter on stream: either "stdout", "stderr" or "koyeb" (for system logs).' + ), + ] = None, start: Annotated[ Optional[datetime], Field( description= "(Optional) Must always be before `end`. Defaults to 15 minutes ago." - )] = None, + ), + ] = None, end: Annotated[ Optional[datetime], Field(description= - "(Optional) Must always be after `start`. Defaults to now." - )] = None, + "(Optional) Must always be after `start`. Defaults to now."), + ] = None, order: Annotated[ Optional[StrictStr], - Field(description="(Optional) `asc` or `desc`. Defaults to `desc`." - )] = None, + Field(description="(Optional) `asc` or `desc`. Defaults to `desc`."), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) Defaults to 100. Maximum of 1000." - )] = None, + Field(description="(Optional) Defaults to 100. Maximum of 1000."), + ] = None, regex: Annotated[ Optional[StrictStr], Field( description= "(Optional) Apply a regex to filter logs. Can't be used with `text`." - )] = None, + ), + ] = None, text: Annotated[ Optional[StrictStr], Field( description= "(Optional) Looks for this string in logs. Can't be used with `regex`." - )] = None, + ), + ] = None, regions: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on the provided regions (e.g. [\"fra\", \"was\"])." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + '(Optional) Filter on the provided regions (e.g. ["fra", "was"]).' + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56658,94 +59387,106 @@ async def query_logs_without_preload_content( Optional[StrictStr], Field( description= - "Type of logs to retrieve, either \"build\" or \"runtime\". Defaults to \"runtime\"." - )] = None, + 'Type of logs to retrieve, either "build" or "runtime". Defaults to "runtime".' + ), + ] = None, app_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided app_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, service_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided service_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, regional_deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided regional_deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using instance_ids instead." - )] = None, + Field(description="Deprecated, prefer using instance_ids instead."), + ] = None, instance_ids: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter on the provided instance_ids. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, stream: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using streams instead.")] = None, + Field(description="Deprecated, prefer using streams instead."), + ] = None, streams: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on stream: either \"stdout\", \"stderr\" or \"koyeb\" (for system logs)." - )] = None, + '(Optional) Filter on stream: either "stdout", "stderr" or "koyeb" (for system logs).' + ), + ] = None, start: Annotated[ Optional[datetime], Field( description= "(Optional) Must always be before `end`. Defaults to 15 minutes ago." - )] = None, + ), + ] = None, end: Annotated[ Optional[datetime], Field(description= - "(Optional) Must always be after `start`. Defaults to now." - )] = None, + "(Optional) Must always be after `start`. Defaults to now."), + ] = None, order: Annotated[ Optional[StrictStr], - Field(description="(Optional) `asc` or `desc`. Defaults to `desc`." - )] = None, + Field(description="(Optional) `asc` or `desc`. Defaults to `desc`."), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) Defaults to 100. Maximum of 1000." - )] = None, + Field(description="(Optional) Defaults to 100. Maximum of 1000."), + ] = None, regex: Annotated[ Optional[StrictStr], Field( description= "(Optional) Apply a regex to filter logs. Can't be used with `text`." - )] = None, + ), + ] = None, text: Annotated[ Optional[StrictStr], Field( description= "(Optional) Looks for this string in logs. Can't be used with `regex`." - )] = None, + ), + ] = None, regions: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on the provided regions (e.g. [\"fra\", \"was\"])." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + '(Optional) Filter on the provided regions (e.g. ["fra", "was"]).' + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56803,82 +59544,94 @@ async def tail_logs( Optional[StrictStr], Field( description= - "Type of logs to retrieve, either \"build\" or \"runtime\". Defaults to \"runtime\"." - )] = None, + 'Type of logs to retrieve, either "build" or "runtime". Defaults to "runtime".' + ), + ] = None, app_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided app_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, service_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided service_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, regional_deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided regional_deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using instance_ids instead." - )] = None, + Field(description="Deprecated, prefer using instance_ids instead."), + ] = None, instance_ids: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter on the provided instance_ids. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, stream: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using streams instead.")] = None, + Field(description="Deprecated, prefer using streams instead."), + ] = None, streams: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on stream: either \"stdout\", \"stderr\" or \"koyeb\" (for system logs)." - )] = None, + '(Optional) Filter on stream: either "stdout", "stderr" or "koyeb" (for system logs).' + ), + ] = None, start: Annotated[ Optional[datetime], - Field(description="(Optional) Defaults to 24 hours ago.")] = None, + Field(description="(Optional) Defaults to 24 hours ago."), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) Defaults to 1000. Maximum of 1000." - )] = None, + Field(description="(Optional) Defaults to 1000. Maximum of 1000."), + ] = None, regex: Annotated[ Optional[StrictStr], Field( description= "(Optional) Apply a regex to filter logs. Can't be used with `text`." - )] = None, + ), + ] = None, text: Annotated[ Optional[StrictStr], Field( description= "(Optional) Looks for this string in logs. Can't be used with `regex`." - )] = None, + ), + ] = None, regions: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on the provided regions (e.g. [\"fra\", \"was\"])." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + '(Optional) Filter on the provided regions (e.g. ["fra", "was"]).' + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -56934,82 +59687,94 @@ async def tail_logs_with_http_info( Optional[StrictStr], Field( description= - "Type of logs to retrieve, either \"build\" or \"runtime\". Defaults to \"runtime\"." - )] = None, + 'Type of logs to retrieve, either "build" or "runtime". Defaults to "runtime".' + ), + ] = None, app_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided app_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, service_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided service_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, regional_deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided regional_deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using instance_ids instead." - )] = None, + Field(description="Deprecated, prefer using instance_ids instead."), + ] = None, instance_ids: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter on the provided instance_ids. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, stream: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using streams instead.")] = None, + Field(description="Deprecated, prefer using streams instead."), + ] = None, streams: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on stream: either \"stdout\", \"stderr\" or \"koyeb\" (for system logs)." - )] = None, + '(Optional) Filter on stream: either "stdout", "stderr" or "koyeb" (for system logs).' + ), + ] = None, start: Annotated[ Optional[datetime], - Field(description="(Optional) Defaults to 24 hours ago.")] = None, + Field(description="(Optional) Defaults to 24 hours ago."), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) Defaults to 1000. Maximum of 1000." - )] = None, + Field(description="(Optional) Defaults to 1000. Maximum of 1000."), + ] = None, regex: Annotated[ Optional[StrictStr], Field( description= "(Optional) Apply a regex to filter logs. Can't be used with `text`." - )] = None, + ), + ] = None, text: Annotated[ Optional[StrictStr], Field( description= "(Optional) Looks for this string in logs. Can't be used with `regex`." - )] = None, + ), + ] = None, regions: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on the provided regions (e.g. [\"fra\", \"was\"])." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + '(Optional) Filter on the provided regions (e.g. ["fra", "was"]).' + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57065,82 +59830,94 @@ async def tail_logs_without_preload_content( Optional[StrictStr], Field( description= - "Type of logs to retrieve, either \"build\" or \"runtime\". Defaults to \"runtime\"." - )] = None, + 'Type of logs to retrieve, either "build" or "runtime". Defaults to "runtime".' + ), + ] = None, app_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided app_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, service_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided service_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, regional_deployment_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on the provided regional_deployment_id. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using instance_ids instead." - )] = None, + Field(description="Deprecated, prefer using instance_ids instead."), + ] = None, instance_ids: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter on the provided instance_ids. At least one of app_id, service_id, deployment_id, regional_deployment_id or instance_ids must be set." - )] = None, + ), + ] = None, stream: Annotated[ Optional[StrictStr], - Field(description="Deprecated, prefer using streams instead.")] = None, + Field(description="Deprecated, prefer using streams instead."), + ] = None, streams: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on stream: either \"stdout\", \"stderr\" or \"koyeb\" (for system logs)." - )] = None, + '(Optional) Filter on stream: either "stdout", "stderr" or "koyeb" (for system logs).' + ), + ] = None, start: Annotated[ Optional[datetime], - Field(description="(Optional) Defaults to 24 hours ago.")] = None, + Field(description="(Optional) Defaults to 24 hours ago."), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) Defaults to 1000. Maximum of 1000." - )] = None, + Field(description="(Optional) Defaults to 1000. Maximum of 1000."), + ] = None, regex: Annotated[ Optional[StrictStr], Field( description= "(Optional) Apply a regex to filter logs. Can't be used with `text`." - )] = None, + ), + ] = None, text: Annotated[ Optional[StrictStr], Field( description= "(Optional) Looks for this string in logs. Can't be used with `regex`." - )] = None, + ), + ] = None, regions: Annotated[ Optional[List[StrictStr]], Field( description= - "(Optional) Filter on the provided regions (e.g. [\"fra\", \"was\"])." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + '(Optional) Filter on the provided regions (e.g. ["fra", "was"]).' + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57219,12 +59996,12 @@ Do not edit the class manually. @validate_call async def autocomplete( body: AutocompleteRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57266,12 +60043,12 @@ Returns the result object. @validate_call async def autocomplete_with_http_info( body: AutocompleteRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57313,12 +60090,12 @@ Returns the result object. @validate_call async def autocomplete_without_preload_content( body: AutocompleteRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57362,12 +60139,12 @@ async def create_service( service: CreateService, dry_run: Annotated[Optional[StrictBool], Field(description="If set only run validation")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57410,12 +60187,12 @@ async def create_service_with_http_info( service: CreateService, dry_run: Annotated[Optional[StrictBool], Field(description="If set only run validation")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57458,12 +60235,12 @@ async def create_service_without_preload_content( service: CreateService, dry_run: Annotated[Optional[StrictBool], Field(description="If set only run validation")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57505,12 +60282,12 @@ Returns the result object. async def delete_service( id: Annotated[StrictStr, Field(description="The id of the entity to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57552,12 +60329,12 @@ Returns the result object. async def delete_service_with_http_info( id: Annotated[StrictStr, Field(description="The id of the entity to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57600,12 +60377,12 @@ Returns the result object. async def delete_service_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the entity to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57648,12 +60425,12 @@ Returns the result object. async def delete_service_scaling( id: Annotated[StrictStr, Field(description="The id of the service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57695,12 +60472,12 @@ Returns the result object. async def delete_service_scaling_with_http_info( id: Annotated[StrictStr, Field(description="The id of the service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57743,12 +60520,12 @@ Returns the result object. async def delete_service_scaling_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57791,12 +60568,12 @@ Returns the result object. async def get_service( id: Annotated[StrictStr, Field(description="The id of the Service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57837,12 +60614,12 @@ Returns the result object. async def get_service_with_http_info( id: Annotated[StrictStr, Field(description="The id of the Service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57883,12 +60660,12 @@ Returns the result object. async def get_service_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the Service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57929,12 +60706,12 @@ Returns the result object. async def get_service_scaling( id: Annotated[StrictStr, Field(description="The id of the service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -57977,12 +60754,12 @@ Returns the result object. async def get_service_scaling_with_http_info( id: Annotated[StrictStr, Field(description="The id of the service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58025,12 +60802,12 @@ Returns the result object. async def get_service_scaling_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the service")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58076,26 +60853,30 @@ async def list_service_events( Field(description="(Optional) Filter on service id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service event types")] = None, + Field(description="(Optional) Filter on service event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58143,26 +60924,30 @@ async def list_service_events_with_http_info( Field(description="(Optional) Filter on service id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service event types")] = None, + Field(description="(Optional) Filter on service event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58210,26 +60995,30 @@ async def list_service_events_without_preload_content( Field(description="(Optional) Filter on service id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service event types")] = None, + Field(description="(Optional) Filter on service event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58277,31 +61066,36 @@ async def list_services( description="(Optional) The id of the app")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service types")] = None, + Field(description="(Optional) Filter on service types"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service statuses")] = None, + Field(description="(Optional) Filter on service statuses"), + ] = None, regions: Annotated[Optional[List[StrictStr]], Field( description="(Optional) Filter on regions")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on service ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58320,7 +61114,7 @@ List Services - `types` (`List[str]`): (Optional) Filter on service types - `statuses` (`List[str]`): (Optional) Filter on service statuses - `regions` (`List[str]`): (Optional) Filter on regions -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on service ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -58352,31 +61146,36 @@ async def list_services_with_http_info( description="(Optional) The id of the app")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service types")] = None, + Field(description="(Optional) Filter on service types"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service statuses")] = None, + Field(description="(Optional) Filter on service statuses"), + ] = None, regions: Annotated[Optional[List[StrictStr]], Field( description="(Optional) Filter on regions")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on service ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58395,7 +61194,7 @@ List Services - `types` (`List[str]`): (Optional) Filter on service types - `statuses` (`List[str]`): (Optional) Filter on service statuses - `regions` (`List[str]`): (Optional) Filter on regions -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on service ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -58427,31 +61226,36 @@ async def list_services_without_preload_content( description="(Optional) The id of the app")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service types")] = None, + Field(description="(Optional) Filter on service types"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on service statuses")] = None, + Field(description="(Optional) Filter on service statuses"), + ] = None, regions: Annotated[Optional[List[StrictStr]], Field( description="(Optional) Filter on regions")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on service ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58470,7 +61274,7 @@ List Services - `types` (`List[str]`): (Optional) Filter on service types - `statuses` (`List[str]`): (Optional) Filter on service statuses - `regions` (`List[str]`): (Optional) Filter on regions -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on service ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -58499,12 +61303,12 @@ Returns the result object. async def pause_service( id: Annotated[StrictStr, Field(description="The id of the service to pause.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58546,12 +61350,12 @@ Returns the result object. async def pause_service_with_http_info( id: Annotated[StrictStr, Field(description="The id of the service to pause.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58594,12 +61398,12 @@ Returns the result object. async def pause_service_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the service to pause.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58642,12 +61446,12 @@ Returns the result object. async def re_deploy( id: StrictStr, info: RedeployRequestInfo, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58689,12 +61493,12 @@ Returns the result object. async def re_deploy_with_http_info( id: StrictStr, info: RedeployRequestInfo, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58736,12 +61540,12 @@ Returns the result object. async def re_deploy_without_preload_content( id: StrictStr, info: RedeployRequestInfo, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58789,14 +61593,15 @@ async def resume_service( Field( description= "If set to true, the build stage will be skipped and the image coming from the last successful build step will be used instead. The call fails if no previous successful builds happened." - )] = None, + ), + ] = None, use_cache: Optional[StrictBool] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58845,14 +61650,15 @@ async def resume_service_with_http_info( Field( description= "If set to true, the build stage will be skipped and the image coming from the last successful build step will be used instead. The call fails if no previous successful builds happened." - )] = None, + ), + ] = None, use_cache: Optional[StrictBool] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58902,14 +61708,15 @@ async def resume_service_without_preload_content( Field( description= "If set to true, the build stage will be skipped and the image coming from the last successful build step will be used instead. The call fails if no previous successful builds happened." - )] = None, + ), + ] = None, use_cache: Optional[StrictBool] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -58959,14 +61766,14 @@ async def update_service( dry_run: Annotated[ Optional[StrictBool], Field(description= - "If set, run validation and check that the service exists" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If set, run validation and check that the service exists"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59015,14 +61822,14 @@ async def update_service_with_http_info( dry_run: Annotated[ Optional[StrictBool], Field(description= - "If set, run validation and check that the service exists" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If set, run validation and check that the service exists"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59071,14 +61878,14 @@ async def update_service_without_preload_content( dry_run: Annotated[ Optional[StrictBool], Field(description= - "If set, run validation and check that the service exists" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If set, run validation and check that the service exists"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59127,14 +61934,14 @@ async def update_service2( dry_run: Annotated[ Optional[StrictBool], Field(description= - "If set, run validation and check that the service exists" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If set, run validation and check that the service exists"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59183,14 +61990,14 @@ async def update_service2_with_http_info( dry_run: Annotated[ Optional[StrictBool], Field(description= - "If set, run validation and check that the service exists" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If set, run validation and check that the service exists"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59239,14 +62046,14 @@ async def update_service2_without_preload_content( dry_run: Annotated[ Optional[StrictBool], Field(description= - "If set, run validation and check that the service exists" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If set, run validation and check that the service exists"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59291,12 +62098,12 @@ async def update_service_scaling( id: Annotated[StrictStr, Field(description="The id of the service to scale")], body: UpdateServiceScalingRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59340,12 +62147,12 @@ async def update_service_scaling_with_http_info( id: Annotated[StrictStr, Field(description="The id of the service to scale")], body: UpdateServiceScalingRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59390,12 +62197,12 @@ async def update_service_scaling_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the service to scale")], body: UpdateServiceScalingRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59465,12 +62272,12 @@ Do not edit the class manually. async def get_organization_summary( organization_id: Annotated[StrictStr, Field(description="Organization ID")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59511,12 +62318,12 @@ Returns the result object. async def get_organization_summary_with_http_info( organization_id: Annotated[StrictStr, Field(description="Organization ID")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59557,12 +62364,12 @@ Returns the result object. async def get_organization_summary_without_preload_content( organization_id: Annotated[StrictStr, Field(description="Organization ID")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59628,12 +62435,12 @@ Do not edit the class manually. @validate_call async def create_persistent_volume( body: CreatePersistentVolumeRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59673,12 +62480,12 @@ Returns the result object. @validate_call async def create_persistent_volume_with_http_info( body: CreatePersistentVolumeRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59718,12 +62525,12 @@ Returns the result object. @validate_call async def create_persistent_volume_without_preload_content( body: CreatePersistentVolumeRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59763,12 +62570,12 @@ Returns the result object. @validate_call async def delete_persistent_volume( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59808,12 +62615,12 @@ Returns the result object. @validate_call async def delete_persistent_volume_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59853,12 +62660,12 @@ Returns the result object. @validate_call async def delete_persistent_volume_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59898,12 +62705,12 @@ Returns the result object. @validate_call async def get_persistent_volume( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59943,12 +62750,12 @@ Returns the result object. @validate_call async def get_persistent_volume_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -59988,12 +62795,12 @@ Returns the result object. @validate_call async def get_persistent_volume_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60034,30 +62841,35 @@ Returns the result object. async def list_persistent_volume_events( persistent_volume_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on persistent volume id")] = None, + Field(description="(Optional) Filter on persistent volume id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on persistent volume event types" - )] = None, + Field( + description="(Optional) Filter on persistent volume event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60102,30 +62914,35 @@ Returns the result object. async def list_persistent_volume_events_with_http_info( persistent_volume_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on persistent volume id")] = None, + Field(description="(Optional) Filter on persistent volume id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on persistent volume event types" - )] = None, + Field( + description="(Optional) Filter on persistent volume event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60170,30 +62987,35 @@ Returns the result object. async def list_persistent_volume_events_without_preload_content( persistent_volume_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on persistent volume id")] = None, + Field(description="(Optional) Filter on persistent volume id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on persistent volume event types" - )] = None, + Field( + description="(Optional) Filter on persistent volume event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60238,29 +63060,33 @@ Returns the result object. async def list_persistent_volumes( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, service_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) A filter for the service id")] = None, + Field(description="(Optional) A filter for the service id"), + ] = None, region: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the region")] = None, name: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on volume ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60277,7 +63103,7 @@ List all PersistentVolumes - `service_id` (`str`): (Optional) A filter for the service id - `region` (`str`): (Optional) A filter for the region - `name` (`str`): (Optional) A filter for the name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on volume ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60306,29 +63132,33 @@ Returns the result object. async def list_persistent_volumes_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, service_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) A filter for the service id")] = None, + Field(description="(Optional) A filter for the service id"), + ] = None, region: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the region")] = None, name: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on volume ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60345,7 +63175,7 @@ List all PersistentVolumes - `service_id` (`str`): (Optional) A filter for the service id - `region` (`str`): (Optional) A filter for the region - `name` (`str`): (Optional) A filter for the name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on volume ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60374,29 +63204,33 @@ Returns the result object. async def list_persistent_volumes_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, service_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) A filter for the service id")] = None, + Field(description="(Optional) A filter for the service id"), + ] = None, region: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the region")] = None, name: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on volume ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60413,7 +63247,7 @@ List all PersistentVolumes - `service_id` (`str`): (Optional) A filter for the service id - `region` (`str`): (Optional) A filter for the region - `name` (`str`): (Optional) A filter for the name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on volume ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60442,12 +63276,12 @@ Returns the result object. async def update_persistent_volume( id: StrictStr, body: UpdatePersistentVolumeRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60489,12 +63323,12 @@ Returns the result object. async def update_persistent_volume_with_http_info( id: StrictStr, body: UpdatePersistentVolumeRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60536,12 +63370,12 @@ Returns the result object. async def update_persistent_volume_without_preload_content( id: StrictStr, body: UpdatePersistentVolumeRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60574,9 +63408,9 @@ in the spec for a single request. Returns the result object. - + -# koyeb/api\_async.api.users\_api +# koyeb/api\_async.api.pool\_claims\_api Koyeb Rest API @@ -60587,12 +63421,12 @@ Generated by OpenAPI Generator (https://openapi-generator.tech) Do not edit the class manually. - + -## UsersApi Objects +## PoolClaimsApi Objects ```python -class UsersApi() +class PoolClaimsApi() ``` NOTE: This class is auto generated by OpenAPI Generator @@ -60600,33 +63434,32 @@ Ref: https://openapi-generator.tech Do not edit the class manually. - + -#### delete\_user +#### claim ```python @validate_call -async def delete_user( - id: Annotated[StrictStr, - Field(description="The id of the user")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, +async def claim( + body: PoolClaimRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, - Field(ge=0, le=0)] = 0) -> DeleteUserReply + Field(ge=0, le=0)] = 0) -> PoolClaimReply ``` -Delete user +Claim a sandbox from a service pool **Arguments**: -- `id` (`str`): The id of the user (required) +- `body` (`PoolClaimRequest`): (required) - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60646,33 +63479,32 @@ in the spec for a single request. Returns the result object. - + -#### delete\_user\_with\_http\_info +#### claim\_with\_http\_info ```python @validate_call -async def delete_user_with_http_info( - id: Annotated[StrictStr, - Field(description="The id of the user")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, +async def claim_with_http_info( + body: PoolClaimRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 -) -> ApiResponse[DeleteUserReply] +) -> ApiResponse[PoolClaimReply] ``` -Delete user +Claim a sandbox from a service pool **Arguments**: -- `id` (`str`): The id of the user (required) +- `body` (`PoolClaimRequest`): (required) - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60692,21 +63524,20 @@ in the spec for a single request. Returns the result object. - + -#### delete\_user\_without\_preload\_content +#### claim\_without\_preload\_content ```python @validate_call -async def delete_user_without_preload_content( - id: Annotated[StrictStr, - Field(description="The id of the user")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, +async def claim_without_preload_content( + body: PoolClaimRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60714,11 +63545,11 @@ async def delete_user_without_preload_content( Field(ge=0, le=0)] = 0) -> RESTResponseType ``` -Delete user +Claim a sandbox from a service pool **Arguments**: -- `id` (`str`): The id of the user (required) +- `body` (`PoolClaimRequest`): (required) - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60738,33 +63569,32 @@ in the spec for a single request. Returns the result object. - + -#### delete\_user\_v2 +#### get\_claim ```python @validate_call -async def delete_user_v2( - id: Annotated[StrictStr, - Field(description="The id of the user")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, +async def get_claim( + claim_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, - Field(ge=0, le=0)] = 0) -> DeleteUserReply + Field(ge=0, le=0)] = 0) -> GetPoolClaimReply ``` -V2 Delete user +Get a claim **Arguments**: -- `id` (`str`): The id of the user (required) +- `claim_id` (`str`): (required) - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60784,33 +63614,32 @@ in the spec for a single request. Returns the result object. - + -#### delete\_user\_v2\_with\_http\_info +#### get\_claim\_with\_http\_info ```python @validate_call -async def delete_user_v2_with_http_info( - id: Annotated[StrictStr, - Field(description="The id of the user")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, +async def get_claim_with_http_info( + claim_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 -) -> ApiResponse[DeleteUserReply] +) -> ApiResponse[GetPoolClaimReply] ``` -V2 Delete user +Get a claim **Arguments**: -- `id` (`str`): The id of the user (required) +- `claim_id` (`str`): (required) - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -60830,29 +63659,483 @@ in the spec for a single request. Returns the result object. - + -#### delete\_user\_v2\_without\_preload\_content +#### get\_claim\_without\_preload\_content ```python @validate_call -async def delete_user_v2_without_preload_content( +async def get_claim_without_preload_content( + claim_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +Get a claim + +**Arguments**: + +- `claim_id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### list\_claim + +```python +@validate_call +async def list_claim( + pool_id: StrictStr, + status: Optional[StrictStr] = None, + limit: Optional[StrictStr] = None, + offset: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ListPoolClaimReply +``` + +List claims of a service pool + +**Arguments**: + +- `pool_id` (`str`): (required) +- `status` (`str`): +- `limit` (`str`): +- `offset` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### list\_claim\_with\_http\_info + +```python +@validate_call +async def list_claim_with_http_info( + pool_id: StrictStr, + status: Optional[StrictStr] = None, + limit: Optional[StrictStr] = None, + offset: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[ListPoolClaimReply] +``` + +List claims of a service pool + +**Arguments**: + +- `pool_id` (`str`): (required) +- `status` (`str`): +- `limit` (`str`): +- `offset` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### list\_claim\_without\_preload\_content + +```python +@validate_call +async def list_claim_without_preload_content( + pool_id: StrictStr, + status: Optional[StrictStr] = None, + limit: Optional[StrictStr] = None, + offset: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +List claims of a service pool + +**Arguments**: + +- `pool_id` (`str`): (required) +- `status` (`str`): +- `limit` (`str`): +- `offset` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +# koyeb/api\_async.api.users\_api + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## UsersApi Objects + +```python +class UsersApi() +``` + +NOTE: This class is auto generated by OpenAPI Generator +Ref: https://openapi-generator.tech + +Do not edit the class manually. + + + +#### delete\_user + +```python +@validate_call +async def delete_user( id: Annotated[StrictStr, Field(description="The id of the user")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, - Field(ge=0, le=0)] = 0) -> RESTResponseType + Field(ge=0, le=0)] = 0) -> DeleteUserReply ``` -V2 Delete user +Delete user + +**Arguments**: + +- `id` (`str`): The id of the user (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_user\_with\_http\_info + +```python +@validate_call +async def delete_user_with_http_info( + id: Annotated[StrictStr, + Field(description="The id of the user")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[DeleteUserReply] +``` + +Delete user + +**Arguments**: + +- `id` (`str`): The id of the user (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_user\_without\_preload\_content + +```python +@validate_call +async def delete_user_without_preload_content( + id: Annotated[StrictStr, + Field(description="The id of the user")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +Delete user + +**Arguments**: + +- `id` (`str`): The id of the user (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_user\_v2 + +```python +@validate_call +async def delete_user_v2( + id: Annotated[StrictStr, + Field(description="The id of the user")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> DeleteUserReply +``` + +V2 Delete user + +**Arguments**: + +- `id` (`str`): The id of the user (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_user\_v2\_with\_http\_info + +```python +@validate_call +async def delete_user_v2_with_http_info( + id: Annotated[StrictStr, + Field(description="The id of the user")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[DeleteUserReply] +``` + +V2 Delete user + +**Arguments**: + +- `id` (`str`): The id of the user (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_user\_v2\_without\_preload\_content + +```python +@validate_call +async def delete_user_v2_without_preload_content( + id: Annotated[StrictStr, + Field(description="The id of the user")], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +V2 Delete user **Arguments**: @@ -60910,12 +64193,12 @@ Do not edit the class manually. @validate_call async def create_archive( archive: CreateArchive, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -60957,12 +64240,12 @@ Returns the result object. @validate_call async def create_archive_with_http_info( archive: CreateArchive, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61004,12 +64287,12 @@ Returns the result object. @validate_call async def create_archive_without_preload_content( archive: CreateArchive, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61081,16 +64364,18 @@ async def get_metrics( Field( description= "ID of the service to query instances metrics for. Ignored if instance_id is set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="ID of the instance to query metrics for.")] = None, + Field(description="ID of the instance to query metrics for."), + ] = None, name: Annotated[Optional[StrictStr], Field(description="Metric to query.")] = None, start: Annotated[ Optional[datetime], - Field(description="(Optional) Defaults to an hour prior to end." - )] = None, + Field(description="(Optional) Defaults to an hour prior to end."), + ] = None, end: Annotated[Optional[datetime], Field(description="(Optional) Defaults to now.")] = None, step: Annotated[ @@ -61098,13 +64383,14 @@ async def get_metrics( Field( description= "(Optional) Must be a valid duration in hours (h) or minutes (m). Defaulst to 5m." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61153,16 +64439,18 @@ async def get_metrics_with_http_info( Field( description= "ID of the service to query instances metrics for. Ignored if instance_id is set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="ID of the instance to query metrics for.")] = None, + Field(description="ID of the instance to query metrics for."), + ] = None, name: Annotated[Optional[StrictStr], Field(description="Metric to query.")] = None, start: Annotated[ Optional[datetime], - Field(description="(Optional) Defaults to an hour prior to end." - )] = None, + Field(description="(Optional) Defaults to an hour prior to end."), + ] = None, end: Annotated[Optional[datetime], Field(description="(Optional) Defaults to now.")] = None, step: Annotated[ @@ -61170,13 +64458,14 @@ async def get_metrics_with_http_info( Field( description= "(Optional) Must be a valid duration in hours (h) or minutes (m). Defaulst to 5m." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61225,16 +64514,18 @@ async def get_metrics_without_preload_content( Field( description= "ID of the service to query instances metrics for. Ignored if instance_id is set." - )] = None, + ), + ] = None, instance_id: Annotated[ Optional[StrictStr], - Field(description="ID of the instance to query metrics for.")] = None, + Field(description="ID of the instance to query metrics for."), + ] = None, name: Annotated[Optional[StrictStr], Field(description="Metric to query.")] = None, start: Annotated[ Optional[datetime], - Field(description="(Optional) Defaults to an hour prior to end." - )] = None, + Field(description="(Optional) Defaults to an hour prior to end."), + ] = None, end: Annotated[Optional[datetime], Field(description="(Optional) Defaults to now.")] = None, step: Annotated[ @@ -61242,13 +64533,14 @@ async def get_metrics_without_preload_content( Field( description= "(Optional) Must be a valid duration in hours (h) or minutes (m). Defaulst to 5m." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61320,12 +64612,12 @@ Do not edit the class manually. async def confirm_payment_authorization( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61367,12 +64659,12 @@ Returns the result object. async def confirm_payment_authorization_with_http_info( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61414,12 +64706,12 @@ Returns the result object. async def confirm_payment_authorization_without_preload_content( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61460,12 +64752,12 @@ Returns the result object. @validate_call async def create_payment_authorization( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61505,12 +64797,12 @@ Returns the result object. @validate_call async def create_payment_authorization_with_http_info( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61550,12 +64842,12 @@ Returns the result object. @validate_call async def create_payment_authorization_without_preload_content( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61595,12 +64887,12 @@ Returns the result object. @validate_call async def delete_payment_method( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61639,12 +64931,12 @@ Returns the result object. @validate_call async def delete_payment_method_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61684,12 +64976,12 @@ Returns the result object. @validate_call async def delete_payment_method_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61729,12 +65021,12 @@ Returns the result object. @validate_call async def get_payment_method( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61774,12 +65066,12 @@ Returns the result object. @validate_call async def get_payment_method_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61819,12 +65111,12 @@ Returns the result object. @validate_call async def get_payment_method_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61865,21 +65157,23 @@ Returns the result object. async def list_payment_methods( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on payment method statuses" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on payment method statuses"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61922,21 +65216,23 @@ Returns the result object. async def list_payment_methods_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on payment method statuses" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on payment method statuses"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -61979,21 +65275,23 @@ Returns the result object. async def list_payment_methods_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on payment method statuses" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on payment method statuses"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62064,12 +65362,12 @@ async def create_stage_attempt( stage: StrictStr, attempt: StrictStr, body: CreateStageAttemptRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62114,12 +65412,12 @@ async def create_stage_attempt_with_http_info( stage: StrictStr, attempt: StrictStr, body: CreateStageAttemptRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62165,12 +65463,12 @@ async def create_stage_attempt_without_preload_content( stage: StrictStr, attempt: StrictStr, body: CreateStageAttemptRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62216,12 +65514,12 @@ async def declare_stage_progress( stage: StrictStr, attempt: StrictStr, body: DeclareStageProgressRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62266,12 +65564,12 @@ async def declare_stage_progress_with_http_info( stage: StrictStr, attempt: StrictStr, body: DeclareStageProgressRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62317,12 +65615,12 @@ async def declare_stage_progress_without_preload_content( stage: StrictStr, attempt: StrictStr, body: DeclareStageProgressRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62369,12 +65667,12 @@ async def declare_step_progress( attempt: StrictStr, step: StrictStr, body: DeclareStepProgressRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62421,12 +65719,12 @@ async def declare_step_progress_with_http_info( attempt: StrictStr, step: StrictStr, body: DeclareStepProgressRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62474,12 +65772,12 @@ async def declare_step_progress_without_preload_content( attempt: StrictStr, step: StrictStr, body: DeclareStepProgressRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62553,12 +65851,12 @@ Do not edit the class manually. @validate_call async def create_organization_invitation( body: CreateOrganizationInvitationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62598,12 +65896,12 @@ Returns the result object. @validate_call async def create_organization_invitation_with_http_info( body: CreateOrganizationInvitationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62643,12 +65941,12 @@ Returns the result object. @validate_call async def create_organization_invitation_without_preload_content( body: CreateOrganizationInvitationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62689,14 +65987,15 @@ Returns the result object. async def delete_organization_invitation( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to delete" - )], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field( + description="The id of the organization invitation to delete"), + ], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62736,13 +66035,14 @@ Returns the result object. async def delete_organization_invitation_with_http_info( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="The id of the organization invitation to delete"), + ], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62783,13 +66083,14 @@ Returns the result object. async def delete_organization_invitation_without_preload_content( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="The id of the organization invitation to delete"), + ], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62830,12 +66131,12 @@ Returns the result object. async def get_organization_invitation( id: Annotated[StrictStr, Field(description="The id of the invitation to get")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62876,12 +66177,12 @@ Returns the result object. async def get_organization_invitation_with_http_info( id: Annotated[StrictStr, Field(description="The id of the invitation to get")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62922,12 +66223,12 @@ Returns the result object. async def get_organization_invitation_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the invitation to get")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -62968,28 +66269,32 @@ Returns the result object. async def list_organization_invitations( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on organization invitation statuses" - )] = None, + ), + ] = None, user_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on invitee ID. Will match both invitations sent to that user_id and invitations sent to the email of that user_id. The only valid value is the requester's user_id" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63033,28 +66338,32 @@ Returns the result object. async def list_organization_invitations_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on organization invitation statuses" - )] = None, + ), + ] = None, user_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on invitee ID. Will match both invitations sent to that user_id and invitations sent to the email of that user_id. The only valid value is the requester's user_id" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63098,28 +66407,32 @@ Returns the result object. async def list_organization_invitations_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on organization invitation statuses" - )] = None, + ), + ] = None, user_id: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on invitee ID. Will match both invitations sent to that user_id and invitations sent to the email of that user_id. The only valid value is the requester's user_id" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63163,14 +66476,15 @@ Returns the result object. async def resend_organization_invitation( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to resend")], + Field(description="The id of the organization invitation to resend"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63212,14 +66526,15 @@ Returns the result object. async def resend_organization_invitation_with_http_info( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to resend")], + Field(description="The id of the organization invitation to resend"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63261,14 +66576,15 @@ Returns the result object. async def resend_organization_invitation_without_preload_content( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to resend")], + Field(description="The id of the organization invitation to resend"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63335,12 +66651,12 @@ Do not edit the class manually. @validate_call async def list_usage( region: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63380,12 +66696,12 @@ Returns the result object. @validate_call async def list_usage_with_http_info( region: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63425,12 +66741,12 @@ Returns the result object. @validate_call async def list_usage_without_preload_content( region: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63462,6 +66778,730 @@ in the spec for a single request. Returns the result object. + + +# koyeb/api\_async.api.service\_pools\_api + +Koyeb Rest API + +The Koyeb API allows you to interact with the Koyeb platform in a simple, programmatic way using conventional HTTP requests. + +The version of the OpenAPI document: 1.0.0 +Generated by OpenAPI Generator (https://openapi-generator.tech) + +Do not edit the class manually. + + + +## ServicePoolsApi Objects + +```python +class ServicePoolsApi() +``` + +NOTE: This class is auto generated by OpenAPI Generator +Ref: https://openapi-generator.tech + +Do not edit the class manually. + + + +#### create\_service\_pool + +```python +@validate_call +async def create_service_pool( + service_pool: CreateServicePool, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> CreateServicePoolReply +``` + +Create a ServicePool + +**Arguments**: + +- `service_pool` (`CreateServicePool`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### create\_service\_pool\_with\_http\_info + +```python +@validate_call +async def create_service_pool_with_http_info( + service_pool: CreateServicePool, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[CreateServicePoolReply] +``` + +Create a ServicePool + +**Arguments**: + +- `service_pool` (`CreateServicePool`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### create\_service\_pool\_without\_preload\_content + +```python +@validate_call +async def create_service_pool_without_preload_content( + service_pool: CreateServicePool, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +Create a ServicePool + +**Arguments**: + +- `service_pool` (`CreateServicePool`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_service\_pool + +```python +@validate_call +async def delete_service_pool( + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0) -> object +``` + +Delete a ServicePool + +**Arguments**: + +- `id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_service\_pool\_with\_http\_info + +```python +@validate_call +async def delete_service_pool_with_http_info( + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[object] +``` + +Delete a ServicePool + +**Arguments**: + +- `id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### delete\_service\_pool\_without\_preload\_content + +```python +@validate_call +async def delete_service_pool_without_preload_content( + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +Delete a ServicePool + +**Arguments**: + +- `id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### get\_service\_pool + +```python +@validate_call +async def get_service_pool( + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> GetServicePoolReply +``` + +Get a ServicePool + +**Arguments**: + +- `id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### get\_service\_pool\_with\_http\_info + +```python +@validate_call +async def get_service_pool_with_http_info( + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[GetServicePoolReply] +``` + +Get a ServicePool + +**Arguments**: + +- `id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### get\_service\_pool\_without\_preload\_content + +```python +@validate_call +async def get_service_pool_without_preload_content( + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +Get a ServicePool + +**Arguments**: + +- `id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### list\_service\_pools + +```python +@validate_call +async def list_service_pools( + name: Optional[StrictStr] = None, + limit: Optional[StrictStr] = None, + offset: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ListServicePoolsReply +``` + +List ServicePools + +**Arguments**: + +- `name` (`str`): +- `limit` (`str`): +- `offset` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### list\_service\_pools\_with\_http\_info + +```python +@validate_call +async def list_service_pools_with_http_info( + name: Optional[StrictStr] = None, + limit: Optional[StrictStr] = None, + offset: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[ListServicePoolsReply] +``` + +List ServicePools + +**Arguments**: + +- `name` (`str`): +- `limit` (`str`): +- `offset` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### list\_service\_pools\_without\_preload\_content + +```python +@validate_call +async def list_service_pools_without_preload_content( + name: Optional[StrictStr] = None, + limit: Optional[StrictStr] = None, + offset: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +List ServicePools + +**Arguments**: + +- `name` (`str`): +- `limit` (`str`): +- `offset` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### update\_service\_pool + +```python +@validate_call +async def update_service_pool( + id: StrictStr, + service_pool: UpdateServicePool, + update_mask: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> UpdateServicePoolReply +``` + +update_service_pool + +**Arguments**: + +- `id` (`str`): (required) +- `service_pool` (`UpdateServicePool`): (required) +- `update_mask` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### update\_service\_pool\_with\_http\_info + +```python +@validate_call +async def update_service_pool_with_http_info( + id: StrictStr, + service_pool: UpdateServicePool, + update_mask: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[UpdateServicePoolReply] +``` + +update_service_pool + +**Arguments**: + +- `id` (`str`): (required) +- `service_pool` (`UpdateServicePool`): (required) +- `update_mask` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### update\_service\_pool\_without\_preload\_content + +```python +@validate_call +async def update_service_pool_without_preload_content( + id: StrictStr, + service_pool: UpdateServicePool, + update_mask: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +update_service_pool + +**Arguments**: + +- `id` (`str`): (required) +- `service_pool` (`UpdateServicePool`): (required) +- `update_mask` (`str`): +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + # koyeb/api\_async.api.intercom\_api @@ -63495,12 +67535,12 @@ Do not edit the class manually. ```python @validate_call async def get_intercom_profile( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63538,12 +67578,12 @@ Returns the result object. ```python @validate_call async def get_intercom_profile_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63581,12 +67621,12 @@ Returns the result object. ```python @validate_call async def get_intercom_profile_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63651,12 +67691,12 @@ Do not edit the class manually. @validate_call async def create_app( app: CreateApp, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63696,12 +67736,12 @@ Returns the result object. @validate_call async def create_app_with_http_info( app: CreateApp, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63741,12 +67781,12 @@ Returns the result object. @validate_call async def create_app_without_preload_content( app: CreateApp, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63787,12 +67827,12 @@ Returns the result object. async def delete_app( id: Annotated[StrictStr, Field(description="The id of the App to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63834,12 +67874,12 @@ Returns the result object. async def delete_app_with_http_info( id: Annotated[StrictStr, Field(description="The id of the App to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63882,12 +67922,12 @@ Returns the result object. async def delete_app_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the App to delete")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63930,12 +67970,12 @@ Returns the result object. async def get_app( id: Annotated[StrictStr, Field(description="The id of the App")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -63975,12 +68015,12 @@ Returns the result object. @validate_call async def get_app_with_http_info( id: Annotated[StrictStr, Field(description="The id of the App")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64020,12 +68060,12 @@ Returns the result object. @validate_call async def get_app_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the App")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64068,26 +68108,30 @@ async def list_app_events( Field(description="(Optional) Filter on app id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on app event types")] = None, + Field(description="(Optional) Filter on app event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64134,26 +68178,30 @@ async def list_app_events_with_http_info( Field(description="(Optional) Filter on app id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on app event types")] = None, + Field(description="(Optional) Filter on app event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64200,26 +68248,30 @@ async def list_app_events_without_preload_content( Field(description="(Optional) Filter on app id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on app event types")] = None, + Field(description="(Optional) Filter on app event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64264,26 +68316,25 @@ Returns the result object. async def list_apps( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return" - )] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field( - description= - "(Optional) The offset in the list of item to return")] = None, + Field(description= + "(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field( - description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[Optional[List[StrictStr]], + Field( + description="(Optional) Filter on app ids")] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64298,7 +68349,7 @@ List App - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return - `name` (`str`): (Optional) A filter for name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on app ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -64327,22 +68378,23 @@ Returns the result object. async def list_apps_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[Optional[List[StrictStr]], + Field(description="(Optional) Filter on app ids")] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64357,7 +68409,7 @@ List App - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return - `name` (`str`): (Optional) A filter for name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on app ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -64386,22 +68438,23 @@ Returns the result object. async def list_apps_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[Optional[StrictStr], Field(description="(Optional) A filter for name")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[Optional[List[StrictStr]], + Field(description="(Optional) Filter on app ids")] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64416,7 +68469,7 @@ List App - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return - `name` (`str`): (Optional) A filter for name -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on app ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -64445,12 +68498,12 @@ Returns the result object. async def pause_app( id: Annotated[StrictStr, Field(description="The id of the app to pause.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64492,12 +68545,12 @@ Returns the result object. async def pause_app_with_http_info( id: Annotated[StrictStr, Field(description="The id of the app to pause.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64540,12 +68593,12 @@ Returns the result object. async def pause_app_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the app to pause.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64588,12 +68641,12 @@ Returns the result object. async def resume_app( id: Annotated[StrictStr, Field(description="The id of the app to resume.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64635,12 +68688,12 @@ Returns the result object. async def resume_app_with_http_info( id: Annotated[StrictStr, Field(description="The id of the app to resume.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64683,12 +68736,12 @@ Returns the result object. async def resume_app_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the app to resume.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64733,12 +68786,12 @@ async def update_app( Field(description="The id of the app to update.")], app: UpdateApp, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64783,12 +68836,12 @@ async def update_app_with_http_info( Field(description="The id of the app to update.")], app: UpdateApp, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64833,12 +68886,12 @@ async def update_app_without_preload_content( Field(description="The id of the app to update.")], app: UpdateApp, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64883,12 +68936,12 @@ async def update_app2( Field(description="The id of the app to update.")], app: UpdateApp, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64933,12 +68986,12 @@ async def update_app2_with_http_info( Field(description="The id of the app to update.")], app: UpdateApp, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -64983,12 +69036,12 @@ async def update_app2_without_preload_content( Field(description="The id of the app to update.")], app: UpdateApp, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65056,12 +69109,12 @@ Do not edit the class manually. @validate_call async def create_invite( body: InviteUserRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65100,12 +69153,12 @@ Returns the result object. @validate_call async def create_invite_with_http_info( body: InviteUserRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65145,12 +69198,12 @@ Returns the result object. @validate_call async def create_invite_without_preload_content( body: InviteUserRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65218,12 +69271,12 @@ async def cancel_deployment( id: Annotated[StrictStr, Field( description="The id of the deployment to cancel.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65265,12 +69318,12 @@ Returns the result object. async def cancel_deployment_with_http_info( id: Annotated[StrictStr, Field(description="The id of the deployment to cancel.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65313,12 +69366,12 @@ Returns the result object. async def cancel_deployment_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the deployment to cancel.")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65361,12 +69414,12 @@ Returns the result object. async def get_deployment( id: Annotated[StrictStr, Field(description="The id of the deployment")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65407,12 +69460,12 @@ Returns the result object. async def get_deployment_with_http_info( id: Annotated[StrictStr, Field(description="The id of the deployment")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65453,12 +69506,12 @@ Returns the result object. async def get_deployment_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the deployment")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65503,12 +69556,12 @@ async def get_deployment_scaling( replica_index: Annotated[ Optional[StrictInt], Field(description="(Optional) Filter on replica_index")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65555,12 +69608,12 @@ async def get_deployment_scaling_with_http_info( replica_index: Annotated[ Optional[StrictInt], Field(description="(Optional) Filter on replica_index")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65607,12 +69660,12 @@ async def get_deployment_scaling_without_preload_content( replica_index: Annotated[ Optional[StrictInt], Field(description="(Optional) Filter on replica_index")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65658,27 +69711,30 @@ async def list_deployment_events( Field(description="(Optional) Filter on deployment id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field( - description="(Optional) Filter on deployment event types")] = None, + Field(description="(Optional) Filter on deployment event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65726,27 +69782,30 @@ async def list_deployment_events_with_http_info( Field(description="(Optional) Filter on deployment id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field( - description="(Optional) Filter on deployment event types")] = None, + Field(description="(Optional) Filter on deployment event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65794,27 +69853,30 @@ async def list_deployment_events_without_preload_content( Field(description="(Optional) Filter on deployment id")] = None, types: Annotated[ Optional[List[StrictStr]], - Field( - description="(Optional) Filter on deployment event types")] = None, + Field(description="(Optional) Filter on deployment event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65859,26 +69921,34 @@ Returns the result object. async def list_deployments( app_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on application id")] = None, + Field(description="(Optional) Filter on application id"), + ] = None, service_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on service id")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on statuses")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on statuses"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on deployment ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65895,6 +69965,7 @@ List Deployments - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return - `statuses` (`List[str]`): (Optional) Filter on statuses +- `ids` (`List[str]`): (Optional) Filter on deployment ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -65923,26 +69994,34 @@ Returns the result object. async def list_deployments_with_http_info( app_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on application id")] = None, + Field(description="(Optional) Filter on application id"), + ] = None, service_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on service id")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on statuses")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on statuses"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on deployment ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -65959,6 +70038,7 @@ List Deployments - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return - `statuses` (`List[str]`): (Optional) Filter on statuses +- `ids` (`List[str]`): (Optional) Filter on deployment ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -65987,26 +70067,34 @@ Returns the result object. async def list_deployments_without_preload_content( app_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on application id")] = None, + Field(description="(Optional) Filter on application id"), + ] = None, service_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on service id")] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on statuses")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter on statuses"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on deployment ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66023,6 +70111,7 @@ List Deployments - `limit` (`str`): (Optional) The number of items to return - `offset` (`str`): (Optional) The offset in the list of item to return - `statuses` (`List[str]`): (Optional) Filter on statuses +- `ids` (`List[str]`): (Optional) Filter on deployment ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -66076,12 +70165,12 @@ Do not edit the class manually. @validate_call async def create_project( project: CreateProject, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66121,12 +70210,12 @@ Returns the result object. @validate_call async def create_project_with_http_info( project: CreateProject, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66166,12 +70255,12 @@ Returns the result object. @validate_call async def create_project_without_preload_content( project: CreateProject, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66211,12 +70300,12 @@ Returns the result object. @validate_call async def delete_project( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66255,12 +70344,12 @@ Returns the result object. @validate_call async def delete_project_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66300,12 +70389,12 @@ Returns the result object. @validate_call async def delete_project_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66345,12 +70434,12 @@ Returns the result object. @validate_call async def get_project( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66390,12 +70479,12 @@ Returns the result object. @validate_call async def get_project_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66435,12 +70524,12 @@ Returns the result object. @validate_call async def get_project_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66481,20 +70570,22 @@ Returns the result object. async def list_projects( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter by project name")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66537,20 +70628,22 @@ Returns the result object. async def list_projects_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter by project name")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66593,20 +70686,22 @@ Returns the result object. async def list_projects_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, name: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter by project name")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66650,12 +70745,12 @@ async def update_project( id: StrictStr, project: Project, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66699,12 +70794,12 @@ async def update_project_with_http_info( id: StrictStr, project: Project, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66748,12 +70843,12 @@ async def update_project_without_preload_content( id: StrictStr, project: Project, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66797,12 +70892,12 @@ async def update_project2( id: StrictStr, project: Project, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66846,12 +70941,12 @@ async def update_project2_with_http_info( id: StrictStr, project: Project, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66895,12 +70990,12 @@ async def update_project2_without_preload_content( id: StrictStr, project: Project, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -66969,27 +71064,30 @@ Do not edit the class manually. async def list_organization_members( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter for an organization")] = None, + Field(description="(Optional) Filter for an organization"), + ] = None, user_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter for an user")] = None, organization_statuses: Annotated[ Optional[List[StrictStr]], - Field( - description="(Optional) Filter for organization statuses")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter for organization statuses"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67034,27 +71132,30 @@ Returns the result object. async def list_organization_members_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter for an organization")] = None, + Field(description="(Optional) Filter for an organization"), + ] = None, user_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter for an user")] = None, organization_statuses: Annotated[ Optional[List[StrictStr]], - Field( - description="(Optional) Filter for organization statuses")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter for organization statuses"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67099,27 +71200,30 @@ Returns the result object. async def list_organization_members_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter for an organization")] = None, + Field(description="(Optional) Filter for an organization"), + ] = None, user_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter for an user")] = None, organization_statuses: Annotated[ Optional[List[StrictStr]], - Field( - description="(Optional) Filter for organization statuses")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="(Optional) Filter for organization statuses"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67163,12 +71267,12 @@ Returns the result object. @validate_call async def remove_organization_member( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67208,12 +71312,12 @@ Returns the result object. @validate_call async def remove_organization_member_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67253,12 +71357,12 @@ Returns the result object. @validate_call async def remove_organization_member_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67327,12 +71431,12 @@ async def create_access_token( Field( description="Organization id for ephemeral credential")], body: CreateAccessTokenRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67378,12 +71482,12 @@ async def create_access_token_with_http_info( Field( description="Organization id for ephemeral credential")], body: CreateAccessTokenRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67429,12 +71533,12 @@ async def create_access_token_without_preload_content( Field( description="Organization id for ephemeral credential")], body: CreateAccessTokenRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67478,12 +71582,12 @@ Returns the result object. async def create_budget( organization_id: StrictStr, body: UpdateBudgetRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67525,12 +71629,12 @@ Returns the result object. async def create_budget_with_http_info( organization_id: StrictStr, body: UpdateBudgetRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67572,12 +71676,12 @@ Returns the result object. async def create_budget_without_preload_content( organization_id: StrictStr, body: UpdateBudgetRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67618,12 +71722,12 @@ Returns the result object. @validate_call async def create_organization( body: CreateOrganizationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67663,12 +71767,12 @@ Returns the result object. @validate_call async def create_organization_with_http_info( body: CreateOrganizationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67708,12 +71812,12 @@ Returns the result object. @validate_call async def create_organization_without_preload_content( body: CreateOrganizationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67754,12 +71858,12 @@ Returns the result object. async def deactivate_organization( id: StrictStr, body: DeactivateOrganizationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67801,12 +71905,12 @@ Returns the result object. async def deactivate_organization_with_http_info( id: StrictStr, body: DeactivateOrganizationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67848,12 +71952,12 @@ Returns the result object. async def deactivate_organization_without_preload_content( id: StrictStr, body: DeactivateOrganizationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67894,12 +71998,12 @@ Returns the result object. @validate_call async def delete_budget( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67938,12 +72042,12 @@ Returns the result object. @validate_call async def delete_budget_with_http_info( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -67983,12 +72087,12 @@ Returns the result object. @validate_call async def delete_budget_without_preload_content( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68028,12 +72132,12 @@ Returns the result object. @validate_call async def delete_organization( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68073,12 +72177,12 @@ Returns the result object. @validate_call async def delete_organization_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68118,12 +72222,12 @@ Returns the result object. @validate_call async def delete_organization_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68163,12 +72267,12 @@ Returns the result object. @validate_call async def get_budget( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68208,12 +72312,12 @@ Returns the result object. @validate_call async def get_budget_with_http_info( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68253,12 +72357,12 @@ Returns the result object. @validate_call async def get_budget_without_preload_content( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68297,12 +72401,12 @@ Returns the result object. ```python @validate_call async def get_github_installation( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68340,12 +72444,12 @@ Returns the result object. ```python @validate_call async def get_github_installation_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68383,12 +72487,12 @@ Returns the result object. ```python @validate_call async def get_github_installation_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68427,12 +72531,12 @@ Returns the result object. @validate_call async def get_organization( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68472,12 +72576,12 @@ Returns the result object. @validate_call async def get_organization_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68517,12 +72621,12 @@ Returns the result object. @validate_call async def get_organization_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68562,12 +72666,12 @@ Returns the result object. @validate_call async def github_installation( body: GithubInstallationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68607,12 +72711,12 @@ Returns the result object. @validate_call async def github_installation_with_http_info( body: GithubInstallationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68652,12 +72756,12 @@ Returns the result object. @validate_call async def github_installation_without_preload_content( body: GithubInstallationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68698,12 +72802,12 @@ Returns the result object. async def reactivate_organization( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68745,12 +72849,12 @@ Returns the result object. async def reactivate_organization_with_http_info( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68792,12 +72896,12 @@ Returns the result object. async def reactivate_organization_without_preload_content( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68841,12 +72945,12 @@ async def switch_organization( body: Dict[str, Any], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68891,12 +72995,12 @@ async def switch_organization_with_http_info( body: Dict[str, Any], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68941,12 +73045,12 @@ async def switch_organization_without_preload_content( body: Dict[str, Any], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -68990,12 +73094,12 @@ async def unscope_organization_token( body: Dict[str, Any], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69040,12 +73144,12 @@ async def unscope_organization_token_with_http_info( body: Dict[str, Any], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69090,12 +73194,12 @@ async def unscope_organization_token_without_preload_content( body: Dict[str, Any], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69139,12 +73243,12 @@ Returns the result object. async def update_budget( organization_id: StrictStr, body: UpdateBudgetRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69186,12 +73290,12 @@ Returns the result object. async def update_budget_with_http_info( organization_id: StrictStr, body: UpdateBudgetRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69233,12 +73337,12 @@ Returns the result object. async def update_budget_without_preload_content( organization_id: StrictStr, body: UpdateBudgetRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69281,12 +73385,12 @@ async def update_organization( id: StrictStr, organization: Organization, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69330,12 +73434,12 @@ async def update_organization_with_http_info( id: StrictStr, organization: Organization, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69379,12 +73483,12 @@ async def update_organization_without_preload_content( id: StrictStr, organization: Organization, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69428,12 +73532,12 @@ async def update_organization2( id: StrictStr, organization: Organization, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69477,12 +73581,12 @@ async def update_organization2_with_http_info( id: StrictStr, organization: Organization, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69526,12 +73630,12 @@ async def update_organization2_without_preload_content( id: StrictStr, organization: Organization, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69574,12 +73678,12 @@ Returns the result object. async def update_organization_default_project( id: StrictStr, body: UpdateOrganizationDefaultProjectRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69621,12 +73725,12 @@ Returns the result object. async def update_organization_default_project_with_http_info( id: StrictStr, body: UpdateOrganizationDefaultProjectRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69668,12 +73772,12 @@ Returns the result object. async def update_organization_default_project_without_preload_content( id: StrictStr, body: UpdateOrganizationDefaultProjectRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69715,12 +73819,12 @@ Returns the result object. async def update_organization_name( id: StrictStr, body: UpdateOrganizationNameRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69762,12 +73866,12 @@ Returns the result object. async def update_organization_name_with_http_info( id: StrictStr, body: UpdateOrganizationNameRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69809,12 +73913,12 @@ Returns the result object. async def update_organization_name_without_preload_content( id: StrictStr, body: UpdateOrganizationNameRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69856,12 +73960,12 @@ Returns the result object. async def update_organization_plan( id: StrictStr, body: UpdateOrganizationPlanRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69903,12 +74007,12 @@ Returns the result object. async def update_organization_plan_with_http_info( id: StrictStr, body: UpdateOrganizationPlanRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69950,12 +74054,12 @@ Returns the result object. async def update_organization_plan_without_preload_content( id: StrictStr, body: UpdateOrganizationPlanRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -69997,12 +74101,12 @@ Returns the result object. async def upsert_signup_qualification( id: StrictStr, body: UpsertSignupQualificationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70044,12 +74148,12 @@ Returns the result object. async def upsert_signup_qualification_with_http_info( id: StrictStr, body: UpsertSignupQualificationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70091,12 +74195,12 @@ Returns the result object. async def upsert_signup_qualification_without_preload_content( id: StrictStr, body: UpsertSignupQualificationRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70155,6 +74259,141 @@ Ref: https://openapi-generator.tech Do not edit the class manually. + + +#### get\_organization\_quotas\_usage + +```python +@validate_call +async def get_organization_quotas_usage( + organization_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> GetOrganizationQuotasUsageReply +``` + +Return the organization's current quota usage alongside the plan's limits. Response is cached in Redis for 60s. Accept text/plain (or ?format=prometheus) to receive the response rendered as Prometheus text exposition format ("koyeb_quota_" for usage, "koyeb_quota__limit" for the plan limit) suitable for scraping into an external Prometheus. + +**Arguments**: + +- `organization_id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### get\_organization\_quotas\_usage\_with\_http\_info + +```python +@validate_call +async def get_organization_quotas_usage_with_http_info( + organization_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0 +) -> ApiResponse[GetOrganizationQuotasUsageReply] +``` + +Return the organization's current quota usage alongside the plan's limits. Response is cached in Redis for 60s. Accept text/plain (or ?format=prometheus) to receive the response rendered as Prometheus text exposition format ("koyeb_quota_" for usage, "koyeb_quota__limit" for the plan limit) suitable for scraping into an external Prometheus. + +**Arguments**: + +- `organization_id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + + + +#### get\_organization\_quotas\_usage\_without\_preload\_content + +```python +@validate_call +async def get_organization_quotas_usage_without_preload_content( + organization_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, + Field(ge=0, le=0)] = 0) -> RESTResponseType +``` + +Return the organization's current quota usage alongside the plan's limits. Response is cached in Redis for 60s. Accept text/plain (or ?format=prometheus) to receive the response rendered as Prometheus text exposition format ("koyeb_quota_" for usage, "koyeb_quota__limit" for the plan limit) suitable for scraping into an external Prometheus. + +**Arguments**: + +- `organization_id` (`str`): (required) +- `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one +number provided, it will be total request +timeout. It can also be a pair (tuple) of +(connection, read) timeouts. +- `_request_auth` (`dict, optional`): set to override the auth_settings for an a single +request; this effectively ignores the +authentication in the spec for a single request. +- `_content_type` (`str, Optional`): force content-type for the request. +- `_headers` (`dict, optional`): set to override the headers for a single +request; this effectively ignores the headers +in the spec for a single request. +- `_host_index` (`int, optional`): set to override the host_index for a single +request; this effectively ignores the host_index +in the spec for a single request. + +**Returns**: + +Returns the result object. + #### review\_organization\_capacity @@ -70163,12 +74402,12 @@ Do not edit the class manually. @validate_call async def review_organization_capacity( body: ReviewOrganizationCapacityRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70208,12 +74447,12 @@ Returns the result object. @validate_call async def review_organization_capacity_with_http_info( body: ReviewOrganizationCapacityRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70253,12 +74492,12 @@ Returns the result object. @validate_call async def review_organization_capacity_without_preload_content( body: ReviewOrganizationCapacityRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70325,18 +74564,18 @@ Do not edit the class manually. async def get_organization_usage( starting_time: Annotated[ Optional[datetime], - Field(description="The starting time of the period to get data from" - )] = None, + Field(description="The starting time of the period to get data from"), + ] = None, ending_time: Annotated[ Optional[datetime], - Field(description="The ending time of the period to get data from" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="The ending time of the period to get data from"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70378,18 +74617,18 @@ Returns the result object. async def get_organization_usage_with_http_info( starting_time: Annotated[ Optional[datetime], - Field(description="The starting time of the period to get data from" - )] = None, + Field(description="The starting time of the period to get data from"), + ] = None, ending_time: Annotated[ Optional[datetime], - Field(description="The ending time of the period to get data from" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="The ending time of the period to get data from"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70431,18 +74670,18 @@ Returns the result object. async def get_organization_usage_without_preload_content( starting_time: Annotated[ Optional[datetime], - Field(description="The starting time of the period to get data from" - )] = None, + Field(description="The starting time of the period to get data from"), + ] = None, ending_time: Annotated[ Optional[datetime], - Field(description="The ending time of the period to get data from" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + Field(description="The ending time of the period to get data from"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70484,36 +74723,39 @@ Returns the result object. async def get_organization_usage_details( starting_time: Annotated[ Optional[datetime], - Field(description="The starting time of the period to get data from" - )] = None, + Field(description="The starting time of the period to get data from"), + ] = None, ending_time: Annotated[ Optional[datetime], - Field(description="The ending time of the period to get data from" - )] = None, + Field(description="The ending time of the period to get data from"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, accept: Annotated[ Optional[StrictStr], Field(description= - "If defined with the value 'text/csv', a csv file is returned" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If defined with the value 'text/csv', a csv file is returned"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70559,36 +74801,39 @@ Returns the result object. async def get_organization_usage_details_with_http_info( starting_time: Annotated[ Optional[datetime], - Field(description="The starting time of the period to get data from" - )] = None, + Field(description="The starting time of the period to get data from"), + ] = None, ending_time: Annotated[ Optional[datetime], - Field(description="The ending time of the period to get data from" - )] = None, + Field(description="The ending time of the period to get data from"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, accept: Annotated[ Optional[StrictStr], Field(description= - "If defined with the value 'text/csv', a csv file is returned" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If defined with the value 'text/csv', a csv file is returned"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70634,36 +74879,39 @@ Returns the result object. async def get_organization_usage_details_without_preload_content( starting_time: Annotated[ Optional[datetime], - Field(description="The starting time of the period to get data from" - )] = None, + Field(description="The starting time of the period to get data from"), + ] = None, ending_time: Annotated[ Optional[datetime], - Field(description="The ending time of the period to get data from" - )] = None, + Field(description="The ending time of the period to get data from"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, accept: Annotated[ Optional[StrictStr], Field(description= - "If defined with the value 'text/csv', a csv file is returned" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "If defined with the value 'text/csv', a csv file is returned"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70736,12 +74984,12 @@ async def login( body: LoginRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70784,12 +75032,12 @@ async def login_with_http_info( body: LoginRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70832,12 +75080,12 @@ async def login_without_preload_content( body: LoginRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70877,12 +75125,12 @@ Returns the result object. ```python @validate_call async def logout( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70919,12 +75167,12 @@ Returns the result object. ```python @validate_call async def logout_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -70962,12 +75210,12 @@ Returns the result object. ```python @validate_call async def logout_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71005,12 +75253,12 @@ Returns the result object. ```python @validate_call async def new_session( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71050,12 +75298,12 @@ Returns the result object. ```python @validate_call async def new_session_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71095,12 +75343,12 @@ Returns the result object. ```python @validate_call async def new_session_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71140,12 +75388,12 @@ Returns the result object. ```python @validate_call async def refresh_token( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71183,12 +75431,12 @@ Returns the result object. ```python @validate_call async def refresh_token_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71226,12 +75474,12 @@ Returns the result object. ```python @validate_call async def refresh_token_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71296,12 +75544,12 @@ Do not edit the class manually. @validate_call async def create_secret( secret: CreateSecret, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71341,12 +75589,12 @@ Returns the result object. @validate_call async def create_secret_with_http_info( secret: CreateSecret, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71386,12 +75634,12 @@ Returns the result object. @validate_call async def create_secret_without_preload_content( secret: CreateSecret, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71431,12 +75679,12 @@ Returns the result object. @validate_call async def delete_secret( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71475,12 +75723,12 @@ Returns the result object. @validate_call async def delete_secret_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71520,12 +75768,12 @@ Returns the result object. @validate_call async def delete_secret_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71565,12 +75813,12 @@ Returns the result object. @validate_call async def get_secret( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71610,12 +75858,12 @@ Returns the result object. @validate_call async def get_secret_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71655,12 +75903,12 @@ Returns the result object. @validate_call async def get_secret_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71704,15 +75952,16 @@ async def list_secrets( offset: Optional[StrictStr] = None, types: Annotated[Optional[List[StrictStr]], Field(description="Filter by secret types")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on secret ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71728,7 +75977,7 @@ List Secrets - `limit` (`str`): - `offset` (`str`): - `types` (`List[str]`): Filter by secret types -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on secret ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -71760,15 +76009,16 @@ async def list_secrets_with_http_info( offset: Optional[StrictStr] = None, types: Annotated[Optional[List[StrictStr]], Field(description="Filter by secret types")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on secret ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71784,7 +76034,7 @@ List Secrets - `limit` (`str`): - `offset` (`str`): - `types` (`List[str]`): Filter by secret types -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on secret ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -71816,15 +76066,16 @@ async def list_secrets_without_preload_content( offset: Optional[StrictStr] = None, types: Annotated[Optional[List[StrictStr]], Field(description="Filter by secret types")] = None, - project_id: Annotated[ - Optional[StrictStr], - Field(description="(Optional) A filter for the project ID")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on secret ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71840,7 +76091,7 @@ List Secrets - `limit` (`str`): - `offset` (`str`): - `types` (`List[str]`): Filter by secret types -- `project_id` (`str`): (Optional) A filter for the project ID +- `ids` (`List[str]`): (Optional) Filter on secret ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -71869,12 +76120,12 @@ Returns the result object. async def reveal_secret( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71916,12 +76167,12 @@ Returns the result object. async def reveal_secret_with_http_info( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -71963,12 +76214,12 @@ Returns the result object. async def reveal_secret_without_preload_content( id: StrictStr, body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72011,12 +76262,12 @@ async def update_secret( id: StrictStr, secret: Secret, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72060,12 +76311,12 @@ async def update_secret_with_http_info( id: StrictStr, secret: Secret, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72109,12 +76360,12 @@ async def update_secret_without_preload_content( id: StrictStr, secret: Secret, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72158,12 +76409,12 @@ async def update_secret2( id: StrictStr, secret: Secret, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72207,12 +76458,12 @@ async def update_secret2_with_http_info( id: StrictStr, secret: Secret, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72256,12 +76507,12 @@ async def update_secret2_without_preload_content( id: StrictStr, secret: Secret, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72330,14 +76581,15 @@ Do not edit the class manually. async def accept_organization_invitation( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to accept")], + Field(description="The id of the organization invitation to accept"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72379,14 +76631,15 @@ Returns the result object. async def accept_organization_invitation_with_http_info( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to accept")], + Field(description="The id of the organization invitation to accept"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72428,14 +76681,15 @@ Returns the result object. async def accept_organization_invitation_without_preload_content( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to accept")], + Field(description="The id of the organization invitation to accept"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72476,12 +76730,12 @@ Returns the result object. @validate_call async def clear_idenfy_verification_result( body: ClearIdenfyVerificationResultRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72520,12 +76774,12 @@ Returns the result object. @validate_call async def clear_idenfy_verification_result_with_http_info( body: ClearIdenfyVerificationResultRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72565,12 +76819,12 @@ Returns the result object. @validate_call async def clear_idenfy_verification_result_without_preload_content( body: ClearIdenfyVerificationResultRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72611,14 +76865,15 @@ Returns the result object. async def decline_organization_invitation( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to decline")], + Field(description="The id of the organization invitation to decline"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72660,14 +76915,15 @@ Returns the result object. async def decline_organization_invitation_with_http_info( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to decline")], + Field(description="The id of the organization invitation to decline"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72709,14 +76965,15 @@ Returns the result object. async def decline_organization_invitation_without_preload_content( id: Annotated[ StrictStr, - Field(description="The id of the organization invitation to decline")], + Field(description="The id of the organization invitation to decline"), + ], body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72756,12 +77013,12 @@ Returns the result object. ```python @validate_call async def get_current_organization( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72799,12 +77056,12 @@ Returns the result object. ```python @validate_call async def get_current_organization_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72842,12 +77099,12 @@ Returns the result object. ```python @validate_call async def get_current_organization_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72887,12 +77144,12 @@ Returns the result object. async def get_current_user( seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72932,12 +77189,12 @@ Returns the result object. async def get_current_user_with_http_info( seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -72978,12 +77235,12 @@ Returns the result object. async def get_current_user_without_preload_content( seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73022,12 +77279,12 @@ Returns the result object. ```python @validate_call async def get_idenfy_token( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73065,12 +77322,12 @@ Returns the result object. ```python @validate_call async def get_idenfy_token_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73108,12 +77365,12 @@ Returns the result object. ```python @validate_call async def get_idenfy_token_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73153,20 +77410,21 @@ Returns the result object. async def get_o_auth_options( action: Annotated[ Optional[StrictStr], - Field(description="Which authentication flow is being initiated" - )] = None, + Field(description="Which authentication flow is being initiated"), + ] = None, metadata: Annotated[ Optional[StrictStr], Field( description= "A small (limited to 400 characters) string of arbitrary metadata which will be encoded in the state" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73208,20 +77466,21 @@ Returns the result object. async def get_o_auth_options_with_http_info( action: Annotated[ Optional[StrictStr], - Field(description="Which authentication flow is being initiated" - )] = None, + Field(description="Which authentication flow is being initiated"), + ] = None, metadata: Annotated[ Optional[StrictStr], Field( description= "A small (limited to 400 characters) string of arbitrary metadata which will be encoded in the state" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73263,20 +77522,21 @@ Returns the result object. async def get_o_auth_options_without_preload_content( action: Annotated[ Optional[StrictStr], - Field(description="Which authentication flow is being initiated" - )] = None, + Field(description="Which authentication flow is being initiated"), + ] = None, metadata: Annotated[ Optional[StrictStr], Field( description= "A small (limited to 400 characters) string of arbitrary metadata which will be encoded in the state" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73319,12 +77579,12 @@ async def get_user_organization_invitation( id: Annotated[ StrictStr, Field(description="The id of the organization invitation to get")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73366,12 +77626,12 @@ async def get_user_organization_invitation_with_http_info( id: Annotated[ StrictStr, Field(description="The id of the organization invitation to get")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73413,12 +77673,12 @@ async def get_user_organization_invitation_without_preload_content( id: Annotated[ StrictStr, Field(description="The id of the organization invitation to get")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73457,12 +77717,12 @@ Returns the result object. ```python @validate_call async def get_user_settings( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73500,12 +77760,12 @@ Returns the result object. ```python @validate_call async def get_user_settings_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73543,12 +77803,12 @@ Returns the result object. ```python @validate_call async def get_user_settings_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73588,22 +77848,25 @@ Returns the result object. async def list_user_organization_invitations( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on organization invitation statuses" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73646,22 +77909,25 @@ Returns the result object. async def list_user_organization_invitations_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on organization invitation statuses" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73704,22 +77970,25 @@ Returns the result object. async def list_user_organization_invitations_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description="(Optional) Filter on organization invitation statuses" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73765,31 +78034,35 @@ async def list_user_organizations( Field(description="(Optional) Define pagination limit")] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) Define pagination offset")] = None, + Field(description="(Optional) Define pagination offset"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, search: Annotated[ Optional[StrictStr], Field( description= "(Optional) Fuzzy case-insensitive search based on organization name or organization id" - )] = None, + ), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Only return organizations which status match one in the list" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73839,31 +78112,35 @@ async def list_user_organizations_with_http_info( Field(description="(Optional) Define pagination limit")] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) Define pagination offset")] = None, + Field(description="(Optional) Define pagination offset"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, search: Annotated[ Optional[StrictStr], Field( description= "(Optional) Fuzzy case-insensitive search based on organization name or organization id" - )] = None, + ), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Only return organizations which status match one in the list" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73913,31 +78190,35 @@ async def list_user_organizations_without_preload_content( Field(description="(Optional) Define pagination limit")] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) Define pagination offset")] = None, + Field(description="(Optional) Define pagination offset"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, search: Annotated[ Optional[StrictStr], Field( description= "(Optional) Fuzzy case-insensitive search based on organization name or organization id" - )] = None, + ), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Only return organizations which status match one in the list" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -73983,12 +78264,12 @@ Returns the result object. @validate_call async def login_method( email: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74028,12 +78309,12 @@ Returns the result object. @validate_call async def login_method_with_http_info( email: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74073,12 +78354,12 @@ Returns the result object. @validate_call async def login_method_without_preload_content( email: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74120,12 +78401,12 @@ async def o_auth_callback( body: OAuthCallbackRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74168,12 +78449,12 @@ async def o_auth_callback_with_http_info( body: OAuthCallbackRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74216,12 +78497,12 @@ async def o_auth_callback_without_preload_content( body: OAuthCallbackRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74262,12 +78543,12 @@ Returns the result object. @validate_call async def resend_email_validation( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74306,12 +78587,12 @@ Returns the result object. @validate_call async def resend_email_validation_with_http_info( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74351,12 +78632,12 @@ Returns the result object. @validate_call async def resend_email_validation_without_preload_content( body: Dict[str, Any], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74396,12 +78677,12 @@ Returns the result object. @validate_call async def reset_password( body: ResetPasswordRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74440,12 +78721,12 @@ Returns the result object. @validate_call async def reset_password_with_http_info( body: ResetPasswordRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74485,12 +78766,12 @@ Returns the result object. @validate_call async def reset_password_without_preload_content( body: ResetPasswordRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74533,12 +78814,12 @@ async def signup( Field(description="Create new account")], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74582,12 +78863,12 @@ async def signup_with_http_info( Field(description="Create new account")], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74631,12 +78912,12 @@ async def signup_without_preload_content( Field(description="Create new account")], seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74679,12 +78960,12 @@ async def update_password( body: UpdatePasswordRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74727,12 +79008,12 @@ async def update_password_with_http_info( body: UpdatePasswordRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74775,12 +79056,12 @@ async def update_password_without_preload_content( body: UpdatePasswordRequest, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74822,12 +79103,12 @@ Returns the result object. async def update_user( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74868,12 +79149,12 @@ Returns the result object. async def update_user_with_http_info( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74915,12 +79196,12 @@ Returns the result object. async def update_user_without_preload_content( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -74962,12 +79243,12 @@ Returns the result object. async def update_user2( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75008,12 +79289,12 @@ Returns the result object. async def update_user2_with_http_info( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75055,12 +79336,12 @@ Returns the result object. async def update_user2_without_preload_content( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75101,12 +79382,12 @@ Returns the result object. @validate_call async def update_user_settings( body: UpdateUserSettingsRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75146,12 +79427,12 @@ Returns the result object. @validate_call async def update_user_settings_with_http_info( body: UpdateUserSettingsRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75191,12 +79472,12 @@ Returns the result object. @validate_call async def update_user_settings_without_preload_content( body: UpdateUserSettingsRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75237,12 +79518,12 @@ Returns the result object. async def update_user_v2( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75283,12 +79564,12 @@ Returns the result object. async def update_user_v2_with_http_info( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75330,12 +79611,12 @@ Returns the result object. async def update_user_v2_without_preload_content( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75377,12 +79658,12 @@ Returns the result object. async def update_user_v22( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75423,12 +79704,12 @@ Returns the result object. async def update_user_v22_with_http_info( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75470,12 +79751,12 @@ Returns the result object. async def update_user_v22_without_preload_content( user: UpdateUserRequestUserUpdateBody, update_mask: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75518,12 +79799,12 @@ async def validate( id: StrictStr, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75566,12 +79847,12 @@ async def validate_with_http_info( id: StrictStr, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75614,12 +79895,12 @@ async def validate_without_preload_content( id: StrictStr, seon_fp: Annotated[Optional[StrictStr], Field(description="Seon Fingerprint")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75685,12 +79966,12 @@ Do not edit the class manually. ```python @validate_call async def test_anon( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75727,12 +80008,12 @@ Returns the result object. ```python @validate_call async def test_anon_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75770,12 +80051,12 @@ Returns the result object. ```python @validate_call async def test_anon_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75814,12 +80095,12 @@ Returns the result object. @validate_call async def test_auth( body: KtestTestAuthRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75859,12 +80140,12 @@ Returns the result object. @validate_call async def test_auth_with_http_info( body: KtestTestAuthRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75904,12 +80185,12 @@ Returns the result object. @validate_call async def test_auth_without_preload_content( body: KtestTestAuthRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -75976,12 +80257,12 @@ Do not edit the class manually. async def get_catalog_instance( id: Annotated[StrictStr, Field(description="The name of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76022,12 +80303,12 @@ Returns the result object. async def get_catalog_instance_with_http_info( id: Annotated[StrictStr, Field(description="The name of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76068,12 +80349,12 @@ Returns the result object. async def get_catalog_instance_without_preload_content( id: Annotated[StrictStr, Field(description="The name of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76114,20 +80395,22 @@ Returns the result object. async def list_catalog_instances( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, id: Annotated[Optional[StrictStr], Field( description="(Optional) A filter for instances")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76170,20 +80453,22 @@ Returns the result object. async def list_catalog_instances_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, id: Annotated[Optional[StrictStr], Field( description="(Optional) A filter for instances")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76226,20 +80511,22 @@ Returns the result object. async def list_catalog_instances_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, id: Annotated[Optional[StrictStr], Field( description="(Optional) A filter for instances")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76310,33 +80597,36 @@ async def exec_command( Field(description="ID of the resource to exec on.")] = None, body_command: Annotated[ Optional[List[StrictStr]], - Field(description="Command to exec. Mandatory in the first frame sent" - )] = None, + Field( + description="Command to exec. Mandatory in the first frame sent"), + ] = None, body_tty_size_height: Optional[StrictInt] = None, body_tty_size_width: Optional[StrictInt] = None, body_stdin_data: Annotated[ Optional[Union[StrictBytes, StrictStr]], - Field(description="Data is base64 encoded")] = None, + Field(description="Data is base64 encoded"), + ] = None, body_stdin_close: Annotated[ Optional[StrictBool], Field(description="Indicate last data frame")] = None, body_disable_tty: Annotated[ Optional[StrictBool], Field(description= - "Disable TTY. It's enough to specify it in the first frame" - )] = None, + "Disable TTY. It's enough to specify it in the first frame"), + ] = None, id_type: Annotated[ Optional[StrictStr], Field( description= "When specified, it is used to determine if the kind of resource the id refers to. If missing, defaults to the instance id." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76388,33 +80678,36 @@ async def exec_command_with_http_info( Field(description="ID of the resource to exec on.")] = None, body_command: Annotated[ Optional[List[StrictStr]], - Field(description="Command to exec. Mandatory in the first frame sent" - )] = None, + Field( + description="Command to exec. Mandatory in the first frame sent"), + ] = None, body_tty_size_height: Optional[StrictInt] = None, body_tty_size_width: Optional[StrictInt] = None, body_stdin_data: Annotated[ Optional[Union[StrictBytes, StrictStr]], - Field(description="Data is base64 encoded")] = None, + Field(description="Data is base64 encoded"), + ] = None, body_stdin_close: Annotated[ Optional[StrictBool], Field(description="Indicate last data frame")] = None, body_disable_tty: Annotated[ Optional[StrictBool], Field(description= - "Disable TTY. It's enough to specify it in the first frame" - )] = None, + "Disable TTY. It's enough to specify it in the first frame"), + ] = None, id_type: Annotated[ Optional[StrictStr], Field( description= "When specified, it is used to determine if the kind of resource the id refers to. If missing, defaults to the instance id." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76466,33 +80759,36 @@ async def exec_command_without_preload_content( Field(description="ID of the resource to exec on.")] = None, body_command: Annotated[ Optional[List[StrictStr]], - Field(description="Command to exec. Mandatory in the first frame sent" - )] = None, + Field( + description="Command to exec. Mandatory in the first frame sent"), + ] = None, body_tty_size_height: Optional[StrictInt] = None, body_tty_size_width: Optional[StrictInt] = None, body_stdin_data: Annotated[ Optional[Union[StrictBytes, StrictStr]], - Field(description="Data is base64 encoded")] = None, + Field(description="Data is base64 encoded"), + ] = None, body_stdin_close: Annotated[ Optional[StrictBool], Field(description="Indicate last data frame")] = None, body_disable_tty: Annotated[ Optional[StrictBool], Field(description= - "Disable TTY. It's enough to specify it in the first frame" - )] = None, + "Disable TTY. It's enough to specify it in the first frame"), + ] = None, id_type: Annotated[ Optional[StrictStr], Field( description= "When specified, it is used to determine if the kind of resource the id refers to. If missing, defaults to the instance id." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76542,12 +80838,12 @@ Returns the result object. async def get_instance( id: Annotated[StrictStr, Field(description="The id of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76588,12 +80884,12 @@ Returns the result object. async def get_instance_with_http_info( id: Annotated[StrictStr, Field(description="The id of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76634,12 +80930,12 @@ Returns the result object. async def get_instance_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the instance")], - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76680,29 +80976,34 @@ Returns the result object. async def list_instance_events( instance_ids: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on list of instance id")] = None, + Field(description="(Optional) Filter on list of instance id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance event types")] = None, + Field(description="(Optional) Filter on instance event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76747,29 +81048,34 @@ Returns the result object. async def list_instance_events_with_http_info( instance_ids: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on list of instance id")] = None, + Field(description="(Optional) Filter on list of instance id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance event types")] = None, + Field(description="(Optional) Filter on instance event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76814,29 +81120,34 @@ Returns the result object. async def list_instance_events_without_preload_content( instance_ids: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on list of instance id")] = None, + Field(description="(Optional) Filter on list of instance id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance event types")] = None, + Field(description="(Optional) Filter on instance event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76881,7 +81192,8 @@ Returns the result object. async def list_instances( app_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on application id")] = None, + Field(description="(Optional) Filter on application id"), + ] = None, service_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on service id")] = None, @@ -76890,8 +81202,8 @@ async def list_instances( Field(description="(Optional) Filter on deployment id")] = None, regional_deployment_id: Annotated[ Optional[StrictStr], - Field( - description="(Optional) Filter on regional deployment id")] = None, + Field(description="(Optional) Filter on regional deployment id"), + ] = None, allocation_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on allocation id")] = None, @@ -76900,36 +81212,45 @@ async def list_instances( Field(description="(Optional) Filter on replica index")] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance statuses")] = None, + Field(description="(Optional) Filter on instance statuses"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, starting_time: Annotated[ Optional[datetime], - Field(description= - "(Optional) The starting time of the period of running instance" - )] = None, + Field( + description= + "(Optional) The starting time of the period of running instance"), + ] = None, ending_time: Annotated[ Optional[datetime], Field(description= - "(Optional) The ending time of the period of running instance" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "(Optional) The ending time of the period of running instance"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on instance ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -76953,6 +81274,7 @@ List Instances - `order` (`str`): (Optional) Sorts the list in the ascending or the descending order - `starting_time` (`datetime`): (Optional) The starting time of the period of running instance - `ending_time` (`datetime`): (Optional) The ending time of the period of running instance +- `ids` (`List[str]`): (Optional) Filter on instance ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -76981,7 +81303,8 @@ Returns the result object. async def list_instances_with_http_info( app_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on application id")] = None, + Field(description="(Optional) Filter on application id"), + ] = None, service_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on service id")] = None, @@ -76990,8 +81313,8 @@ async def list_instances_with_http_info( Field(description="(Optional) Filter on deployment id")] = None, regional_deployment_id: Annotated[ Optional[StrictStr], - Field( - description="(Optional) Filter on regional deployment id")] = None, + Field(description="(Optional) Filter on regional deployment id"), + ] = None, allocation_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on allocation id")] = None, @@ -77000,36 +81323,45 @@ async def list_instances_with_http_info( Field(description="(Optional) Filter on replica index")] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance statuses")] = None, + Field(description="(Optional) Filter on instance statuses"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, starting_time: Annotated[ Optional[datetime], - Field(description= - "(Optional) The starting time of the period of running instance" - )] = None, + Field( + description= + "(Optional) The starting time of the period of running instance"), + ] = None, ending_time: Annotated[ Optional[datetime], Field(description= - "(Optional) The ending time of the period of running instance" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "(Optional) The ending time of the period of running instance"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on instance ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77053,6 +81385,7 @@ List Instances - `order` (`str`): (Optional) Sorts the list in the ascending or the descending order - `starting_time` (`datetime`): (Optional) The starting time of the period of running instance - `ending_time` (`datetime`): (Optional) The ending time of the period of running instance +- `ids` (`List[str]`): (Optional) Filter on instance ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -77081,7 +81414,8 @@ Returns the result object. async def list_instances_without_preload_content( app_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on application id")] = None, + Field(description="(Optional) Filter on application id"), + ] = None, service_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on service id")] = None, @@ -77090,8 +81424,8 @@ async def list_instances_without_preload_content( Field(description="(Optional) Filter on deployment id")] = None, regional_deployment_id: Annotated[ Optional[StrictStr], - Field( - description="(Optional) Filter on regional deployment id")] = None, + Field(description="(Optional) Filter on regional deployment id"), + ] = None, allocation_id: Annotated[ Optional[StrictStr], Field(description="(Optional) Filter on allocation id")] = None, @@ -77100,36 +81434,45 @@ async def list_instances_without_preload_content( Field(description="(Optional) Filter on replica index")] = None, statuses: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance statuses")] = None, + Field(description="(Optional) Filter on instance statuses"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, + ), + ] = None, starting_time: Annotated[ Optional[datetime], - Field(description= - "(Optional) The starting time of the period of running instance" - )] = None, + Field( + description= + "(Optional) The starting time of the period of running instance"), + ] = None, ending_time: Annotated[ Optional[datetime], Field(description= - "(Optional) The ending time of the period of running instance" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + "(Optional) The ending time of the period of running instance"), + ] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on instance ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77153,6 +81496,7 @@ List Instances - `order` (`str`): (Optional) Sorts the list in the ascending or the descending order - `starting_time` (`datetime`): (Optional) The starting time of the period of running instance - `ending_time` (`datetime`): (Optional) The ending time of the period of running instance +- `ids` (`List[str]`): (Optional) Filter on instance ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -77206,12 +81550,12 @@ Do not edit the class manually. @validate_call async def compose( compose: CreateCompose, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77251,12 +81595,12 @@ Returns the result object. @validate_call async def compose_with_http_info( compose: CreateCompose, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77296,12 +81640,12 @@ Returns the result object. @validate_call async def compose_without_preload_content( compose: CreateCompose, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77366,12 +81710,12 @@ Do not edit the class manually. ```python @validate_call async def has_unpaid_invoices( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77411,12 +81755,12 @@ Returns the result object. ```python @validate_call async def has_unpaid_invoices_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77456,12 +81800,12 @@ Returns the result object. ```python @validate_call async def has_unpaid_invoices_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77501,12 +81845,12 @@ Returns the result object. ```python @validate_call async def manage( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77544,12 +81888,12 @@ Returns the result object. ```python @validate_call async def manage_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77587,12 +81931,12 @@ Returns the result object. ```python @validate_call async def manage_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77630,12 +81974,12 @@ Returns the result object. ```python @validate_call async def next_invoice( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77675,12 +82019,12 @@ Returns the result object. ```python @validate_call async def next_invoice_with_http_info( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77720,12 +82064,12 @@ Returns the result object. ```python @validate_call async def next_invoice_without_preload_content( - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77793,12 +82137,12 @@ Do not edit the class manually. async def search( query: Annotated[Optional[StrictStr], Field(description="(Optional) Search query")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77839,12 +82183,12 @@ Returns the result object. async def search_with_http_info( query: Annotated[Optional[StrictStr], Field(description="(Optional) Search query")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77885,12 +82229,12 @@ Returns the result object. async def search_without_preload_content( query: Annotated[Optional[StrictStr], Field(description="(Optional) Search query")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -77957,27 +82301,31 @@ Do not edit the class manually. async def list_branches( repository_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on one repository.")] = None, + Field(description="(Optional) Filter on one repository."), + ] = None, name: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on branch name using a fuzzy search. Repository filter is required to enable this filter." - )] = None, + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return.")] = None, + Field(description="(Optional) The number of items to return."), + ] = None, offset: Annotated[ Optional[StrictStr], Field( description="(Optional) The offset in the list of item to return." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78021,27 +82369,31 @@ Returns the result object. async def list_branches_with_http_info( repository_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on one repository.")] = None, + Field(description="(Optional) Filter on one repository."), + ] = None, name: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on branch name using a fuzzy search. Repository filter is required to enable this filter." - )] = None, + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return.")] = None, + Field(description="(Optional) The number of items to return."), + ] = None, offset: Annotated[ Optional[StrictStr], Field( description="(Optional) The offset in the list of item to return." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78085,27 +82437,31 @@ Returns the result object. async def list_branches_without_preload_content( repository_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on one repository.")] = None, + Field(description="(Optional) Filter on one repository."), + ] = None, name: Annotated[ Optional[StrictStr], Field( description= "(Optional) Filter on branch name using a fuzzy search. Repository filter is required to enable this filter." - )] = None, + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return.")] = None, + Field(description="(Optional) The number of items to return."), + ] = None, offset: Annotated[ Optional[StrictStr], Field( description="(Optional) The offset in the list of item to return." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78150,28 +82506,31 @@ async def list_repositories( name: Annotated[ Optional[StrictStr], Field(description= - "(Optional) Filter on repository name using a fuzzy search." - )] = None, + "(Optional) Filter on repository name using a fuzzy search."), + ] = None, name_search_op: Annotated[ Optional[StrictStr], Field( description= - "(Optional) Define search operation for repository name. Accept either \"fuzzy\" or \"equality\", use \"fuzzy\" by default." - )] = None, + '(Optional) Define search operation for repository name. Accept either "fuzzy" or "equality", use "fuzzy" by default.' + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return.")] = None, + Field(description="(Optional) The number of items to return."), + ] = None, offset: Annotated[ Optional[StrictStr], Field( description="(Optional) The offset in the list of item to return." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78216,28 +82575,31 @@ async def list_repositories_with_http_info( name: Annotated[ Optional[StrictStr], Field(description= - "(Optional) Filter on repository name using a fuzzy search." - )] = None, + "(Optional) Filter on repository name using a fuzzy search."), + ] = None, name_search_op: Annotated[ Optional[StrictStr], Field( description= - "(Optional) Define search operation for repository name. Accept either \"fuzzy\" or \"equality\", use \"fuzzy\" by default." - )] = None, + '(Optional) Define search operation for repository name. Accept either "fuzzy" or "equality", use "fuzzy" by default.' + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return.")] = None, + Field(description="(Optional) The number of items to return."), + ] = None, offset: Annotated[ Optional[StrictStr], Field( description="(Optional) The offset in the list of item to return." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78282,28 +82644,31 @@ async def list_repositories_without_preload_content( name: Annotated[ Optional[StrictStr], Field(description= - "(Optional) Filter on repository name using a fuzzy search." - )] = None, + "(Optional) Filter on repository name using a fuzzy search."), + ] = None, name_search_op: Annotated[ Optional[StrictStr], Field( description= - "(Optional) Define search operation for repository name. Accept either \"fuzzy\" or \"equality\", use \"fuzzy\" by default." - )] = None, + '(Optional) Define search operation for repository name. Accept either "fuzzy" or "equality", use "fuzzy" by default.' + ), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return.")] = None, + Field(description="(Optional) The number of items to return."), + ] = None, offset: Annotated[ Optional[StrictStr], Field( description="(Optional) The offset in the list of item to return." - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78346,12 +82711,12 @@ Returns the result object. @validate_call async def resync_organization( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78390,12 +82755,12 @@ Returns the result object. @validate_call async def resync_organization_with_http_info( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78435,12 +82800,12 @@ Returns the result object. @validate_call async def resync_organization_without_preload_content( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78506,12 +82871,12 @@ Do not edit the class manually. @validate_call async def create_instance_snapshot( body: CreateInstanceSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78551,12 +82916,12 @@ Returns the result object. @validate_call async def create_instance_snapshot_with_http_info( body: CreateInstanceSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78596,12 +82961,12 @@ Returns the result object. @validate_call async def create_instance_snapshot_without_preload_content( body: CreateInstanceSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78641,12 +83006,12 @@ Returns the result object. @validate_call async def delete_instance_snapshot( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78686,12 +83051,12 @@ Returns the result object. @validate_call async def delete_instance_snapshot_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78731,12 +83096,12 @@ Returns the result object. @validate_call async def delete_instance_snapshot_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78776,12 +83141,12 @@ Returns the result object. @validate_call async def get_instance_snapshot( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78821,12 +83186,12 @@ Returns the result object. @validate_call async def get_instance_snapshot_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78866,12 +83231,12 @@ Returns the result object. @validate_call async def get_instance_snapshot_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78912,30 +83277,35 @@ Returns the result object. async def list_instance_snapshot_events( instance_snapshot_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on instance snapshot id")] = None, + Field(description="(Optional) Filter on instance snapshot id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance snapshot event types" - )] = None, + Field( + description="(Optional) Filter on instance snapshot event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -78980,30 +83350,35 @@ Returns the result object. async def list_instance_snapshot_events_with_http_info( instance_snapshot_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on instance snapshot id")] = None, + Field(description="(Optional) Filter on instance snapshot id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance snapshot event types" - )] = None, + Field( + description="(Optional) Filter on instance snapshot event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79048,30 +83423,35 @@ Returns the result object. async def list_instance_snapshot_events_without_preload_content( instance_snapshot_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter on instance snapshot id")] = None, + Field(description="(Optional) Filter on instance snapshot id"), + ] = None, types: Annotated[ Optional[List[StrictStr]], - Field(description="(Optional) Filter on instance snapshot event types" - )] = None, + Field( + description="(Optional) Filter on instance snapshot event types"), + ] = None, limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, order: Annotated[ Optional[StrictStr], Field( description= "(Optional) Sorts the list in the ascending or the descending order" - )] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79119,12 +83499,13 @@ async def list_instance_snapshots( name: Optional[StrictStr] = None, statuses: Optional[List[StrictStr]] = None, type: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Optional[List[StrictStr]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79141,6 +83522,7 @@ list_instance_snapshots - `name` (`str`): - `statuses` (`List[str]`): - `type` (`str`): +- `ids` (`List[str]`): - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -79172,12 +83554,13 @@ async def list_instance_snapshots_with_http_info( name: Optional[StrictStr] = None, statuses: Optional[List[StrictStr]] = None, type: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Optional[List[StrictStr]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79194,6 +83577,7 @@ list_instance_snapshots - `name` (`str`): - `statuses` (`List[str]`): - `type` (`str`): +- `ids` (`List[str]`): - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -79225,12 +83609,13 @@ async def list_instance_snapshots_without_preload_content( name: Optional[StrictStr] = None, statuses: Optional[List[StrictStr]] = None, type: Optional[StrictStr] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Optional[List[StrictStr]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79247,6 +83632,7 @@ list_instance_snapshots - `name` (`str`): - `statuses` (`List[str]`): - `type` (`str`): +- `ids` (`List[str]`): - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -79300,12 +83686,12 @@ Do not edit the class manually. @validate_call async def create_snapshot( body: CreateSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79345,12 +83731,12 @@ Returns the result object. @validate_call async def create_snapshot_with_http_info( body: CreateSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79390,12 +83776,12 @@ Returns the result object. @validate_call async def create_snapshot_without_preload_content( body: CreateSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79435,12 +83821,12 @@ Returns the result object. @validate_call async def delete_snapshot( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79480,12 +83866,12 @@ Returns the result object. @validate_call async def delete_snapshot_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79525,12 +83911,12 @@ Returns the result object. @validate_call async def delete_snapshot_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79570,12 +83956,12 @@ Returns the result object. @validate_call async def get_snapshot( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79615,12 +84001,12 @@ Returns the result object. @validate_call async def get_snapshot_with_http_info( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79660,12 +84046,12 @@ Returns the result object. @validate_call async def get_snapshot_without_preload_content( id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79706,29 +84092,37 @@ Returns the result object. async def list_snapshots( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter by organization_id")] = None, + Field(description="(Optional) Filter by organization_id"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter by status - SNAPSHOT_STATUS_INVALID: zero value, invalid - SNAPSHOT_STATUS_CREATING: the snapshot is being created - SNAPSHOT_STATUS_AVAILABLE: the snapshot is complete and available - SNAPSHOT_STATUS_MIGRATING: the snapshot is being migrated - SNAPSHOT_STATUS_DELETING: the snapshot is being deleted - SNAPSHOT_STATUS_DELETED: the snapshot is deleted" - )] = None, + ), + ] = None, region: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the region")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on snapshot ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79745,6 +84139,7 @@ List all Snapshots - `organization_id` (`str`): (Optional) Filter by organization_id - `statuses` (`List[str]`): (Optional) Filter by status - SNAPSHOT_STATUS_INVALID: zero value, invalid - SNAPSHOT_STATUS_CREATING: the snapshot is being created - SNAPSHOT_STATUS_AVAILABLE: the snapshot is complete and available - SNAPSHOT_STATUS_MIGRATING: the snapshot is being migrated - SNAPSHOT_STATUS_DELETING: the snapshot is being deleted - SNAPSHOT_STATUS_DELETED: the snapshot is deleted - `region` (`str`): (Optional) A filter for the region +- `ids` (`List[str]`): (Optional) Filter on snapshot ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -79773,29 +84168,37 @@ Returns the result object. async def list_snapshots_with_http_info( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter by organization_id")] = None, + Field(description="(Optional) Filter by organization_id"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter by status - SNAPSHOT_STATUS_INVALID: zero value, invalid - SNAPSHOT_STATUS_CREATING: the snapshot is being created - SNAPSHOT_STATUS_AVAILABLE: the snapshot is complete and available - SNAPSHOT_STATUS_MIGRATING: the snapshot is being migrated - SNAPSHOT_STATUS_DELETING: the snapshot is being deleted - SNAPSHOT_STATUS_DELETED: the snapshot is deleted" - )] = None, + ), + ] = None, region: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the region")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on snapshot ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79812,6 +84215,7 @@ List all Snapshots - `organization_id` (`str`): (Optional) Filter by organization_id - `statuses` (`List[str]`): (Optional) Filter by status - SNAPSHOT_STATUS_INVALID: zero value, invalid - SNAPSHOT_STATUS_CREATING: the snapshot is being created - SNAPSHOT_STATUS_AVAILABLE: the snapshot is complete and available - SNAPSHOT_STATUS_MIGRATING: the snapshot is being migrated - SNAPSHOT_STATUS_DELETING: the snapshot is being deleted - SNAPSHOT_STATUS_DELETED: the snapshot is deleted - `region` (`str`): (Optional) A filter for the region +- `ids` (`List[str]`): (Optional) Filter on snapshot ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -79840,29 +84244,37 @@ Returns the result object. async def list_snapshots_without_preload_content( limit: Annotated[ Optional[StrictStr], - Field(description="(Optional) The number of items to return")] = None, + Field(description="(Optional) The number of items to return"), + ] = None, offset: Annotated[ Optional[StrictStr], - Field(description="(Optional) The offset in the list of item to return" - )] = None, + Field( + description="(Optional) The offset in the list of item to return"), + ] = None, organization_id: Annotated[ Optional[StrictStr], - Field(description="(Optional) Filter by organization_id")] = None, + Field(description="(Optional) Filter by organization_id"), + ] = None, statuses: Annotated[ Optional[List[StrictStr]], Field( description= "(Optional) Filter by status - SNAPSHOT_STATUS_INVALID: zero value, invalid - SNAPSHOT_STATUS_CREATING: the snapshot is being created - SNAPSHOT_STATUS_AVAILABLE: the snapshot is complete and available - SNAPSHOT_STATUS_MIGRATING: the snapshot is being migrated - SNAPSHOT_STATUS_DELETING: the snapshot is being deleted - SNAPSHOT_STATUS_DELETED: the snapshot is deleted" - )] = None, + ), + ] = None, region: Annotated[ Optional[StrictStr], Field(description="(Optional) A filter for the region")] = None, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + ids: Annotated[ + Optional[List[StrictStr]], + Field(description="(Optional) Filter on snapshot ids"), + ] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79879,6 +84291,7 @@ List all Snapshots - `organization_id` (`str`): (Optional) Filter by organization_id - `statuses` (`List[str]`): (Optional) Filter by status - SNAPSHOT_STATUS_INVALID: zero value, invalid - SNAPSHOT_STATUS_CREATING: the snapshot is being created - SNAPSHOT_STATUS_AVAILABLE: the snapshot is complete and available - SNAPSHOT_STATUS_MIGRATING: the snapshot is being migrated - SNAPSHOT_STATUS_DELETING: the snapshot is being deleted - SNAPSHOT_STATUS_DELETED: the snapshot is deleted - `region` (`str`): (Optional) A filter for the region +- `ids` (`List[str]`): (Optional) Filter on snapshot ids - `_request_timeout` (`int, tuple(int, int), optional`): timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of @@ -79908,12 +84321,12 @@ async def update_snapshot( id: Annotated[StrictStr, Field(description="The id of the snapshot")], body: UpdateSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -79956,12 +84369,12 @@ async def update_snapshot_with_http_info( id: Annotated[StrictStr, Field(description="The id of the snapshot")], body: UpdateSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -80004,12 +84417,12 @@ async def update_snapshot_without_preload_content( id: Annotated[StrictStr, Field(description="The id of the snapshot")], body: UpdateSnapshotRequest, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -80076,12 +84489,12 @@ Do not edit the class manually. @validate_call async def get_quotas( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -80121,12 +84534,12 @@ Returns the result object. @validate_call async def get_quotas_with_http_info( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, @@ -80166,12 +84579,12 @@ Returns the result object. @validate_call async def get_quotas_without_preload_content( organization_id: StrictStr, - _request_timeout: Union[None, Annotated[StrictFloat, - Field(gt=0)], - Tuple[Annotated[StrictFloat, - Field(gt=0)], - Annotated[StrictFloat, - Field(gt=0)]]] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, + Field(gt=0)]], + ] = None, _request_auth: Optional[Dict[StrictStr, Any]] = None, _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, diff --git a/docs/sandbox.md b/docs/sandbox.md index d5d1a9bc..1f86d940 100644 --- a/docs/sandbox.md +++ b/docs/sandbox.md @@ -1,1395 +1,2244 @@ - + -# koyeb/sandbox +# koyeb.sandbox Koyeb Sandbox - Interactive execution environment for running arbitrary code on Koyeb - + -# koyeb/sandbox.test\_utils +# koyeb.sandbox.sandbox - +Koyeb Sandbox - Python SDK for creating and managing Koyeb sandboxes + + -## TestCreateDockerSource Objects +## ProcessInfo Objects ```python -class TestCreateDockerSource(unittest.TestCase) +@dataclass +class ProcessInfo() ``` -Tests for create_docker_source entrypoint, command, and args support. +Type definition for process information returned by list_processes. - + -## TestBuildEgressPolicy Objects +#### id -```python -class TestBuildEgressPolicy(unittest.TestCase) -``` +Process ID (UUID string) -Tests for build_network_policy validation and normalization. + - +#### command -# koyeb/sandbox.test\_egress\_policy +The command that was executed - + -## TestCreateEgressWiring Objects +#### status -```python -class TestCreateEgressWiring(unittest.TestCase) -``` +Process status (e.g., "running", "completed") -Tests that Sandbox.create wires egress kwargs into the deployment definition. + - +#### pid -## TestUpdateNetworkPolicy Objects +OS process ID (if running) -```python -class TestUpdateNetworkPolicy(unittest.TestCase) -``` + -Tests for Sandbox.update_network_policy. +#### exit\_code - +Exit code (if completed) -## TestAsyncUpdateNetworkPolicy Objects + -```python -class TestAsyncUpdateNetworkPolicy(unittest.TestCase) -``` +#### started\_at -Tests for AsyncSandbox.update_network_policy. +ISO 8601 timestamp when process started - + -# koyeb/sandbox.exec +#### completed\_at -Command execution utilities for Koyeb Sandbox instances -Using SandboxClient HTTP API +ISO 8601 timestamp when process completed (if applicable) - + -## CommandStatus Objects +## ExposedPort Objects ```python -class CommandStatus(str, Enum) +@dataclass +class ExposedPort() ``` -Command execution status +Result of exposing a port via TCP proxy. - + -## CommandResult Objects +## Sandbox Objects ```python -@dataclass -class CommandResult() +class Sandbox() ``` -Result of a command execution using Koyeb API models +Synchronous sandbox for running code on Koyeb infrastructure. +Provides creation and deletion functionality with proper health polling. - + -#### success +#### id ```python @property -def success() -> bool +def id() -> str ``` -Check if command executed successfully +Get the service ID of the sandbox. - + -#### output +#### create ```python -@property -def output() -> str +@classmethod +def create(cls, + image: str = "koyeb/sandbox", + name: str = "quick-sandbox", + wait_ready: bool = True, + instance_type: str = "micro", + exposed_port_protocol: Optional[str] = None, + env: Optional[Dict[str, Any]] = None, + config_files: Optional[Dict[str, Any]] = None, + region: Optional[str] = None, + api_token: Optional[str] = None, + timeout: int = 300, + idle_timeout: int = 300, + enable_tcp_proxy: bool = False, + privileged: bool = False, + registry_secret: Optional[str] = None, + _experimental_enable_light_sleep: bool = False, + _experimental_deep_sleep_value: int = 3900, + delete_after_delay: int = 0, + delete_after_inactivity_delay: int = 0, + app_id: Optional[str] = None, + enable_mesh: Optional[bool] = None, + poll_interval: float = DEFAULT_POLL_INTERVAL, + entrypoint: Optional[List[str]] = None, + command: Optional[str] = None, + args: Optional[List[str]] = None, + host: Optional[str] = None, + block_network: bool = False, + outbound_allowlist: Optional[List[str]] = None, + snapshot: Optional[Union[str, "Snapshot"]] = None, + sandbox_secret: Optional[str] = None, + cleanup_on_failure: bool = True) -> Sandbox ``` -Get combined stdout and stderr output - - +Create a new sandbox instance. -## SandboxCommandError Objects +**Arguments**: -```python -class SandboxCommandError(SandboxError) -``` +- `image` - Docker image to use (default: koyeb/sandbox) +- `name` - Name of the sandbox +- `wait_ready` - Wait for sandbox to be ready (default: True) +- `instance_type` - Instance type (default: micro) +- `exposed_port_protocol` - Protocol to expose ports with ("http" or "http2"). + If None, defaults to "http". + If provided, must be one of "http" or "http2". +- `env` - Environment variables +- `config_files` - Config files to create in the sandbox, as a dictionary mapping + file paths to file contents. Values can be plain strings (default permissions 0644) + or ``ConfigFile`` instances for custom permissions + (e.g., {"/etc/myapp/config.yaml": "key: value", "/etc/myapp/cert.pem": ConfigFile(content="...", permissions="0600")}) +- `region` - Region to deploy to. Defaults to KOYEB_REGION env var, or "na" if not set. +- `api_token` - Koyeb API token (if None, will try to get from KOYEB_API_TOKEN env var) +- `timeout` - Timeout for sandbox creation in seconds +- `idle_timeout` - Sleep timeout in seconds. Behavior depends on _experimental_enable_light_sleep: + - If _experimental_enable_light_sleep is True: sets light_sleep value (deep_sleep=3900) + - If _experimental_enable_light_sleep is False: sets deep_sleep value + - If 0: disables scale-to-zero (keep always-on) +- `enable_tcp_proxy` - If True, enables TCP proxy for direct TCP access to port 3031 +- `privileged` - If True, run the container in privileged mode (default: False) +- `registry_secret` - Name of a Koyeb secret containing registry credentials for + pulling private images. Create the secret via Koyeb dashboard or CLI first. +- `_experimental_enable_light_sleep` - If True, uses idle_timeout for light_sleep and sets + deep_sleep=3900. If False, uses idle_timeout for deep_sleep (default: False) +- `delete_after_delay` - If >0, automatically delete the sandbox if there was no activity + after this many seconds since creation. +- `delete_after_inactivity_delay` - If >0, automatically delete the sandbox if service sleeps due to inactivity + after this many seconds. +- `app_id` - If provided, create the sandbox service in an existing app instead of creating a new one. +- `enable_mesh` - Mesh tri-state: None (default) = auto, True = enabled, False = disabled +- `poll_interval` - Time between health checks in seconds when wait_ready is True (default: 0.5) +- `entrypoint` - Override the default entrypoint of the Docker image (e.g., ["/bin/sh", "-c"]) +- `command` - Override the default command of the Docker image (e.g., "python app.py") +- `host` - Koyeb API host URL. If not provided, will try to get from KOYEB_API_HOST env var (defaults to https://app.koyeb.com) +- `block_network` - If True, block all outbound network access from the sandbox +- `outbound_allowlist` - List of IPs/CIDRs allowed as outbound destinations; + all other outbound traffic is blocked. Bare IPs are normalized to + /32 (IPv4) or /128 (IPv6). Mutually exclusive with block_network. +- `snapshot` - Optional. A Snapshot object or snapshot name/ID string to create the sandbox from. + If provided, the sandbox will be initialized from this snapshot. + Can be either a Snapshot object (e.g., snapshot=my_snapshot) or a snapshot name/ID string (e.g., snapshot="my snapshot"). +- `sandbox_secret` - Optional sandbox secret to use for executor authentication. If not provided, a new one will be generated. + -Raised when command execution fails +**Returns**: - +- `Sandbox` - A new Sandbox instance + -## SandboxExecutor Objects +**Raises**: -```python -class SandboxExecutor() -``` +- `ValueError` - If API token is not provided +- `SandboxTimeoutError` - If wait_ready is True and sandbox does not become ready within timeout +- `EgressPolicyError` - If both block_network and outbound_allowlist are passed, + or an allowlist entry is not a valid IP address or CIDR + -Synchronous command execution interface for Koyeb Sandbox instances. -Bound to a specific sandbox instance. +**Example**: -For async usage, use AsyncSandboxExecutor instead. + >>> # Public image (default) + >>> sandbox = Sandbox.create() + + >>> # Private image with registry secret + >>> sandbox = Sandbox.create( + ... image="ghcr.io/myorg/myimage:latest", + ... registry_secret="my-ghcr-secret" + ... ) + + >>> # Create from a Snapshot object + >>> from koyeb.sandbox import Snapshot + >>> snapshot = Snapshot.get("my-snapshot-id") + >>> sandbox = Sandbox.create(snapshot=snapshot) + + >>> # Create from a snapshot ID string + >>> sandbox = Sandbox.create(snapshot="my-snapshot-id") + + >>> # Create from a snapshot with custom parameters + >>> sandbox = Sandbox.create( + ... snapshot="my-snapshot-id", + ... image="python:3.12", + ... instance_type="nano", + ... env={"MY_VAR": "value"} + ... ) - + -#### \_\_call\_\_ +#### get\_from\_id ```python -def __call__(command: str, - cwd: Optional[str] = None, - env: Optional[Dict[str, str]] = None, - timeout: int = 30, - on_stdout: Optional[Callable[[str], None]] = None, - on_stderr: Optional[Callable[[str], None]] = None, - stream: bool = True) -> CommandResult +@classmethod +def get_from_id(cls, + id: str, + api_token: Optional[str] = None, + host: Optional[str] = None) -> "Sandbox" ``` -Execute a command in a shell synchronously. Supports streaming output via callbacks. +Get a sandbox by service ID. **Arguments**: -- `command` - Command to execute as a string (e.g., "python -c 'print(2+2)'") -- `cwd` - Working directory for the command -- `env` - Environment variables for the command -- `timeout` - Command timeout in seconds (enforced for HTTP requests) -- `on_stdout` - Optional callback for streaming stdout chunks -- `on_stderr` - Optional callback for streaming stderr chunks +- `id` - Service ID of the sandbox +- `api_token` - Koyeb API token (if None, will try to get from KOYEB_API_TOKEN env var) +- `host` - Koyeb API host URL. If not provided, will try to get from KOYEB_API_HOST env var (defaults to https://app.koyeb.com) **Returns**: -- `CommandResult` - Result of the command execution +- `Sandbox` - The Sandbox instance -**Example**: - - ```python - # Synchronous execution - result = sandbox.exec("echo hello") +**Raises**: - # With streaming callbacks - result = sandbox.exec( - "echo hello; sleep 1; echo world", - on_stdout=lambda data: print(f"OUT: {data}"), - on_stderr=lambda data: print(f"ERR: {data}"), - ) - ``` +- `ValueError` - If API token is not provided or id is invalid +- `SandboxError` - If sandbox is not found or retrieval fails - + -## AsyncSandboxExecutor Objects +#### list ```python -class AsyncSandboxExecutor(SandboxExecutor) +@classmethod +def list(cls, + app_id: Optional[str] = None, + name: Optional[str] = None, + api_token: Optional[str] = None, + host: Optional[str] = None) -> List["Sandbox"] ``` -Async command execution interface for Koyeb Sandbox instances. -Bound to a specific sandbox instance. +List sandbox services. -Inherits from SandboxExecutor and provides async command execution -using native async I/O via AsyncSandboxClient. +Paginates services of type SANDBOX (100 per page, mirroring the CLI). +Returns lazily-connected handles: they carry no executor secret, so +connected operations raise NoSandboxSecretError — use +``Sandbox.get_from_id(handle.id)`` for a connected handle. + +**Arguments**: - +- `app_id` - Optional app filter +- `name` - Optional name filter +- `api_token` - Koyeb API token (defaults to KOYEB_API_TOKEN env var) +- `host` - Koyeb API host (defaults to KOYEB_API_HOST env var) + -#### \_\_call\_\_ +**Returns**: + +- `List[Sandbox]` - Lazy handles for every sandbox service + + + +#### snapshot ```python -async def __call__(command: str, - cwd: Optional[str] = None, - env: Optional[Dict[str, str]] = None, - timeout: int = 30, - on_stdout: Optional[Callable[[str], None]] = None, - on_stderr: Optional[Callable[[str], None]] = None, - stream: bool = True) -> CommandResult +def snapshot(name: str, + snapshot_type: Optional["SnapshotType"] = None, + wait_available: bool = True, + timeout: int = 600) -> "Snapshot" ``` -Execute a command in a shell asynchronously. Supports streaming output via callbacks. +Create a snapshot of this sandbox. + +Captures the current state of the sandbox's filesystem (and optionally +running processes for FULL type) so it can be restored later. **Arguments**: -- `command` - Command to execute as a string (e.g., "python -c 'print(2+2)'") -- `cwd` - Working directory for the command -- `env` - Environment variables for the command -- `timeout` - Command timeout in seconds (enforced for HTTP requests) -- `on_stdout` - Optional callback for streaming stdout chunks -- `on_stderr` - Optional callback for streaming stderr chunks +- `name` - Name for the snapshot +- `snapshot_type` - Type of snapshot to create (FILESYSTEM or FULL). + Defaults to FILESYSTEM. +- `wait_available` - Whether to wait for snapshot to become available +- `timeout` - Timeout in seconds for waiting **Returns**: -- `CommandResult` - Result of the command execution +- `Snapshot` - The created snapshot object -**Example**: +**Raises**: - ```python - # Async execution - result = await sandbox.exec("echo hello") +- `SandboxError` - If snapshot creation fails - # With streaming callbacks - result = await sandbox.exec( - "echo hello; sleep 1; echo world", - on_stdout=lambda data: print(f"OUT: {data}"), - on_stderr=lambda data: print(f"ERR: {data}"), - ) - ``` + - +#### create\_from\_snapshot -# koyeb/sandbox.filesystem +```python +@classmethod +def create_from_snapshot(cls, + snapshot: Union["Snapshot", str], + name: Optional[str] = None, + wait_ready: bool = True, + timeout: int = 300, + **create_kwargs) -> "Sandbox" +``` -Filesystem operations for Koyeb Sandbox instances -Using SandboxClient HTTP API +Create a new sandbox from a snapshot. - +**Arguments**: -## SandboxFilesystemError Objects +- `snapshot` - Snapshot object or snapshot ID string +- `name` - Name for the new sandbox +- `wait_ready` - Whether to wait for sandbox to be ready +- `timeout` - Timeout in seconds +- `**create_kwargs` - Additional arguments to pass to create() + -```python -class SandboxFilesystemError(SandboxError) -``` +**Returns**: -Base exception for filesystem operations +- `Sandbox` - A new sandbox instance - + -## SandboxFileNotFoundError Objects +#### template ```python -class SandboxFileNotFoundError(SandboxFilesystemError) +@classmethod +def template(cls, + name: str, + image: str, + workdir: Optional[str] = None, + api_token: Optional[str] = None, + host: Optional[str] = None, + delete_builder: bool = True) -> "DeclarativeSnapshot" ``` -Raised when file or directory not found - - +Create a declarative snapshot builder. -## SandboxFileExistsError Objects +Use this to build a reusable snapshot by declaratively defining +the sandbox environment (files, packages, etc.) and then building +a snapshot that can be used to spawn pre-configured sandboxes. -```python -class SandboxFileExistsError(SandboxFilesystemError) -``` +**Arguments**: -Raised when file already exists +- `name` - Name for the template +- `image` - Docker image to use +- `workdir` - Working directory in the sandbox +- `api_token` - Koyeb API token +- `host` - Koyeb API host +- `delete_builder` - Whether to delete the builder sandbox after creating the snapshot (default: True) + - +**Returns**: -## FileInfo Objects +- `DeclarativeSnapshot` - Fluent builder for creating snapshots + -```python -@dataclass -class FileInfo() -``` +**Example**: -File information + snapshot = ( + Sandbox.template("python-ci", image="python:3.12", workdir="/workspace") + .file("requirements.txt", "pytest\nrequests") + .run("pip install -r requirements.txt") + .build(snapshot_name="python-ci-env") + ) + + sbx = snapshot.spawn(name="test-runner") - + -## SandboxFilesystem Objects +#### wait\_ready ```python -class SandboxFilesystem() +def wait_ready(timeout: int = DEFAULT_INSTANCE_WAIT_TIMEOUT, + poll_interval: Optional[float] = None) -> bool ``` -Synchronous filesystem operations for Koyeb Sandbox instances. -Using SandboxClient HTTP API. - -For async usage, use AsyncSandboxFilesystem instead. +Wait for sandbox to become ready with exponential backoff polling. - +First waits for the deployment status to become HEALTHY, then polls the +sandbox health endpoint to confirm the executor is responsive. -#### write\_file +Starts polling at 0.1s intervals, doubling each time up to poll_interval. -```python -def write_file(path: str, - content: Union[str, bytes], - encoding: str = "utf-8") -> None -``` +**Arguments**: -Write content to a file synchronously. +- `timeout` - Maximum time to wait in seconds +- `poll_interval` - Maximum time between health checks in seconds (defaults to instance poll_interval) + -**Arguments**: +**Returns**: -- `path` - Absolute path to the file -- `content` - Content to write (string or bytes) -- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary data. +- `bool` - True if sandbox became ready, False if timeout - + -#### read\_file +#### wait\_tcp\_proxy\_ready ```python -def read_file(path: str, encoding: str = "utf-8") -> FileInfo +def wait_tcp_proxy_ready(timeout: int = DEFAULT_INSTANCE_WAIT_TIMEOUT, + poll_interval: Optional[float] = None) -> bool ``` -Read a file from the sandbox synchronously. +Wait for TCP proxy to become ready and available. + +Polls the deployment metadata with exponential backoff until the TCP proxy +information is available. Starts at 0.1s intervals, doubling up to poll_interval. **Arguments**: -- `path` - Absolute path to the file -- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary data, - which will decode the base64 content and return bytes. +- `timeout` - Maximum time to wait in seconds +- `poll_interval` - Maximum time between checks in seconds (defaults to instance poll_interval) **Returns**: -- `FileInfo` - Object with content (str or bytes if base64) and encoding +- `bool` - True if TCP proxy became ready, False if timeout - + -#### mkdir +#### delete ```python -def mkdir(path: str) -> None +def delete() -> None ``` -Create a directory synchronously. - -Note: Parent directories are always created automatically by the API. - -**Arguments**: +Delete the sandbox instance. -- `path` - Absolute path to the directory +Deletes the whole app for SDK-created sandboxes; only the service +when the sandbox lives in a caller-provided app. - + -#### list\_dir +#### get\_domain ```python -def list_dir(path: str = ".") -> List[str] +def get_domain() -> Optional[str] ``` -List contents of a directory synchronously. - -**Arguments**: +Get the public domain of the sandbox. -- `path` - Path to the directory (default: current directory) - +Returns the domain (e.g., "app-name-org.koyeb.app/r/routing_key/" or +"app-name-org.koyeb.app") without protocol. To get the full URL with protocol, +use sandbox._get_url() **Returns**: -- `List[str]` - Names of files and directories within the specified path. +- `Optional[str]` - The domain or None if unavailable - + -#### delete\_file +#### get\_tcp\_proxy\_info ```python -def delete_file(path: str) -> None +def get_tcp_proxy_info() -> Optional[tuple[str, int]] ``` -Delete a file synchronously. +Get the TCP proxy host and port for the sandbox. -**Arguments**: +Returns the TCP proxy host and port as a tuple (host, port) for direct TCP access to port 3031. +This is only available if enable_tcp_proxy=True was set when creating the sandbox. -- `path` - Absolute path to the file +**Returns**: + + Optional[tuple[str, int]]: A tuple of (host, port) or None if unavailable - + -#### delete\_dir +#### is\_healthy ```python -def delete_dir(path: str) -> None +def is_healthy() -> bool ``` -Delete a directory synchronously. - -**Arguments**: +Check if sandbox is healthy and ready for operations. -- `path` - Absolute path to the directory +Raises SandboxDeploymentError when the deployment reached a terminal +state (e.g. STOPPED) — classification fails closed. - + -#### rename\_file +#### filesystem ```python -def rename_file(old_path: str, new_path: str) -> None +@property +def filesystem() -> "SandboxFilesystem" ``` -Rename a file synchronously. - -**Arguments**: - -- `old_path` - Current file path -- `new_path` - New file path +Get filesystem operations interface - + -#### move\_file +#### exec ```python -def move_file(source_path: str, destination_path: str) -> None +@property +def exec() -> "SandboxExecutor" ``` -Move a file to a different directory synchronously. - -**Arguments**: - -- `source_path` - Current file path -- `destination_path` - Destination path +Get command execution interface - + -#### write\_files +#### expose\_port ```python -def write_files(files: List[Dict[str, str]]) -> None +def expose_port(port: int) -> ExposedPort ``` -Write multiple files in a single operation synchronously. +Expose a port to external connections via TCP proxy. + +Binds the specified internal port to the TCP proxy, allowing external +connections to reach services running on that port inside the sandbox. +Automatically unbinds any existing port before binding the new one. **Arguments**: -- `files` - List of dictionaries, each with 'path', 'content', and optional 'encoding'. +- `port` - The internal port number to expose (must be a valid port number between 1 and 65535) + - +**Returns**: -#### exists +- `ExposedPort` - An object with `port` and `exposed_at` attributes: + - port: The exposed port number + - exposed_at: The full URL with https:// protocol (e.g., "https://app-name-org.koyeb.app") + -```python -def exists(path: str) -> bool -``` +**Raises**: -Check if file/directory exists synchronously +- `ValueError` - If port is not in valid range [1, 65535] +- `SandboxError` - If the port binding operation fails + - +**Notes**: -#### is\_file + - Only one port can be exposed at a time + - Any existing port binding is automatically unbound before binding the new port + - The port must be available and accessible within the sandbox environment + - The TCP proxy is accessed via get_tcp_proxy_info() which returns (host, port) + -```python -def is_file(path: str) -> bool -``` +**Example**: -Check if path is a file synchronously + >>> result = sandbox.expose_port(8080) + >>> result.port + 8080 + >>> result.exposed_at + 'https://app-name-org.koyeb.app' - + -#### is\_dir +#### unexpose\_port ```python -def is_dir(path: str) -> bool +def unexpose_port() -> None ``` -Check if path is a directory synchronously - - - -#### upload\_file - -```python -def upload_file(local_path: str, - remote_path: str, - encoding: str = "utf-8") -> None -``` +Unexpose a port from external connections. -Upload a local file to the sandbox synchronously. +Removes the TCP proxy port binding, stopping traffic forwarding to the +previously bound port. -**Arguments**: +**Raises**: -- `local_path` - Path to the local file -- `remote_path` - Destination path in the sandbox -- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary files. +- `SandboxError` - If the port unbinding operation fails -**Raises**: +**Notes**: -- `SandboxFileNotFoundError` - If local file doesn't exist -- `UnicodeDecodeError` - If file cannot be decoded with specified encoding + - After unexposing, the TCP proxy will no longer forward traffic + - Safe to call even if no port is currently bound - + -#### download\_file +#### launch\_process ```python -def download_file(remote_path: str, - local_path: str, - encoding: str = "utf-8") -> None +def launch_process(cmd: str, + cwd: Optional[str] = None, + env: Optional[Dict[str, str]] = None) -> str ``` -Download a file from the sandbox to a local path synchronously. +Launch a background process in the sandbox. + +Starts a long-running background process that continues executing even after +the method returns. Use this for servers, workers, or other long-running tasks. **Arguments**: -- `remote_path` - Path to the file in the sandbox -- `local_path` - Destination path on the local filesystem -- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary files. +- `cmd` - The shell command to execute as a background process +- `cwd` - Optional working directory for the process +- `env` - Optional environment variables to set/override for the process + + +**Returns**: + +- `str` - The unique process ID (UUID string) that can be used to manage the process **Raises**: -- `SandboxFileNotFoundError` - If remote file doesn't exist +- `SandboxError` - If the process launch fails + - +**Example**: -#### ls + >>> process_id = sandbox.launch_process("python -u server.py") + >>> print(f"Started process: {process_id}") + + + +#### kill\_process ```python -def ls(path: str = ".") -> List[str] +def kill_process(process_id: str) -> None ``` -List directory contents synchronously. +Kill a background process by its ID. + +Terminates a running background process. This sends a SIGTERM signal to the process, +allowing it to clean up gracefully. If the process doesn't terminate within a timeout, +it will be forcefully killed with SIGKILL. **Arguments**: -- `path` - Path to list +- `process_id` - The unique process ID (UUID string) to kill -**Returns**: - - List of file/directory names - - - -#### rm - -```python -def rm(path: str, recursive: bool = False) -> None -``` +**Raises**: -Remove file or directory synchronously. +- `SandboxError` - If the process kill operation fails + -**Arguments**: +**Example**: -- `path` - Path to remove -- `recursive` - Remove recursively + >>> sandbox.kill_process("550e8400-e29b-41d4-a716-446655440000") - + -#### open +#### list\_processes ```python -def open(path: str, mode: str = "r", encoding: str = "utf-8") -> SandboxFileIO +def list_processes() -> List[ProcessInfo] ``` -Open a file in the sandbox synchronously. - -**Arguments**: +List all background processes. -- `path` - Path to the file -- `mode` - Open mode ('r', 'w', 'a', etc.) -- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary data. - +Returns information about all currently running and recently completed background +processes. This includes both active processes and processes that have completed +(which remain in memory until server restart). **Returns**: -- `SandboxFileIO` - File handle - - - -## AsyncSandboxFilesystem Objects - -```python -class AsyncSandboxFilesystem(SandboxFilesystem) -``` - -Async filesystem operations for Koyeb Sandbox instances. -Uses native async I/O via AsyncSandboxClient. - - - -#### write\_file +- `List[ProcessInfo]` - List of process objects, each containing: + - id: Process ID (UUID string) + - command: The command that was executed + - status: Process status (e.g., "running", "completed") + - pid: OS process ID (if running) + - exit_code: Exit code (if completed) + - started_at: ISO 8601 timestamp when process started + - completed_at: ISO 8601 timestamp when process completed (if applicable) + -```python -async def write_file(path: str, - content: Union[str, bytes], - encoding: str = "utf-8") -> None -``` +**Raises**: -Write content to a file asynchronously. +- `SandboxError` - If listing processes fails + -**Arguments**: +**Example**: -- `path` - Absolute path to the file -- `content` - Content to write (string or bytes) -- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary data. + >>> processes = sandbox.list_processes() + >>> for process in processes: + ... print(f"{process.id}: {process.command} - {process.status}") - + -#### read\_file +#### kill\_all\_processes ```python -async def read_file(path: str, encoding: str = "utf-8") -> FileInfo +def kill_all_processes() -> int ``` -Read a file from the sandbox asynchronously. - -**Arguments**: +Kill all running background processes. -- `path` - Absolute path to the file -- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary data, - which will decode the base64 content and return bytes. - +Convenience method that lists all processes and kills them all. This is useful +for cleanup operations. **Returns**: -- `FileInfo` - Object with content (str or bytes if base64) and encoding - - - -#### mkdir - -```python -async def mkdir(path: str) -> None -``` +- `int` - The number of processes that were killed + -Create a directory asynchronously. +**Raises**: -Note: Parent directories are always created automatically by the API. +- `SandboxError` - If listing or killing processes fails + -**Arguments**: +**Example**: -- `path` - Absolute path to the directory + >>> count = sandbox.kill_all_processes() + >>> print(f"Killed {count} processes") - + -#### list\_dir +#### update\_lifecycle ```python -async def list_dir(path: str = ".") -> List[str] +def update_lifecycle(delete_after_delay: Optional[int] = None, + delete_after_inactivity: Optional[int] = None) -> None ``` -List contents of a directory asynchronously. +Update the sandbox's life cycle settings. **Arguments**: -- `path` - Path to the directory (default: current directory) +- `delete_after_delay` - If >0, automatically delete the sandbox if there was no activity + after this many seconds since creation. +- `delete_after_inactivity` - If >0, automatically delete the sandbox if service sleeps due to inactivity + after this many seconds. -**Returns**: - -- `List[str]` - Names of files and directories within the specified path. - - - -#### delete\_file - -```python -async def delete_file(path: str) -> None -``` +**Raises**: -Delete a file asynchronously. +- `SandboxError` - If updating life cycle fails + -**Arguments**: +**Example**: -- `path` - Absolute path to the file + >>> sandbox.update_life_cycle(delete_after_delay=600, delete_after_inactivity=300) - + -#### delete\_dir +#### update\_network\_policy ```python -async def delete_dir(path: str) -> None +def update_network_policy( + block_network: bool = False, + outbound_allowlist: Optional[List[str]] = None) -> None ``` -Delete a directory asynchronously. - -**Arguments**: - -- `path` - Absolute path to the directory - - - -#### rename\_file - -```python -async def rename_file(old_path: str, new_path: str) -> None -``` +Update the sandbox's network policy. -Rename a file asynchronously. +Warning: applying a new network policy triggers a redeployment of the +sandbox service. The sandbox is restarted and any in-memory or +non-persisted state is lost. This method does not wait for the +redeployment to finish; it repoints the sandbox at the new deployment +and clears cached connection state, so call wait_ready() afterwards to +block until the replacement deployment is healthy before issuing further +operations. **Arguments**: -- `old_path` - Current file path -- `new_path` - New file path - - - -#### move\_file +- `block_network` - If True, block all outbound network access from the sandbox +- `outbound_allowlist` - List of IPs/CIDRs allowed as outbound destinations; + all other outbound traffic is blocked. Bare IPs are normalized to + /32 (IPv4) or /128 (IPv6). Mutually exclusive with block_network. + + With both arguments unset, the network policy is reset to the + platform default (unrestricted outbound access). + -```python -async def move_file(source_path: str, destination_path: str) -> None -``` +**Raises**: -Move a file to a different directory asynchronously. +- `EgressPolicyError` - If both block_network and outbound_allowlist are + passed, or an allowlist entry is not a valid IP address or CIDR +- `SandboxError` - If updating the network policy fails + -**Arguments**: +**Example**: -- `source_path` - Current file path -- `destination_path` - Destination path + >>> sandbox.update_network_policy(block_network=True) + >>> sandbox.update_network_policy(outbound_allowlist=["10.0.0.0/8", "1.2.3.4"]) + >>> sandbox.update_network_policy() # reset to unrestricted - + -#### write\_files +#### \_\_enter\_\_ ```python -async def write_files(files: List[Dict[str, str]]) -> None +def __enter__() -> "Sandbox" ``` -Write multiple files in a single operation asynchronously. - -**Arguments**: - -- `files` - List of dictionaries, each with 'path', 'content', and optional 'encoding'. +Context manager entry - returns self. - + -#### exists +#### \_\_exit\_\_ ```python -async def exists(path: str) -> bool +def __exit__(exc_type, exc_val, exc_tb) -> None ``` -Check if file/directory exists asynchronously +Context manager exit - automatically deletes the sandbox. - + -#### is\_file +## AsyncSandbox Objects ```python -async def is_file(path: str) -> bool +class AsyncSandbox(Sandbox) ``` -Check if path is a file asynchronously +Async sandbox for running code on Koyeb infrastructure. +Inherits from Sandbox and provides native async implementations. - + -#### is\_dir +#### get\_from\_id ```python -async def is_dir(path: str) -> bool +@classmethod +async def get_from_id(cls, + id: str, + api_token: Optional[str] = None, + host: Optional[str] = None) -> "AsyncSandbox" ``` -Check if path is a directory asynchronously - - - -#### upload\_file +Get a sandbox by service ID asynchronously. -```python -async def upload_file(local_path: str, - remote_path: str, - encoding: str = "utf-8") -> None -``` +**Arguments**: -Upload a local file to the sandbox asynchronously. +- `id` - Service ID of the sandbox +- `api_token` - Koyeb API token (if None, will try to get from KOYEB_API_TOKEN env var) +- `host` - Koyeb API host URL. If not provided, will try to get from KOYEB_API_HOST env var (defaults to https://app.koyeb.com) + -**Arguments**: +**Returns**: -- `local_path` - Path to the local file -- `remote_path` - Destination path in the sandbox -- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary files. +- `AsyncSandbox` - The AsyncSandbox instance **Raises**: -- `SandboxFileNotFoundError` - If local file doesn't exist -- `UnicodeDecodeError` - If file cannot be decoded with specified encoding +- `ValueError` - If API token is not provided or id is invalid +- `SandboxError` - If sandbox is not found or retrieval fails - + -#### download\_file +#### create ```python -async def download_file(remote_path: str, - local_path: str, - encoding: str = "utf-8") -> None +@classmethod +async def create(cls, + image: str = "koyeb/sandbox", + name: str = "quick-sandbox", + wait_ready: bool = True, + instance_type: str = "micro", + exposed_port_protocol: Optional[str] = None, + env: Optional[Dict[str, Any]] = None, + config_files: Optional[Dict[str, Any]] = None, + region: Optional[str] = None, + api_token: Optional[str] = None, + timeout: int = 300, + idle_timeout: int = 300, + enable_tcp_proxy: bool = False, + privileged: bool = False, + registry_secret: Optional[str] = None, + _experimental_enable_light_sleep: bool = False, + _experimental_deep_sleep_value: int = 3900, + delete_after_delay: int = 0, + delete_after_inactivity_delay: int = 0, + app_id: Optional[str] = None, + enable_mesh: Optional[bool] = None, + poll_interval: float = DEFAULT_POLL_INTERVAL, + entrypoint: Optional[List[str]] = None, + command: Optional[str] = None, + args: Optional[List[str]] = None, + host: Optional[str] = None, + block_network: bool = False, + outbound_allowlist: Optional[List[str]] = None, + snapshot: Optional[Union[str, "Snapshot"]] = None, + sandbox_secret: Optional[str] = None, + cleanup_on_failure: bool = True) -> AsyncSandbox ``` -Download a file from the sandbox to a local path asynchronously. +Create a new sandbox instance with async support. **Arguments**: -- `remote_path` - Path to the file in the sandbox -- `local_path` - Destination path on the local filesystem -- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary files. +- `image` - Docker image to use (default: koyeb/sandbox) +- `name` - Name of the sandbox +- `wait_ready` - Wait for sandbox to be ready (default: True) +- `instance_type` - Instance type (default: micro) +- `exposed_port_protocol` - Protocol to expose ports with ("http" or "http2"). + If None, defaults to "http". + If provided, must be one of "http" or "http2". +- `env` - Environment variables +- `config_files` - Config files to create in the sandbox, as a dictionary mapping + file paths to file contents. Values can be plain strings (default permissions 0644) + or ``ConfigFile`` instances for custom permissions + (e.g., {"/etc/myapp/config.yaml": "key: value", "/etc/myapp/cert.pem": ConfigFile(content="...", permissions="0600")}) +- `region` - Region to deploy to. Defaults to KOYEB_REGION env var, or "na" if not set. +- `api_token` - Koyeb API token (if None, will try to get from KOYEB_API_TOKEN env var) +- `timeout` - Timeout for sandbox creation in seconds +- `idle_timeout` - Sleep timeout in seconds. Behavior depends on _experimental_enable_light_sleep: + - If _experimental_enable_light_sleep is True: sets light_sleep value (deep_sleep uses _experimental_deep_sleep_value) + - If _experimental_enable_light_sleep is False: sets deep_sleep value + - If 0: disables scale-to-zero (keep always-on) +- `enable_tcp_proxy` - If True, enables TCP proxy for direct TCP access to port 3031 +- `privileged` - If True, run the container in privileged mode (default: False) +- `registry_secret` - Name of a Koyeb secret containing registry credentials for + pulling private images. Create the secret via Koyeb dashboard or CLI first. +- `_experimental_enable_light_sleep` - If True, uses idle_timeout for light_sleep and configurable + deep_sleep (default: False) +- `_experimental_deep_sleep_value` - Number of seconds for deep sleep when light sleep is enabled (default: 3900). + Only used if _experimental_enable_light_sleep is True +- `delete_after_delay` - If >0, automatically delete the sandbox if there was no activity + after this many seconds since creation. +- `delete_after_inactivity_delay` - If >0, automatically delete the sandbox if service sleeps due to inactivity + after this many seconds. +- `app_id` - If provided, create the sandbox service in an existing app instead of creating a new one. +- `enable_mesh` - Mesh tri-state: None (default) = auto, True = enabled, False = disabled +- `poll_interval` - Time between health checks in seconds when wait_ready is True (default: 0.5) +- `entrypoint` - Override the default entrypoint of the Docker image (e.g., ["/bin/sh", "-c"]) +- `command` - Override the default command of the Docker image (e.g., "python app.py") +- `host` - Koyeb API host URL. If not provided, will try to get from KOYEB_API_HOST env var (defaults to https://app.koyeb.com) +- `block_network` - If True, block all outbound network access from the sandbox +- `outbound_allowlist` - List of IPs/CIDRs allowed as outbound destinations; + all other outbound traffic is blocked. Bare IPs are normalized to + /32 (IPv4) or /128 (IPv6). Mutually exclusive with block_network. +- `snapshot` - Optional. A Snapshot object or snapshot name/ID string to create the sandbox from. + If provided, the sandbox will be initialized from this snapshot. + Can be either a Snapshot object (e.g., snapshot=my_snapshot) or a snapshot name/ID string (e.g., snapshot="my snapshot"). +- `sandbox_secret` - Optional sandbox secret to use for executor authentication. If not provided, a new one will be generated. + + +**Returns**: + +- `AsyncSandbox` - A new AsyncSandbox instance **Raises**: -- `SandboxFileNotFoundError` - If remote file doesn't exist +- `ValueError` - If API token is not provided +- `SandboxTimeoutError` - If wait_ready is True and sandbox does not become ready within timeout +- `EgressPolicyError` - If both block_network and outbound_allowlist are passed, + or an allowlist entry is not a valid IP address or CIDR - + -#### ls +#### list ```python -async def ls(path: str = ".") -> List[str] +@classmethod +async def list(cls, + app_id: Optional[str] = None, + name: Optional[str] = None, + api_token: Optional[str] = None, + host: Optional[str] = None) -> List["AsyncSandbox"] ``` -List directory contents asynchronously. +List sandbox services (async twin of :meth:`Sandbox.list`). + +Returns lazily-connected handles without executor secrets; use +``AsyncSandbox.get_from_id(handle.id)`` for a connected handle. + + + +#### wait\_ready + +```python +async def wait_ready(timeout: int = DEFAULT_INSTANCE_WAIT_TIMEOUT, + poll_interval: Optional[float] = None) -> bool +``` + +Wait for sandbox to become ready with exponential backoff async polling. + +First waits for the deployment status to become HEALTHY, then polls the +sandbox health endpoint to confirm the executor is responsive. + +Starts polling at 0.1s intervals, doubling each time up to poll_interval. **Arguments**: -- `path` - Path to list +- `timeout` - Maximum time to wait in seconds +- `poll_interval` - Maximum time between health checks in seconds (defaults to instance poll_interval) **Returns**: - List of file/directory names +- `bool` - True if sandbox became ready, False if timeout - + -#### rm +#### wait\_tcp\_proxy\_ready ```python -async def rm(path: str, recursive: bool = False) -> None +async def wait_tcp_proxy_ready(timeout: int = DEFAULT_INSTANCE_WAIT_TIMEOUT, + poll_interval: Optional[float] = None) -> bool ``` -Remove file or directory asynchronously. +Wait for TCP proxy to become ready and available asynchronously. + +Polls the deployment metadata with exponential backoff until the TCP proxy +information is available. Starts at 0.1s intervals, doubling up to poll_interval. **Arguments**: -- `path` - Path to remove -- `recursive` - Remove recursively +- `timeout` - Maximum time to wait in seconds +- `poll_interval` - Maximum time between checks in seconds (defaults to instance poll_interval) + - +**Returns**: -#### open +- `bool` - True if TCP proxy became ready, False if timeout + + + +#### delete ```python -def open(path: str, - mode: str = "r", - encoding: str = "utf-8") -> AsyncSandboxFileIO +async def delete() -> None ``` -Open a file in the sandbox asynchronously. +Delete the sandbox instance asynchronously. + +Deletes the whole app for SDK-created sandboxes; only the service +when the sandbox lives in a caller-provided app. + + + +#### snapshot + +```python +async def snapshot(name: str, + snapshot_type: Optional["SnapshotType"] = None, + wait_available: bool = True, + timeout: int = 600) -> "Snapshot" +``` + +Create a snapshot of this sandbox asynchronously. + +Captures the current state of the sandbox's filesystem (and optionally +running processes for FULL type) so it can be restored later. **Arguments**: -- `path` - Path to the file -- `mode` - Open mode ('r', 'w', 'a', etc.) -- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary data. +- `name` - Name for the snapshot +- `snapshot_type` - Type of snapshot to create (FILESYSTEM or FULL). + Defaults to FILESYSTEM. +- `wait_available` - Whether to wait for snapshot to become available +- `timeout` - Timeout in seconds for waiting **Returns**: -- `AsyncSandboxFileIO` - Async file handle +- `Snapshot` - The created snapshot object + - +**Raises**: -## SandboxFileIO Objects +- `SandboxError` - If snapshot creation fails + + + +#### create\_from\_snapshot ```python -class SandboxFileIO() +@classmethod +async def create_from_snapshot(cls, + snapshot: Union["Snapshot", str], + name: Optional[str] = None, + wait_ready: bool = True, + timeout: int = 300, + **create_kwargs) -> "AsyncSandbox" ``` -Synchronous file I/O handle for sandbox files +Create a new async sandbox from a snapshot. - +**Arguments**: -#### read +- `snapshot` - Snapshot object or snapshot ID string +- `name` - Name for the new sandbox +- `wait_ready` - Whether to wait for sandbox to be ready +- `timeout` - Timeout in seconds +- `**create_kwargs` - Additional arguments to pass to create() + -```python -def read() -> Union[str, bytes] -``` +**Returns**: -Read file content synchronously +- `AsyncSandbox` - A new async sandbox instance - + -#### write +#### is\_healthy ```python -def write(content: Union[str, bytes]) -> None +async def is_healthy() -> bool ``` -Write content to file synchronously +Check if sandbox is healthy and ready for operations asynchronously. - +Raises SandboxDeploymentError when the deployment reached a terminal +state (e.g. STOPPED) — classification fails closed. -#### close + + +#### exec ```python -def close() -> None +@property +def exec() -> "AsyncSandboxExecutor" ``` -Close the file +Get async command execution interface - + -## AsyncSandboxFileIO Objects +#### filesystem ```python -class AsyncSandboxFileIO() +@property +def filesystem() -> "AsyncSandboxFilesystem" ``` -Async file I/O handle for sandbox files +Get filesystem operations interface - + -#### read +#### expose\_port ```python -async def read() -> Union[str, bytes] +async def expose_port(port: int) -> ExposedPort ``` -Read file content asynchronously +Expose a port to external connections via TCP proxy asynchronously. - + -#### write +#### unexpose\_port ```python -async def write(content: Union[str, bytes]) -> None +async def unexpose_port() -> None ``` -Write content to file asynchronously +Unexpose a port from external connections asynchronously. - + -#### close +#### launch\_process ```python -def close() -> None +async def launch_process(cmd: str, + cwd: Optional[str] = None, + env: Optional[Dict[str, str]] = None) -> str ``` -Close the file +Launch a background process in the sandbox asynchronously. - + -# koyeb/sandbox.sandbox +#### kill\_process -Koyeb Sandbox - Python SDK for creating and managing Koyeb sandboxes +```python +async def kill_process(process_id: str) -> None +``` + +Kill a background process by its ID asynchronously. - + -## ProcessInfo Objects +#### list\_processes ```python -@dataclass -class ProcessInfo() +async def list_processes() -> List[ProcessInfo] ``` -Type definition for process information returned by list_processes. - - +List all background processes asynchronously. -#### id + -Process ID (UUID string) +#### kill\_all\_processes - +```python +async def kill_all_processes() -> int +``` -#### command +Kill all running background processes asynchronously. -The command that was executed + - +#### update\_lifecycle -#### status +```python +async def update_lifecycle( + delete_after_delay: Optional[int] = None, + delete_after_inactivity: Optional[int] = None) -> None +``` -Process status (e.g., "running", "completed") +Update the sandbox's life cycle settings asynchronously. - + -#### pid +#### update\_network\_policy -OS process ID (if running) +```python +async def update_network_policy( + block_network: bool = False, + outbound_allowlist: Optional[List[str]] = None) -> None +``` - +Update the sandbox's network policy asynchronously. -#### exit\_code +Warning: applying a new network policy triggers a redeployment of the +sandbox service. The sandbox is restarted and any in-memory or +non-persisted state is lost. This method does not wait for the +redeployment to finish; it repoints the sandbox at the new deployment +and clears cached connection state, so call wait_ready() afterwards to +block until the replacement deployment is healthy before issuing further +operations. -Exit code (if completed) +See Sandbox.update_network_policy for full documentation. - +**Raises**: -#### started\_at +- `EgressPolicyError` - If both block_network and outbound_allowlist are + passed, or an allowlist entry is not a valid IP address or CIDR +- `SandboxError` - If updating the network policy fails -ISO 8601 timestamp when process started + - +#### \_\_aenter\_\_ -#### completed\_at +```python +async def __aenter__() -> "AsyncSandbox" +``` -ISO 8601 timestamp when process completed (if applicable) +Async context manager entry - returns self. - + -## ExposedPort Objects +#### \_\_aexit\_\_ ```python -@dataclass -class ExposedPort() +async def __aexit__(exc_type, exc_val, exc_tb) -> None ``` -Result of exposing a port via TCP proxy. +Async context manager exit - automatically deletes the sandbox. - + -## Sandbox Objects +# koyeb.sandbox.exec + +Command execution utilities for Koyeb Sandbox instances +Using SandboxClient HTTP API + + + +## CommandStatus Objects ```python -class Sandbox() +class CommandStatus(str, Enum) ``` -Synchronous sandbox for running code on Koyeb infrastructure. -Provides creation and deletion functionality with proper health polling. +Command execution status - + -#### id +## CommandResult Objects + +```python +@dataclass +class CommandResult() +``` + +Result of a command execution using Koyeb API models + + + +#### success ```python @property -def id() -> str +def success() -> bool +``` + +Check if command executed successfully + + + +#### output + +```python +@property +def output() -> str +``` + +Get combined stdout and stderr output + + + +## SandboxCommandError Objects + +```python +class SandboxCommandError(SandboxError) +``` + +Raised when a sandbox command fails (opt-in via raise_on_error). + + + +## SandboxExecutor Objects + +```python +class SandboxExecutor() +``` + +Synchronous command execution interface for Koyeb Sandbox instances. +Bound to a specific sandbox instance. + +For async usage, use AsyncSandboxExecutor instead. + + + +#### \_\_call\_\_ + +```python +def __call__(command: str, + cwd: Optional[str] = None, + env: Optional[Dict[str, str]] = None, + timeout: int = 30, + on_stdout: Optional[Callable[[str], None]] = None, + on_stderr: Optional[Callable[[str], None]] = None, + stream: bool = True, + raise_on_error: bool = False) -> CommandResult +``` + +Execute a command in a shell synchronously. Supports streaming output via callbacks. + +**Arguments**: + +- `command` - Command to execute as a string (e.g., "python -c 'print(2+2)'") +- `cwd` - Working directory for the command +- `env` - Environment variables for the command +- `timeout` - Command timeout in seconds (enforced for HTTP requests) +- `on_stdout` - Optional callback for streaming stdout chunks +- `on_stderr` - Optional callback for streaming stderr chunks + + +**Returns**: + +- `CommandResult` - Result of the command execution + + +**Example**: + + ```python + # Synchronous execution + result = sandbox.exec("echo hello") + + # With streaming callbacks + result = sandbox.exec( + "echo hello; sleep 1; echo world", + on_stdout=lambda data: print(f"OUT: {data}"), + on_stderr=lambda data: print(f"ERR: {data}"), + ) + ``` + + + +## AsyncSandboxExecutor Objects + +```python +class AsyncSandboxExecutor(SandboxExecutor) +``` + +Async command execution interface for Koyeb Sandbox instances. +Bound to a specific sandbox instance. + +Inherits from SandboxExecutor and provides async command execution +using native async I/O via AsyncSandboxClient. + + + +#### \_\_call\_\_ + +```python +async def __call__(command: str, + cwd: Optional[str] = None, + env: Optional[Dict[str, str]] = None, + timeout: int = 30, + on_stdout: Optional[Callable[[str], None]] = None, + on_stderr: Optional[Callable[[str], None]] = None, + stream: bool = True, + raise_on_error: bool = False) -> CommandResult +``` + +Execute a command in a shell asynchronously. Supports streaming output via callbacks. + +**Arguments**: + +- `command` - Command to execute as a string (e.g., "python -c 'print(2+2)'") +- `cwd` - Working directory for the command +- `env` - Environment variables for the command +- `timeout` - Command timeout in seconds (enforced for HTTP requests) +- `on_stdout` - Optional callback for streaming stdout chunks +- `on_stderr` - Optional callback for streaming stderr chunks + + +**Returns**: + +- `CommandResult` - Result of the command execution + + +**Example**: + + ```python + # Async execution + result = await sandbox.exec("echo hello") + + # With streaming callbacks + result = await sandbox.exec( + "echo hello; sleep 1; echo world", + on_stdout=lambda data: print(f"OUT: {data}"), + on_stderr=lambda data: print(f"ERR: {data}"), + ) + ``` + + + +# koyeb.sandbox.executor\_client + +Sandbox Executor API Client + +Sync and async Python clients for interacting with the Sandbox Executor API. + + + +## ConnectionInfo Objects + +```python +@dataclass +class ConnectionInfo() +``` + +Information needed to connect to a sandbox + + + +## SandboxClient Objects + +```python +class SandboxClient() +``` + +Client for the Sandbox Executor API. + + + +#### \_\_init\_\_ + +```python +def __init__(conn_info: ConnectionInfo, timeout: float = DEFAULT_HTTP_TIMEOUT) +``` + +Initialize the Sandbox Client. + +**Arguments**: + +- `conn_info` - The parameters needed to connect to the sandbox +- `timeout` - Request timeout in seconds (default: 30) + + + +#### close + +```python +def close() -> None +``` + +Close the HTTP client and release resources. + + + +#### \_\_enter\_\_ + +```python +def __enter__() +``` + +Context manager entry - returns self. + + + +#### \_\_exit\_\_ + +```python +def __exit__(exc_type, exc_val, exc_tb) -> None +``` + +Context manager exit - automatically closes the client. + + + +#### \_\_del\_\_ + +```python +def __del__() +``` + +Clean up client on deletion (fallback, not guaranteed to run). + + + +#### health + +```python +def health() -> Dict[str, str] +``` + +Check the health status of the server. + +Uses a short timeout and no retries since callers (wait_ready) +already handle polling with backoff. + +**Returns**: + + Dict with status information + + +**Raises**: + +- `httpx.HTTPStatusError` - If the health check fails +- `httpx.TimeoutException` - If the health check times out + + + +#### run + +```python +def run(cmd: str, + cwd: Optional[str] = None, + env: Optional[Dict[str, str]] = None, + timeout: Optional[float] = None) -> Dict[str, Any] +``` + +Execute a shell command in the sandbox. + +**Arguments**: + +- `cmd` - The shell command to execute +- `cwd` - Optional working directory for command execution +- `env` - Optional environment variables to set/override +- `timeout` - Optional timeout in seconds for the request + + +**Returns**: + + Dict containing stdout, stderr, error (if any), and exit code + + + +#### run\_streaming + +```python +def run_streaming(cmd: str, + cwd: Optional[str] = None, + env: Optional[Dict[str, str]] = None, + timeout: Optional[float] = None) -> Iterator[Dict[str, Any]] +``` + +Execute a shell command in the sandbox and stream the output in real-time. + +This method uses Server-Sent Events (SSE) to stream command output line-by-line +as it's produced. Use this for long-running commands where you want real-time +output. For simple commands where buffered output is acceptable, use run() instead. + +**Arguments**: + +- `cmd` - The shell command to execute +- `cwd` - Optional working directory for command execution +- `env` - Optional environment variables to set/override +- `timeout` - Optional timeout in seconds for the streaming request + + +**Yields**: + + Dict events with the following types: + + - output events (as command produces output): +- `{"stream"` - "stdout"|"stderr", "data": "line of output"} + + - complete event (when command finishes): +- `{"code"` - , "error": false} + + - error event (if command fails to start): +- `{"error"` - "error message"} + + +**Example**: + + >>> client = SandboxClient("http://localhost:8080", "secret") + >>> for event in client.run_streaming("echo 'Hello'; sleep 1; echo 'World'"): + ... if "stream" in event: + ... print(f"{event['stream']}: {event['data']}") + ... elif "code" in event: + ... print(f"Exit code: {event['code']}") + + + +#### write\_file + +```python +def write_file(path: str, content: str) -> Dict[str, Any] +``` + +Write content to a file. + +**Arguments**: + +- `path` - The file path to write to +- `content` - The content to write + + +**Returns**: + + Dict with success status and error if any + + + +#### read\_file + +```python +def read_file(path: str) -> Dict[str, Any] +``` + +Read content from a file. + +**Arguments**: + +- `path` - The file path to read from + + +**Returns**: + + Dict with file content and error if any + + + +#### delete\_file + +```python +def delete_file(path: str) -> Dict[str, Any] +``` + +Delete a file. + +**Arguments**: + +- `path` - The file path to delete + + +**Returns**: + + Dict with success status and error if any + + + +#### make\_dir + +```python +def make_dir(path: str) -> Dict[str, Any] +``` + +Create a directory (including parent directories). + +**Arguments**: + +- `path` - The directory path to create + + +**Returns**: + + Dict with success status and error if any + + + +#### delete\_dir + +```python +def delete_dir(path: str) -> Dict[str, Any] +``` + +Recursively delete a directory and all its contents. + +**Arguments**: + +- `path` - The directory path to delete + + +**Returns**: + + Dict with success status and error if any + + + +#### list\_dir + +```python +def list_dir(path: str) -> Dict[str, Any] +``` + +List the contents of a directory. + +**Arguments**: + +- `path` - The directory path to list + + +**Returns**: + + Dict with entries list and error if any + + + +#### bind\_port + +```python +def bind_port(port: int) -> Dict[str, Any] +``` + +Bind a port to the TCP proxy for external access. + +Configures the TCP proxy to forward traffic to the specified port inside the sandbox. +This allows you to expose services running inside the sandbox to external connections. + +**Arguments**: + +- `port` - The port number to bind to (must be a valid port number) + + +**Returns**: + + Dict with success status, message, and port information + + +**Notes**: + + - Only one port can be bound at a time + - Binding a new port will override the previous binding + - The port must be available and accessible within the sandbox environment + + + +#### unbind\_port + +```python +def unbind_port(port: Optional[int] = None) -> Dict[str, Any] +``` + +Unbind a port from the TCP proxy. + +Removes the TCP proxy port binding, stopping traffic forwarding to the previously bound port. + +**Arguments**: + +- `port` - Optional port number to unbind. If provided, it must match the currently bound port. + If not provided, any existing binding will be removed. + + +**Returns**: + + Dict with success status and message + + +**Notes**: + + - If a port is specified and doesn't match the currently bound port, the request will fail + - After unbinding, the TCP proxy will no longer forward traffic + + + +#### start\_process + +```python +def start_process(cmd: str, + cwd: Optional[str] = None, + env: Optional[Dict[str, str]] = None) -> Dict[str, Any] ``` -Get the service ID of the sandbox. +Start a background process in the sandbox. + +Starts a long-running background process that continues executing even after +the API call completes. Use this for servers, workers, or other long-running tasks. - +**Arguments**: -#### create +- `cmd` - The shell command to execute as a background process +- `cwd` - Optional working directory for the process +- `env` - Optional environment variables to set/override for the process + + +**Returns**: + + Dict with process id and success status: + - id: The unique process ID (UUID string) + - success: True if the process was started successfully + + +**Example**: + + >>> client = SandboxClient("http://localhost:8080", "secret") + >>> result = client.start_process("python -u server.py") + >>> process_id = result["id"] + >>> print(f"Started process: {process_id}") + + + +#### kill\_process ```python -@classmethod -def create(cls, - image: str = "koyeb/sandbox", - name: str = "quick-sandbox", - wait_ready: bool = True, - instance_type: str = "micro", - exposed_port_protocol: Optional[str] = None, - env: Optional[Dict[str, Any]] = None, - config_files: Optional[Dict[str, Any]] = None, - region: Optional[str] = None, - api_token: Optional[str] = None, - timeout: int = 300, - idle_timeout: int = 300, - enable_tcp_proxy: bool = False, - privileged: bool = False, - registry_secret: Optional[str] = None, - _experimental_enable_light_sleep: bool = False, - _experimental_deep_sleep_value: int = 3900, - delete_after_delay: int = 0, - delete_after_inactivity_delay: int = 0, - app_id: Optional[str] = None, - enable_mesh: bool = None, - poll_interval: float = DEFAULT_POLL_INTERVAL, - entrypoint: Optional[List[str]] = None, - command: Optional[str] = None, - args: Optional[List[str]] = None, - host: Optional[str] = None, - block_network: bool = False, - outbound_allowlist: Optional[List[str]] = None) -> Sandbox +def kill_process(process_id: str) -> Dict[str, Any] ``` -Create a new sandbox instance. +Kill a background process by its ID. + +Terminates a running background process. This sends a SIGTERM signal to the process, +allowing it to clean up gracefully. If the process doesn't terminate within a timeout, +it will be forcefully killed with SIGKILL. **Arguments**: -- `image` - Docker image to use (default: koyeb/sandbox) -- `name` - Name of the sandbox -- `wait_ready` - Wait for sandbox to be ready (default: True) -- `instance_type` - Instance type (default: micro) -- `exposed_port_protocol` - Protocol to expose ports with ("http" or "http2"). - If None, defaults to "http". - If provided, must be one of "http" or "http2". -- `env` - Environment variables -- `config_files` - Config files to create in the sandbox, as a dictionary mapping - file paths to file contents. Values can be plain strings (default permissions 0644) - or ``ConfigFile`` instances for custom permissions - (e.g., {"/etc/myapp/config.yaml": "key: value", "/etc/myapp/cert.pem": ConfigFile(content="...", permissions="0600")}) -- `region` - Region to deploy to. Defaults to KOYEB_REGION env var, or "na" if not set. -- `api_token` - Koyeb API token (if None, will try to get from KOYEB_API_TOKEN env var) -- `timeout` - Timeout for sandbox creation in seconds -- `idle_timeout` - Sleep timeout in seconds. Behavior depends on _experimental_enable_light_sleep: - - If _experimental_enable_light_sleep is True: sets light_sleep value (deep_sleep=3900) - - If _experimental_enable_light_sleep is False: sets deep_sleep value - - If 0: disables scale-to-zero (keep always-on) - - If None: uses default values -- `enable_tcp_proxy` - If True, enables TCP proxy for direct TCP access to port 3031 -- `privileged` - If True, run the container in privileged mode (default: False) -- `registry_secret` - Name of a Koyeb secret containing registry credentials for - pulling private images. Create the secret via Koyeb dashboard or CLI first. -- `_experimental_enable_light_sleep` - If True, uses idle_timeout for light_sleep and sets - deep_sleep=3900. If False, uses idle_timeout for deep_sleep (default: False) -- `delete_after_delay` - If >0, automatically delete the sandbox if there was no activity - after this many seconds since creation. -- `delete_after_inactivity_delay` - If >0, automatically delete the sandbox if service sleeps due to inactivity - after this many seconds. -- `app_id` - If provided, create the sandbox service in an existing app instead of creating a new one. -- `enable_mesh` - Enable or disable mesh for this sandbox. Disabled by default -- `poll_interval` - Time between health checks in seconds when wait_ready is True (default: 0.5) -- `entrypoint` - Override the default entrypoint of the Docker image (e.g., ["/bin/sh", "-c"]) -- `command` - Override the default command of the Docker image (e.g., "python app.py") -- `host` - Koyeb API host URL. If not provided, will try to get from KOYEB_API_HOST env var (defaults to https://app.koyeb.com) -- `block_network` - If True, block all outbound network access from the sandbox -- `outbound_allowlist` - List of IPs/CIDRs allowed as outbound destinations; - all other outbound traffic is blocked. Bare IPs are normalized to - /32 (IPv4) or /128 (IPv6). Mutually exclusive with block_network. +- `process_id` - The unique process ID (UUID string) to kill **Returns**: -- `Sandbox` - A new Sandbox instance + Dict with success status and error message if any -**Raises**: +**Example**: -- `ValueError` - If API token is not provided -- `SandboxTimeoutError` - If wait_ready is True and sandbox does not become ready within timeout -- `EgressPolicyError` - If both block_network and outbound_allowlist are passed, - or an allowlist entry is not a valid IP address or CIDR + >>> client = SandboxClient("http://localhost:8080", "secret") + >>> result = client.kill_process("550e8400-e29b-41d4-a716-446655440000") + >>> if result.get("success"): + ... print("Process killed successfully") + + + +#### list\_processes + +```python +def list_processes() -> Dict[str, Any] +``` + +List all background processes. + +Returns information about all currently running and recently completed background +processes. This includes both active processes and processes that have completed +(which remain in memory until server restart). + +**Returns**: + + Dict with a list of processes: + - processes: List of process objects, each containing: + - id: Process ID (UUID string) + - command: The command that was executed + - status: Process status (e.g., "running", "completed") + - pid: OS process ID (if running) + - exit_code: Exit code (if completed) + - started_at: ISO 8601 timestamp when process started + - completed_at: ISO 8601 timestamp when process completed (if applicable) **Example**: - >>> # Public image (default) - >>> sandbox = Sandbox.create() + >>> client = SandboxClient("http://localhost:8080", "secret") + >>> result = client.list_processes() + >>> for process in result.get("processes", []): + ... print(f"{process['id']}: {process['command']} - {process['status']}") + + + +## AsyncSandboxClient Objects + +```python +class AsyncSandboxClient() +``` + +Async client for the Sandbox Executor API using httpx. + + + +#### \_\_init\_\_ + +```python +def __init__(conn_info: ConnectionInfo, timeout: float = DEFAULT_HTTP_TIMEOUT) +``` + +Initialize the Async Sandbox Client. + +**Arguments**: + +- `conn_info` - The parameters needed to connect to the sandbox +- `timeout` - Request timeout in seconds (default: 30) + + + +#### close + +```python +async def close() -> None +``` + +Close the HTTP client and release resources. + + + +#### \_\_aenter\_\_ + +```python +async def __aenter__() +``` + +Async context manager entry - returns self. + + + +#### \_\_aexit\_\_ + +```python +async def __aexit__(exc_type, exc_val, exc_tb) -> None +``` + +Async context manager exit - automatically closes the client. + + + +#### health + +```python +async def health() -> Dict[str, str] +``` + +Check the health status of the server. + +Uses a short timeout and no retries since callers (wait_ready) +already handle polling with backoff. + +**Returns**: + + Dict with status information - >>> # Private image with registry secret - >>> sandbox = Sandbox.create( - ... image="ghcr.io/myorg/myimage:latest", - ... registry_secret="my-ghcr-secret" - ... ) - +**Raises**: + +- `httpx.HTTPStatusError` - If the health check fails +- `httpx.TimeoutException` - If the health check times out + + + +#### run + +```python +async def run(cmd: str, + cwd: Optional[str] = None, + env: Optional[Dict[str, str]] = None, + timeout: Optional[float] = None) -> Dict[str, Any] +``` + +Execute a shell command in the sandbox. + +**Arguments**: + +- `cmd` - The shell command to execute +- `cwd` - Optional working directory for command execution +- `env` - Optional environment variables to set/override +- `timeout` - Optional timeout in seconds for the request + + +**Returns**: + + Dict containing stdout, stderr, error (if any), and exit code + + -#### get\_from\_id +#### run\_streaming ```python -@classmethod -def get_from_id(cls, - id: str, - api_token: Optional[str] = None, - host: Optional[str] = None) -> "Sandbox" +async def run_streaming( + cmd: str, + cwd: Optional[str] = None, + env: Optional[Dict[str, str]] = None, + timeout: Optional[float] = None) -> AsyncIterator[Dict[str, Any]] ``` -Get a sandbox by service ID. +Execute a shell command in the sandbox and stream the output in real-time. + +This method uses Server-Sent Events (SSE) to stream command output line-by-line +as it's produced. Use this for long-running commands where you want real-time +output. For simple commands where buffered output is acceptable, use run() instead. **Arguments**: -- `id` - Service ID of the sandbox -- `api_token` - Koyeb API token (if None, will try to get from KOYEB_API_TOKEN env var) -- `host` - Koyeb API host URL. If not provided, will try to get from KOYEB_API_HOST env var (defaults to https://app.koyeb.com) +- `cmd` - The shell command to execute +- `cwd` - Optional working directory for command execution +- `env` - Optional environment variables to set/override +- `timeout` - Optional timeout in seconds for the streaming request -**Returns**: +**Yields**: -- `Sandbox` - The Sandbox instance + Dict events with the following types: + + - output events (as command produces output): +- `{"stream"` - "stdout"|"stderr", "data": "line of output"} + + - complete event (when command finishes): +- `{"code"` - , "error": false} + + - error event (if command fails to start): +- `{"error"` - "error message"} -**Raises**: +**Example**: -- `ValueError` - If API token is not provided or id is invalid -- `SandboxError` - If sandbox is not found or retrieval fails + >>> client = AsyncSandboxClient("http://localhost:8080", "secret") + >>> async for event in client.run_streaming("echo 'Hello'; sleep 1; echo 'World'"): + ... if "stream" in event: + ... print(f"{event['stream']}: {event['data']}") + ... elif "code" in event: + ... print(f"Exit code: {event['code']}") - + -#### wait\_ready +#### write\_file ```python -def wait_ready(timeout: int = DEFAULT_INSTANCE_WAIT_TIMEOUT, - poll_interval: Optional[float] = None) -> bool +async def write_file(path: str, content: str) -> Dict[str, Any] ``` -Wait for sandbox to become ready with exponential backoff polling. - -First waits for the deployment status to become HEALTHY, then polls the -sandbox health endpoint to confirm the executor is responsive. - -Starts polling at 0.1s intervals, doubling each time up to poll_interval. +Write content to a file. **Arguments**: -- `timeout` - Maximum time to wait in seconds -- `poll_interval` - Maximum time between health checks in seconds (defaults to instance poll_interval) +- `path` - The file path to write to +- `content` - The content to write **Returns**: -- `bool` - True if sandbox became ready, False if timeout + Dict with success status and error if any - + -#### wait\_tcp\_proxy\_ready +#### read\_file ```python -def wait_tcp_proxy_ready(timeout: int = DEFAULT_INSTANCE_WAIT_TIMEOUT, - poll_interval: Optional[float] = None) -> bool +async def read_file(path: str) -> Dict[str, Any] ``` -Wait for TCP proxy to become ready and available. - -Polls the deployment metadata with exponential backoff until the TCP proxy -information is available. Starts at 0.1s intervals, doubling up to poll_interval. +Read content from a file. **Arguments**: -- `timeout` - Maximum time to wait in seconds -- `poll_interval` - Maximum time between checks in seconds (defaults to instance poll_interval) +- `path` - The file path to read from **Returns**: -- `bool` - True if TCP proxy became ready, False if timeout + Dict with file content and error if any - + -#### delete +#### delete\_file ```python -def delete() -> None +async def delete_file(path: str) -> Dict[str, Any] ``` -Delete the sandbox instance. - - - -#### get\_domain - -```python -def get_domain() -> Optional[str] -``` +Delete a file. -Get the public domain of the sandbox. +**Arguments**: -Returns the domain (e.g., "app-name-org.koyeb.app/r/routing_key/" or -"app-name-org.koyeb.app") without protocol. To get the full URL with protocol, -use sandbox._get_url() +- `path` - The file path to delete + **Returns**: -- `Optional[str]` - The domain or None if unavailable + Dict with success status and error if any - + -#### get\_tcp\_proxy\_info +#### make\_dir ```python -def get_tcp_proxy_info() -> Optional[tuple[str, int]] +async def make_dir(path: str) -> Dict[str, Any] ``` -Get the TCP proxy host and port for the sandbox. +Create a directory (including parent directories). -Returns the TCP proxy host and port as a tuple (host, port) for direct TCP access to port 3031. -This is only available if enable_tcp_proxy=True was set when creating the sandbox. +**Arguments**: + +- `path` - The directory path to create + **Returns**: - Optional[tuple[str, int]]: A tuple of (host, port) or None if unavailable + Dict with success status and error if any - + -#### is\_healthy +#### delete\_dir ```python -def is_healthy() -> bool +async def delete_dir(path: str) -> Dict[str, Any] ``` -Check if sandbox is healthy and ready for operations +Recursively delete a directory and all its contents. - +**Arguments**: -#### filesystem +- `path` - The directory path to delete + -```python -@property -def filesystem() -> "SandboxFilesystem" -``` +**Returns**: -Get filesystem operations interface + Dict with success status and error if any - + -#### exec +#### list\_dir ```python -@property -def exec() -> "SandboxExecutor" +async def list_dir(path: str) -> Dict[str, Any] ``` -Get command execution interface +List the contents of a directory. - +**Arguments**: -#### expose\_port +- `path` - The directory path to list + + +**Returns**: + + Dict with entries list and error if any + + + +#### bind\_port ```python -def expose_port(port: int) -> ExposedPort +async def bind_port(port: int) -> Dict[str, Any] ``` -Expose a port to external connections via TCP proxy. +Bind a port to the TCP proxy for external access. -Binds the specified internal port to the TCP proxy, allowing external -connections to reach services running on that port inside the sandbox. -Automatically unbinds any existing port before binding the new one. +Configures the TCP proxy to forward traffic to the specified port inside the sandbox. +This allows you to expose services running inside the sandbox to external connections. **Arguments**: -- `port` - The internal port number to expose (must be a valid port number between 1 and 65535) +- `port` - The port number to bind to (must be a valid port number) **Returns**: -- `ExposedPort` - An object with `port` and `exposed_at` attributes: - - port: The exposed port number - - exposed_at: The full URL with https:// protocol (e.g., "https://app-name-org.koyeb.app") - - -**Raises**: - -- `ValueError` - If port is not in valid range [1, 65535] -- `SandboxError` - If the port binding operation fails + Dict with success status, message, and port information **Notes**: - - Only one port can be exposed at a time - - Any existing port binding is automatically unbound before binding the new port + - Only one port can be bound at a time + - Binding a new port will override the previous binding - The port must be available and accessible within the sandbox environment - - The TCP proxy is accessed via get_tcp_proxy_info() which returns (host, port) - - -**Example**: - - >>> result = sandbox.expose_port(8080) - >>> result.port - 8080 - >>> result.exposed_at - 'https://app-name-org.koyeb.app' - + -#### unexpose\_port +#### unbind\_port ```python -def unexpose_port() -> None +async def unbind_port(port: Optional[int] = None) -> Dict[str, Any] ``` -Unexpose a port from external connections. +Unbind a port from the TCP proxy. -Removes the TCP proxy port binding, stopping traffic forwarding to the -previously bound port. +Removes the TCP proxy port binding, stopping traffic forwarding to the previously bound port. -**Raises**: +**Arguments**: -- `SandboxError` - If the port unbinding operation fails +- `port` - Optional port number to unbind. If provided, it must match the currently bound port. + If not provided, any existing binding will be removed. + + +**Returns**: + + Dict with success status and message **Notes**: - - After unexposing, the TCP proxy will no longer forward traffic - - Safe to call even if no port is currently bound + - If a port is specified and doesn't match the currently bound port, the request will fail + - After unbinding, the TCP proxy will no longer forward traffic - + -#### launch\_process +#### start\_process ```python -def launch_process(cmd: str, - cwd: Optional[str] = None, - env: Optional[Dict[str, str]] = None) -> str +async def start_process( + cmd: str, + cwd: Optional[str] = None, + env: Optional[Dict[str, str]] = None) -> Dict[str, Any] ``` -Launch a background process in the sandbox. +Start a background process in the sandbox. Starts a long-running background process that continues executing even after -the method returns. Use this for servers, workers, or other long-running tasks. +the API call completes. Use this for servers, workers, or other long-running tasks. **Arguments**: @@ -1400,25 +2249,24 @@ the method returns. Use this for servers, workers, or other long-running tasks. **Returns**: -- `str` - The unique process ID (UUID string) that can be used to manage the process - - -**Raises**: - -- `SandboxError` - If the process launch fails + Dict with process id and success status: + - id: The unique process ID (UUID string) + - success: True if the process was started successfully **Example**: - >>> process_id = sandbox.launch_process("python -u server.py") + >>> client = AsyncSandboxClient("http://localhost:8080", "secret") + >>> result = await client.start_process("python -u server.py") + >>> process_id = result["id"] >>> print(f"Started process: {process_id}") - + #### kill\_process ```python -def kill_process(process_id: str) -> None +async def kill_process(process_id: str) -> Dict[str, Any] ``` Kill a background process by its ID. @@ -1432,21 +2280,24 @@ it will be forcefully killed with SIGKILL. - `process_id` - The unique process ID (UUID string) to kill -**Raises**: +**Returns**: -- `SandboxError` - If the process kill operation fails + Dict with success status and error message if any **Example**: - >>> sandbox.kill_process("550e8400-e29b-41d4-a716-446655440000") + >>> client = AsyncSandboxClient("http://localhost:8080", "secret") + >>> result = await client.kill_process("550e8400-e29b-41d4-a716-446655440000") + >>> if result.get("success"): + ... print("Process killed successfully") - + #### list\_processes ```python -def list_processes() -> List[ProcessInfo] +async def list_processes() -> Dict[str, Any] ``` List all background processes. @@ -1457,7 +2308,8 @@ processes. This includes both active processes and processes that have completed **Returns**: -- `List[ProcessInfo]` - List of process objects, each containing: + Dict with a list of processes: + - processes: List of process objects, each containing: - id: Process ID (UUID string) - command: The command that was executed - status: Process status (e.g., "running", "completed") @@ -1467,1851 +2319,1873 @@ processes. This includes both active processes and processes that have completed - completed_at: ISO 8601 timestamp when process completed (if applicable) -**Raises**: +**Example**: + + >>> client = AsyncSandboxClient("http://localhost:8080", "secret") + >>> result = await client.list_processes() + >>> for process in result.get("processes", []): + ... print(f"{process['id']}: {process['command']} - {process['status']}") -- `SandboxError` - If listing processes fails - + -**Example**: +# koyeb.sandbox.filesystem - >>> processes = sandbox.list_processes() - >>> for process in processes: - ... print(f"{process.id}: {process.command} - {process.status}") +Filesystem operations for Koyeb Sandbox instances +Using SandboxClient HTTP API - + -#### kill\_all\_processes +## SandboxFilesystemError Objects ```python -def kill_all_processes() -> int +class SandboxFilesystemError(SandboxError) ``` -Kill all running background processes. +Base exception for filesystem operations -Convenience method that lists all processes and kills them all. This is useful -for cleanup operations. + -**Returns**: +## SandboxFileNotFoundError Objects -- `int` - The number of processes that were killed - +```python +class SandboxFileNotFoundError(SandboxFilesystemError) +``` -**Raises**: +Raised when file or directory not found -- `SandboxError` - If listing or killing processes fails - + -**Example**: +## SandboxFileExistsError Objects - >>> count = sandbox.kill_all_processes() - >>> print(f"Killed {count} processes") +```python +class SandboxFileExistsError(SandboxFilesystemError) +``` - +Raised when file already exists -#### update\_lifecycle + + +## FileInfo Objects ```python -def update_lifecycle(delete_after_delay: Optional[int] = None, - delete_after_inactivity: Optional[int] = None) -> None +@dataclass +class FileInfo() ``` -Update the sandbox's life cycle settings. - -**Arguments**: +File information -- `delete_after_delay` - If >0, automatically delete the sandbox if there was no activity - after this many seconds since creation. -- `delete_after_inactivity` - If >0, automatically delete the sandbox if service sleeps due to inactivity - after this many seconds. - + -**Raises**: +## SandboxFilesystem Objects -- `SandboxError` - If updating life cycle fails - +```python +class SandboxFilesystem() +``` -**Example**: +Synchronous filesystem operations for Koyeb Sandbox instances. +Using SandboxClient HTTP API. - >>> sandbox.update_life_cycle(delete_after_delay=600, delete_after_inactivity=300) +For async usage, use AsyncSandboxFilesystem instead. - + -#### update\_network\_policy +#### write\_file ```python -def update_network_policy( - block_network: bool = False, - outbound_allowlist: Optional[List[str]] = None) -> None +def write_file(path: str, + content: Union[str, bytes], + encoding: str = "utf-8") -> None ``` -Update the sandbox's network policy. - -Warning: applying a new network policy triggers a redeployment of the -sandbox service. The sandbox is restarted and any in-memory or -non-persisted state is lost. This method does not wait for the -redeployment to finish. +Write content to a file synchronously. **Arguments**: -- `block_network` - If True, block all outbound network access from the sandbox -- `outbound_allowlist` - List of IPs/CIDRs allowed as outbound destinations; - all other outbound traffic is blocked. Bare IPs are normalized to - /32 (IPv4) or /128 (IPv6). Mutually exclusive with block_network. - - With both arguments unset, the network policy is reset to the - platform default (unrestricted outbound access). - +- `path` - Absolute path to the file +- `content` - Content to write (string or bytes) +- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary data. -**Raises**: + -- `EgressPolicyError` - If both block_network and outbound_allowlist are - passed, or an allowlist entry is not a valid IP address or CIDR -- `SandboxError` - If updating the network policy fails - +#### read\_file -**Example**: +```python +def read_file(path: str, encoding: str = "utf-8") -> FileInfo +``` - >>> sandbox.update_network_policy(block_network=True) - >>> sandbox.update_network_policy(outbound_allowlist=["10.0.0.0/8", "1.2.3.4"]) - >>> sandbox.update_network_policy() # reset to unrestricted +Read a file from the sandbox synchronously. - +**Arguments**: -#### \_\_enter\_\_ +- `path` - Absolute path to the file +- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary data, + which will decode the base64 content and return bytes. + -```python -def __enter__() -> "Sandbox" -``` +**Returns**: -Context manager entry - returns self. +- `FileInfo` - Object with content (str or bytes if base64) and encoding - + -#### \_\_exit\_\_ +#### mkdir ```python -def __exit__(exc_type, exc_val, exc_tb) -> None +def mkdir(path: str) -> None ``` -Context manager exit - automatically deletes the sandbox. - - +Create a directory synchronously. -## AsyncSandbox Objects +Note: Parent directories are always created automatically by the API. -```python -class AsyncSandbox(Sandbox) -``` +**Arguments**: -Async sandbox for running code on Koyeb infrastructure. -Inherits from Sandbox and provides native async implementations. +- `path` - Absolute path to the directory - + -#### get\_from\_id +#### list\_dir ```python -@classmethod -async def get_from_id(cls, - id: str, - api_token: Optional[str] = None, - host: Optional[str] = None) -> "AsyncSandbox" +def list_dir(path: str = ".") -> List[str] ``` -Get a sandbox by service ID asynchronously. +List contents of a directory synchronously. **Arguments**: -- `id` - Service ID of the sandbox -- `api_token` - Koyeb API token (if None, will try to get from KOYEB_API_TOKEN env var) -- `host` - Koyeb API host URL. If not provided, will try to get from KOYEB_API_HOST env var (defaults to https://app.koyeb.com) +- `path` - Path to the directory (default: current directory) **Returns**: -- `AsyncSandbox` - The AsyncSandbox instance - - -**Raises**: - -- `ValueError` - If API token is not provided or id is invalid -- `SandboxError` - If sandbox is not found or retrieval fails +- `List[str]` - Names of files and directories within the specified path. - + -#### create +#### delete\_file ```python -@classmethod -async def create( - cls, - image: str = "koyeb/sandbox", - name: str = "quick-sandbox", - wait_ready: bool = True, - instance_type: str = "micro", - exposed_port_protocol: Optional[str] = None, - env: Optional[Dict[str, Any]] = None, - config_files: Optional[Dict[str, Any]] = None, - region: Optional[str] = None, - api_token: Optional[str] = None, - timeout: int = 300, - idle_timeout: int = 0, - enable_tcp_proxy: bool = False, - privileged: bool = False, - registry_secret: Optional[str] = None, - _experimental_enable_light_sleep: bool = False, - _experimental_deep_sleep_value: int = 3900, - delete_after_delay: int = 0, - delete_after_inactivity_delay: int = 0, - app_id: Optional[str] = None, - enable_mesh: bool = False, - poll_interval: float = DEFAULT_POLL_INTERVAL, - entrypoint: Optional[List[str]] = None, - command: Optional[str] = None, - args: Optional[List[str]] = None, - host: Optional[str] = None, - block_network: bool = False, - outbound_allowlist: Optional[List[str]] = None) -> AsyncSandbox +def delete_file(path: str) -> None ``` -Create a new sandbox instance with async support. +Delete a file synchronously. **Arguments**: -- `image` - Docker image to use (default: koyeb/sandbox) -- `name` - Name of the sandbox -- `wait_ready` - Wait for sandbox to be ready (default: True) -- `instance_type` - Instance type (default: micro) -- `exposed_port_protocol` - Protocol to expose ports with ("http" or "http2"). - If None, defaults to "http". - If provided, must be one of "http" or "http2". -- `env` - Environment variables -- `config_files` - Config files to create in the sandbox, as a dictionary mapping - file paths to file contents. Values can be plain strings (default permissions 0644) - or ``ConfigFile`` instances for custom permissions - (e.g., {"/etc/myapp/config.yaml": "key: value", "/etc/myapp/cert.pem": ConfigFile(content="...", permissions="0600")}) -- `region` - Region to deploy to. Defaults to KOYEB_REGION env var, or "na" if not set. -- `api_token` - Koyeb API token (if None, will try to get from KOYEB_API_TOKEN env var) -- `timeout` - Timeout for sandbox creation in seconds -- `idle_timeout` - Sleep timeout in seconds. Behavior depends on _experimental_enable_light_sleep: - - If _experimental_enable_light_sleep is True: sets light_sleep value (deep_sleep uses _experimental_deep_sleep_value) - - If _experimental_enable_light_sleep is False: sets deep_sleep value - - If 0: disables scale-to-zero (keep always-on) - - If None: uses default values -- `enable_tcp_proxy` - If True, enables TCP proxy for direct TCP access to port 3031 -- `privileged` - If True, run the container in privileged mode (default: False) -- `registry_secret` - Name of a Koyeb secret containing registry credentials for - pulling private images. Create the secret via Koyeb dashboard or CLI first. -- `_experimental_enable_light_sleep` - If True, uses idle_timeout for light_sleep and configurable - deep_sleep (default: False) -- `_experimental_deep_sleep_value` - Number of seconds for deep sleep when light sleep is enabled (default: 3900). - Only used if _experimental_enable_light_sleep is True -- `delete_after_delay` - If >0, automatically delete the sandbox if there was no activity - after this many seconds since creation. -- `delete_after_inactivity_delay` - If >0, automatically delete the sandbox if service sleeps due to inactivity - after this many seconds. -- `app_id` - If provided, create the sandbox service in an existing app instead of creating a new one. -- `enable_mesh` - Enable or disable mesh for this sandbox. Disabled by default -- `poll_interval` - Time between health checks in seconds when wait_ready is True (default: 0.5) -- `entrypoint` - Override the default entrypoint of the Docker image (e.g., ["/bin/sh", "-c"]) -- `command` - Override the default command of the Docker image (e.g., "python app.py") -- `host` - Koyeb API host URL. If not provided, will try to get from KOYEB_API_HOST env var (defaults to https://app.koyeb.com) -- `block_network` - If True, block all outbound network access from the sandbox -- `outbound_allowlist` - List of IPs/CIDRs allowed as outbound destinations; - all other outbound traffic is blocked. Bare IPs are normalized to - /32 (IPv4) or /128 (IPv6). Mutually exclusive with block_network. - +- `path` - Absolute path to the file -**Returns**: + -- `AsyncSandbox` - A new AsyncSandbox instance - +#### delete\_dir -**Raises**: +```python +def delete_dir(path: str) -> None +``` -- `ValueError` - If API token is not provided -- `SandboxTimeoutError` - If wait_ready is True and sandbox does not become ready within timeout -- `EgressPolicyError` - If both block_network and outbound_allowlist are passed, - or an allowlist entry is not a valid IP address or CIDR +Delete a directory synchronously. + +**Arguments**: + +- `path` - Absolute path to the directory - + -#### wait\_ready +#### rename\_file ```python -async def wait_ready(timeout: int = DEFAULT_INSTANCE_WAIT_TIMEOUT, - poll_interval: Optional[float] = None) -> bool +def rename_file(old_path: str, new_path: str) -> None ``` -Wait for sandbox to become ready with exponential backoff async polling. +Rename a file synchronously. -First waits for the deployment status to become HEALTHY, then polls the -sandbox health endpoint to confirm the executor is responsive. +**Arguments**: -Starts polling at 0.1s intervals, doubling each time up to poll_interval. +- `old_path` - Current file path +- `new_path` - New file path -**Arguments**: + -- `timeout` - Maximum time to wait in seconds -- `poll_interval` - Maximum time between health checks in seconds (defaults to instance poll_interval) - +#### move\_file -**Returns**: +```python +def move_file(source_path: str, destination_path: str) -> None +``` -- `bool` - True if sandbox became ready, False if timeout +Move a file to a different directory synchronously. + +**Arguments**: + +- `source_path` - Current file path +- `destination_path` - Destination path - + -#### wait\_tcp\_proxy\_ready +#### write\_files ```python -async def wait_tcp_proxy_ready(timeout: int = DEFAULT_INSTANCE_WAIT_TIMEOUT, - poll_interval: Optional[float] = None) -> bool +def write_files(files: List[Dict[str, str]]) -> None ``` -Wait for TCP proxy to become ready and available asynchronously. - -Polls the deployment metadata with exponential backoff until the TCP proxy -information is available. Starts at 0.1s intervals, doubling up to poll_interval. +Write multiple files in a single operation synchronously. **Arguments**: -- `timeout` - Maximum time to wait in seconds -- `poll_interval` - Maximum time between checks in seconds (defaults to instance poll_interval) - - -**Returns**: - -- `bool` - True if TCP proxy became ready, False if timeout +- `files` - List of dictionaries, each with 'path', 'content', and optional 'encoding'. - + -#### delete +#### exists ```python -async def delete() -> None +def exists(path: str) -> bool ``` -Delete the sandbox instance asynchronously. +Check if file/directory exists synchronously - + -#### is\_healthy +#### is\_file ```python -async def is_healthy() -> bool +def is_file(path: str) -> bool ``` -Check if sandbox is healthy and ready for operations asynchronously. +Check if path is a file synchronously - + -#### exec +#### is\_dir ```python -@property -def exec() -> "AsyncSandboxExecutor" +def is_dir(path: str) -> bool ``` -Get async command execution interface +Check if path is a directory synchronously - + -#### filesystem +#### upload\_file ```python -@property -def filesystem() -> "AsyncSandboxFilesystem" +def upload_file(local_path: str, + remote_path: str, + encoding: str = "utf-8") -> None ``` -Get filesystem operations interface +Upload a local file to the sandbox synchronously. - +**Arguments**: -#### expose\_port +- `local_path` - Path to the local file +- `remote_path` - Destination path in the sandbox +- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary files. + -```python -async def expose_port(port: int) -> ExposedPort -``` +**Raises**: -Expose a port to external connections via TCP proxy asynchronously. +- `SandboxFileNotFoundError` - If local file doesn't exist +- `UnicodeDecodeError` - If file cannot be decoded with specified encoding - + -#### unexpose\_port +#### download\_file ```python -async def unexpose_port() -> None +def download_file(remote_path: str, + local_path: str, + encoding: str = "utf-8") -> None ``` -Unexpose a port from external connections asynchronously. +Download a file from the sandbox to a local path synchronously. - +**Arguments**: -#### launch\_process +- `remote_path` - Path to the file in the sandbox +- `local_path` - Destination path on the local filesystem +- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary files. + -```python -async def launch_process(cmd: str, - cwd: Optional[str] = None, - env: Optional[Dict[str, str]] = None) -> str -``` +**Raises**: -Launch a background process in the sandbox asynchronously. +- `SandboxFileNotFoundError` - If remote file doesn't exist - + -#### kill\_process +#### ls ```python -async def kill_process(process_id: str) -> None +def ls(path: str = ".") -> List[str] ``` -Kill a background process by its ID asynchronously. +List directory contents synchronously. - +**Arguments**: -#### list\_processes +- `path` - Path to list + -```python -async def list_processes() -> List[ProcessInfo] -``` +**Returns**: -List all background processes asynchronously. + List of file/directory names - + -#### kill\_all\_processes +#### rm ```python -async def kill_all_processes() -> int +def rm(path: str, recursive: bool = False) -> None ``` -Kill all running background processes asynchronously. - - - -#### update\_lifecycle +Remove file or directory synchronously. -```python -async def update_lifecycle( - delete_after_delay: Optional[int] = None, - delete_after_inactivity: Optional[int] = None) -> None -``` +**Arguments**: -Update the sandbox's life cycle settings asynchronously. +- `path` - Path to remove +- `recursive` - Remove recursively - + -#### update\_network\_policy +#### open ```python -async def update_network_policy( - block_network: bool = False, - outbound_allowlist: Optional[List[str]] = None) -> None +def open(path: str, mode: str = "r", encoding: str = "utf-8") -> SandboxFileIO ``` -Update the sandbox's network policy asynchronously. +Open a file in the sandbox synchronously. -Warning: applying a new network policy triggers a redeployment of the -sandbox service. The sandbox is restarted and any in-memory or -non-persisted state is lost. This method does not wait for the -redeployment to finish. +**Arguments**: -See Sandbox.update_network_policy for full documentation. +- `path` - Path to the file +- `mode` - Open mode ('r', 'w', 'a', etc.) +- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary data. + -**Raises**: +**Returns**: -- `EgressPolicyError` - If both block_network and outbound_allowlist are - passed, or an allowlist entry is not a valid IP address or CIDR -- `SandboxError` - If updating the network policy fails +- `SandboxFileIO` - File handle - + -#### \_\_aenter\_\_ +## AsyncSandboxFilesystem Objects ```python -async def __aenter__() -> "AsyncSandbox" +class AsyncSandboxFilesystem(SandboxFilesystem) ``` -Async context manager entry - returns self. +Async filesystem operations for Koyeb Sandbox instances. +Uses native async I/O via AsyncSandboxClient. - + -#### \_\_aexit\_\_ +#### write\_file ```python -async def __aexit__(exc_type, exc_val, exc_tb) -> None +async def write_file(path: str, + content: Union[str, bytes], + encoding: str = "utf-8") -> None ``` -Async context manager exit - automatically deletes the sandbox. - - - -# koyeb/sandbox.utils +Write content to a file asynchronously. -Utility functions for Koyeb Sandbox +**Arguments**: - +- `path` - Absolute path to the file +- `content` - Content to write (string or bytes) +- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary data. -#### DEFAULT\_INSTANCE\_WAIT\_TIMEOUT + -seconds +#### read\_file - +```python +async def read_file(path: str, encoding: str = "utf-8") -> FileInfo +``` -#### DEFAULT\_POLL\_INTERVAL +Read a file from the sandbox asynchronously. -seconds +**Arguments**: - +- `path` - Absolute path to the file +- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary data, + which will decode the base64 content and return bytes. + -#### DEFAULT\_COMMAND\_TIMEOUT +**Returns**: -seconds +- `FileInfo` - Object with content (str or bytes if base64) and encoding - + -#### DEFAULT\_HTTP\_TIMEOUT +#### mkdir -seconds for HTTP requests +```python +async def mkdir(path: str) -> None +``` - +Create a directory asynchronously. -## ApiClients Objects +Note: Parent directories are always created automatically by the API. -```python -@dataclass(frozen=True) -class ApiClients() -``` +**Arguments**: -Bundle of Koyeb API clients sharing a single underlying ApiClient. +- `path` - Absolute path to the directory - + -#### get\_api\_clients +#### list\_dir ```python -def get_api_clients(api_token: Optional[str] = None, - host: Optional[str] = None) -> ApiClients +async def list_dir(path: str = ".") -> List[str] ``` -Get configured API clients for Koyeb operations. - -Caches clients by (token, host) to reuse the underlying HTTP connection pool. +List contents of a directory asynchronously. **Arguments**: -- `api_token` - Koyeb API token. If not provided, will try to get from KOYEB_API_TOKEN env var -- `host` - Koyeb API host URL. If not provided, will try to get from KOYEB_API_HOST env var (defaults to https://app.koyeb.com) +- `path` - Path to the directory (default: current directory) **Returns**: - ApiClients with apps, services, instances, catalog_instances, deployments, and secrets attributes - +- `List[str]` - Names of files and directories within the specified path. -**Raises**: + -- `ValueError` - If API token is not provided +#### delete\_file - +```python +async def delete_file(path: str) -> None +``` -## AsyncApiClients Objects +Delete a file asynchronously. + +**Arguments**: + +- `path` - Absolute path to the file + + + +#### delete\_dir ```python -@dataclass(frozen=True) -class AsyncApiClients() +async def delete_dir(path: str) -> None ``` -Bundle of async Koyeb API clients sharing a single underlying AsyncApiClient. +Delete a directory asynchronously. - +**Arguments**: -#### get\_async\_api\_clients +- `path` - Absolute path to the directory + + + +#### rename\_file ```python -def get_async_api_clients(api_token: Optional[str] = None, - host: Optional[str] = None) -> AsyncApiClients +async def rename_file(old_path: str, new_path: str) -> None ``` -Get configured async API clients for Koyeb operations. - -Caches clients by (token, host) to reuse the underlying HTTP connection pool. +Rename a file asynchronously. **Arguments**: -- `api_token` - Koyeb API token. If not provided, will try to get from KOYEB_API_TOKEN env var -- `host` - Koyeb API host URL. If not provided, will try to get from KOYEB_API_HOST env var - +- `old_path` - Current file path +- `new_path` - New file path -**Returns**: + - AsyncApiClients with async API client instances - +#### move\_file + +```python +async def move_file(source_path: str, destination_path: str) -> None +``` + +Move a file to a different directory asynchronously. -**Raises**: +**Arguments**: -- `ValueError` - If API token is not provided +- `source_path` - Current file path +- `destination_path` - Destination path - + -#### build\_env\_vars +#### write\_files ```python -def build_env_vars(env: Optional[Dict[str, Any]]) -> List[DeploymentEnv] +async def write_files(files: List[Dict[str, str]]) -> None ``` -Build environment variables list from dictionary. +Write multiple files in a single operation asynchronously. **Arguments**: -- `env` - Dictionary of environment variables. Values can be plain strings - or ``Secret`` instances. A ``Secret`` value is rendered as - ``"{{ secret. }}"`` so the Koyeb API substitutes the secret - value at deploy time. - +- `files` - List of dictionaries, each with 'path', 'content', and optional 'encoding'. -**Returns**: + - List of DeploymentEnv objects +#### exists + +```python +async def exists(path: str) -> bool +``` + +Check if file/directory exists asynchronously - + -#### build\_config\_files +#### is\_file ```python -def build_config_files( - config_files: Optional[Dict[str, Any]]) -> List[ConfigFile] +async def is_file(path: str) -> bool ``` -Build config files list from dictionary. +Check if path is a file asynchronously -**Arguments**: + -- `config_files` - Dictionary mapping file paths to file contents. - Values can be plain strings (default permissions 0644) or - ``ConfigFile`` instances (custom permissions). The dict key is - always used as the file path. - +#### is\_dir -**Returns**: +```python +async def is_dir(path: str) -> bool +``` - List of ConfigFile objects +Check if path is a directory asynchronously - + -#### create\_docker\_source +#### upload\_file ```python -def create_docker_source(image: str, - privileged: Optional[bool] = None, - image_registry_secret: Optional[str] = None, - entrypoint: Optional[List[str]] = None, - command: Optional[str] = None, - args: Optional[List[str]] = None) -> DockerSource +async def upload_file(local_path: str, + remote_path: str, + encoding: str = "utf-8") -> None ``` -Create Docker source configuration. +Upload a local file to the sandbox asynchronously. **Arguments**: -- `image` - Docker image name -- `privileged` - If True, run the container in privileged mode (default: None/False) -- `image_registry_secret` - Name of the secret containing registry credentials - for pulling private images -- `entrypoint` - Override the default entrypoint of the Docker image -- `command` - Override the default command of the Docker image -- `args` - Arguments to pass to the command +- `local_path` - Path to the local file +- `remote_path` - Destination path in the sandbox +- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary files. -**Returns**: +**Raises**: - DockerSource object +- `SandboxFileNotFoundError` - If local file doesn't exist +- `UnicodeDecodeError` - If file cannot be decoded with specified encoding - + -#### create\_koyeb\_sandbox\_ports +#### download\_file ```python -def create_koyeb_sandbox_ports(protocol: str = "http") -> List[DeploymentPort] +async def download_file(remote_path: str, + local_path: str, + encoding: str = "utf-8") -> None ``` -Create port configuration for koyeb/sandbox image. - -Creates two ports: -- Port 3030 exposed on HTTP, mounted on /koyeb-sandbox/ -- Port 3031 exposed with the specified protocol, mounted on / +Download a file from the sandbox to a local path asynchronously. **Arguments**: -- `protocol` - Protocol to use for port 3031 ("http" or "http2"), defaults to "http" +- `remote_path` - Path to the file in the sandbox +- `local_path` - Destination path on the local filesystem +- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary files. -**Returns**: +**Raises**: - List of DeploymentPort objects configured for koyeb/sandbox +- `SandboxFileNotFoundError` - If remote file doesn't exist - + -#### create\_koyeb\_sandbox\_proxy\_ports +#### ls ```python -def create_koyeb_sandbox_proxy_ports() -> List[DeploymentProxyPort] +async def ls(path: str = ".") -> List[str] ``` -Create TCP proxy port configuration for koyeb/sandbox image. +List directory contents asynchronously. -Creates proxy port for direct TCP access: -- Port 3031 exposed via TCP proxy +**Arguments**: + +- `path` - Path to list + **Returns**: - List of DeploymentProxyPort objects configured for TCP proxy access + List of file/directory names - + -#### create\_koyeb\_sandbox\_routes +#### rm ```python -def create_koyeb_sandbox_routes() -> List[DeploymentRoute] +async def rm(path: str, recursive: bool = False) -> None ``` -Create route configuration for koyeb/sandbox image to make it publicly accessible. - -Creates two routes: -- Port 3030 accessible at /koyeb-sandbox/ -- Port 3031 accessible at / +Remove file or directory asynchronously. -**Returns**: +**Arguments**: - List of DeploymentRoute objects configured for koyeb/sandbox +- `path` - Path to remove +- `recursive` - Remove recursively - + -#### create\_deployment\_definition +#### open ```python -def create_deployment_definition( - name: str, - docker_source: DockerSource, - env_vars: List[DeploymentEnv], - instance_type: str, - exposed_port_protocol: Optional[str] = None, - region: Optional[str] = None, - routes: Optional[List[DeploymentRoute]] = None, - idle_timeout: int = 300, - enable_tcp_proxy: bool = False, - _experimental_enable_light_sleep: bool = False, - _experimental_deep_sleep_value: int = 3900, - enable_mesh: bool = None, - config_files: Optional[List[ConfigFile]] = None, - network_policy: Optional[NetworkPolicy] = None -) -> DeploymentDefinition +def open(path: str, + mode: str = "r", + encoding: str = "utf-8") -> AsyncSandboxFileIO ``` -Create deployment definition for a sandbox service. +Open a file in the sandbox asynchronously. **Arguments**: -- `name` - Service name -- `docker_source` - Docker configuration -- `env_vars` - Environment variables -- `instance_type` - Instance type -- `exposed_port_protocol` - Protocol to expose ports with ("http" or "http2"). - If None, defaults to "http". - If provided, must be one of "http" or "http2". -- `region` - Region to deploy to. Defaults to KOYEB_REGION env var, or "na" if not set. -- `routes` - List of routes for public access -- `idle_timeout` - Number of seconds to wait before sleeping the instance if it receives no traffic -- `enable_tcp_proxy` - If True, enables TCP proxy for direct TCP access to port 3031 -- `_experimental_enable_light_sleep` - If True, uses light sleep when reaching idle_timeout. - Light Sleep reduces cold starts to ~200ms. After scaling to zero, the service stays in Light Sleep for idle_timeout seconds before going into Deep Sleep. -- `_experimental_deep_sleep_value` - Number of seconds for deep sleep when light sleep is enabled (default: 3900). - Only used if _experimental_enable_light_sleep is True. Ignored otherwise. -- `enable_mesh` - Enable or disable mesh for this sandbox. Disabled by default -- `network_policy` - Optional network policy restricting egress traffic +- `path` - Path to the file +- `mode` - Open mode ('r', 'w', 'a', etc.) +- `encoding` - File encoding (default: "utf-8"). Use "base64" for binary data. **Returns**: - DeploymentDefinition object +- `AsyncSandboxFileIO` - Async file handle - + -#### build\_network\_policy +## SandboxFileIO Objects ```python -def build_network_policy( - block_network: bool = False, - outbound_allowlist: Optional[List[str]] = None -) -> Optional[NetworkPolicy] +class SandboxFileIO() ``` -Build a NetworkPolicy from sandbox network policy arguments. +Synchronous file I/O handle for sandbox files -**Arguments**: + -- `block_network` - If True, block all outbound network access -- `outbound_allowlist` - List of IPs/CIDRs allowed as outbound - destinations; all other outbound traffic is blocked. Bare IPs - are normalized to /32 (IPv4) or /128 (IPv6). An empty list - blocks all outbound traffic. - +#### read -**Returns**: +```python +def read() -> Union[str, bytes] +``` - NetworkPolicy, or None when both arguments are unset - (block_network=False and outbound_allowlist=None) - +Read file content synchronously -**Raises**: + -- `EgressPolicyError` - If both arguments are passed, or an allowlist - entry is not a valid IP address or CIDR +#### write - +```python +def write(content: Union[str, bytes]) -> None +``` -#### escape\_shell\_arg +Write content to file synchronously + + + +#### close ```python -def escape_shell_arg(arg: str) -> str +def close() -> None ``` -Escape a shell argument for safe use in shell commands. +Close the file -**Arguments**: + -- `arg` - The argument to escape - +## AsyncSandboxFileIO Objects -**Returns**: +```python +class AsyncSandboxFileIO() +``` - Properly escaped shell argument +Async file I/O handle for sandbox files - + -#### validate\_port +#### read ```python -def validate_port(port: int) -> None +async def read() -> Union[str, bytes] ``` -Validate that a port number is in the valid range. +Read file content asynchronously -**Arguments**: + -- `port` - Port number to validate - +#### write -**Raises**: +```python +async def write(content: Union[str, bytes]) -> None +``` -- `ValueError` - If port is not in valid range [1, 65535] +Write content to file asynchronously - + -#### check\_error\_message +#### close ```python -def check_error_message(error_msg: str, error_type: str) -> bool +def close() -> None ``` -Check if an error message matches a specific error type. -Uses case-insensitive matching against known error patterns. +Close the file -**Arguments**: + -- `error_msg` - The error message to check -- `error_type` - The type of error to check for (key in ERROR_MESSAGES) - +# koyeb.sandbox.pool -**Returns**: +Koyeb service pools: pre-warmed sandbox pools and claims. - True if error message matches the error type +Mirrors the JS SDK's service-pool.ts / claim.ts: a pool keeps ``size`` +pre-warmed sandboxes ready; ``claim()`` hands one out idempotently (the +same ``request_id`` returns the same claim), retrying transient failures +(429/5xx) with linear backoff. Sync and async are fully mirrored. - + -#### create\_sandbox\_client +#### DEFAULT\_CLAIM\_RETRY\_DELAY + +seconds; linear: delay * attempt number + + + +## ClaimResult Objects ```python -def create_sandbox_client(conn_info: Optional["ConnectionInfo"], - existing_client: Optional[Any] = None) -> Any +@dataclass +class ClaimResult() ``` -Create or return existing SandboxClient instance with validation. - -Helper function to create SandboxClient instances with consistent validation. -Used by Sandbox, SandboxExecutor, and SandboxFilesystem to avoid duplication. +A sandbox claimed from a service pool (``service_id`` is always set). -**Arguments**: + -- `conn_info` - The information needed to connect to the sandbox executor API -- `existing_client` - Existing client instance to return if not None - +#### claim -**Returns**: +```python +def claim(pool_id: str, + request_id: Optional[str] = None, + api_token: Optional[str] = None, + host: Optional[str] = None, + max_attempts: int = DEFAULT_CLAIM_ATTEMPTS, + retry_delay: float = DEFAULT_CLAIM_RETRY_DELAY) -> ClaimResult +``` -- `SandboxClient` - Configured client instance - +Claim a sandbox from a service pool. -**Raises**: +On the warm path (``prewarmed=True``) the claimed sandbox is already +running. On the cold path a sandbox service is created on demand: +``service_id`` is returned immediately and the sandbox becomes usable +once the service is ready — see ``wait_claim_ready``. -- `SandboxError` - If sandbox URL or secret is not available +Idempotent: the same ``(pool_id, request_id)`` pair always returns the +same claim; ``request_id`` defaults to a generated UUID and is preserved +across the SDK's internal retries. - + -#### create\_async\_sandbox\_client +#### claim\_async ```python -def create_async_sandbox_client(conn_info: Optional['ConnectionInfo'], - existing_client: Optional[Any] = None) -> Any +async def claim_async( + pool_id: str, + request_id: Optional[str] = None, + api_token: Optional[str] = None, + host: Optional[str] = None, + max_attempts: int = DEFAULT_CLAIM_ATTEMPTS, + retry_delay: float = DEFAULT_CLAIM_RETRY_DELAY) -> ClaimResult ``` -Create or return existing AsyncSandboxClient instance with validation. +Async twin of :func:`claim`. -Helper function to create AsyncSandboxClient instances with consistent validation. -Used by AsyncSandbox to avoid duplication. + -**Arguments**: +#### get\_claim -- `conn_info` - The information needed to connect to the sandbox executor API -- `existing_client` - Existing client instance to return if not None - +```python +def get_claim(claim_id: str, + api_token: Optional[str] = None, + host: Optional[str] = None) -> PoolClaim +``` -**Returns**: +Fetch a claim's state (UNSPECIFIED, PENDING, FULFILLED, FAILED, RELEASED). -- `AsyncSandboxClient` - Configured async client instance - + -**Raises**: +#### get\_claim\_async -- `SandboxError` - If sandbox URL or secret is not available +```python +async def get_claim_async(claim_id: str, + api_token: Optional[str] = None, + host: Optional[str] = None) -> Any +``` - +Async twin of :func:`get_claim`. -## SandboxError Objects + + +#### list\_claims ```python -class SandboxError(Exception) +def list_claims(pool_id: str, + status: Optional[str] = None, + limit: Optional[int] = None, + offset: Optional[int] = None, + api_token: Optional[str] = None, + host: Optional[str] = None) -> List[PoolClaim] ``` -Base exception for sandbox operations +List claims on a service pool, optionally filtered by status. - + -## SandboxTimeoutError Objects +#### list\_claims\_async ```python -class SandboxTimeoutError(SandboxError) +async def list_claims_async(pool_id: str, + status: Optional[str] = None, + limit: Optional[int] = None, + offset: Optional[int] = None, + api_token: Optional[str] = None, + host: Optional[str] = None) -> List[Any] ``` -Raised when a sandbox operation times out +Async twin of :func:`list_claims`. - + -## SandboxDeploymentError Objects +#### wait\_claim\_ready ```python -class SandboxDeploymentError(SandboxError) +def wait_claim_ready(claim_or_service_id: Union[ClaimResult, str], + timeout: float = DEFAULT_CLAIM_WAIT_TIMEOUT, + poll_interval: float = DEFAULT_CLAIM_POLL_INTERVAL, + api_token: Optional[str] = None, + host: Optional[str] = None) -> bool ``` -Raised when a sandbox deployment reaches an error state +Poll Get Service until the claimed sandbox is ready. - +General service-health polling: returns True on ready, False on +timeout, and raises :class:`ServiceTerminalStateError` on terminal +states. Transient Get Service failures are treated as in-progress and +retried until the timeout (they dominate while a cold claim provisions). -## SandboxServiceError Objects + + +#### wait\_claim\_ready\_async ```python -class SandboxServiceError(SandboxError) +async def wait_claim_ready_async( + claim_or_service_id: Union[ClaimResult, str], + timeout: float = DEFAULT_CLAIM_WAIT_TIMEOUT, + poll_interval: float = DEFAULT_CLAIM_POLL_INTERVAL, + api_token: Optional[str] = None, + host: Optional[str] = None) -> bool ``` -Raised when the sandbox executor returns an HTTP 5xx error +Async twin of :func:`wait_claim_ready`. - + -## EgressPolicyError Objects +## ServicePool Objects ```python -class EgressPolicyError(SandboxError) +class ServicePool() ``` -Raised when egress policy arguments are invalid or conflicting +A Koyeb service pool keeping pre-warmed sandboxes ready to claim. - + -# koyeb/sandbox.executor\_client +#### create -Sandbox Executor API Client +```python +@classmethod +def create(cls, + name: str, + image: str = "koyeb/sandbox", + size: int = DEFAULT_POOL_SIZE, + instance_type: str = "micro", + region: Optional[str] = None, + env: Optional[dict] = None, + config_files: Optional[dict] = None, + privileged: bool = False, + registry_secret: Optional[str] = None, + exposed_port_protocol: Optional[str] = None, + enable_tcp_proxy: bool = False, + idle_timeout: int = 300, + _experimental_enable_light_sleep: bool = False, + block_network: bool = False, + outbound_allowlist: Optional[List[str]] = None, + api_token: Optional[str] = None, + host: Optional[str] = None) -> "ServicePool" +``` -Sync and async Python clients for interacting with the Sandbox Executor API. +Create a pool of ``size`` pre-warmed sandboxes built from the same +definition options as ``Sandbox.create`` (minus sandbox-specific +entrypoint/command overrides). - + -## ConnectionInfo Objects +#### update ```python -@dataclass -class ConnectionInfo() +def update(size: Optional[int] = None) -> "ServicePool" ``` -Information needed to connect to a sandbox +Resize the pool; returns the updated pool. - + -## SandboxClient Objects +#### delete ```python -class SandboxClient() +def delete() -> None ``` -Client for the Sandbox Executor API. +Delete the pool (async server-side: it enters DELETING). - + -#### \_\_init\_\_ +#### refresh ```python -def __init__(conn_info: ConnectionInfo, timeout: float = DEFAULT_HTTP_TIMEOUT) +def refresh() -> "ServicePool" ``` -Initialize the Sandbox Client. - -**Arguments**: - -- `conn_info` - The parameters needed to connect to the sandbox -- `timeout` - Request timeout in seconds (default: 30) +Re-fetch the pool's state (ready_count, status) in place. - + -#### close +## AsyncServicePool Objects ```python -def close() -> None +class AsyncServicePool() ``` -Close the HTTP client and release resources. +Async twin of :class:`ServicePool`. - + -#### \_\_enter\_\_ +# koyeb.sandbox.snapshot + +Koyeb Sandbox Snapshot - Snapshot functionality for Koyeb sandboxes + + + +## SnapshotType Objects ```python -def __enter__() +class SnapshotType(Enum) ``` -Context manager entry - returns self. +Types of sandbox snapshots. - + -#### \_\_exit\_\_ +## SnapshotStatus Objects ```python -def __exit__(exc_type, exc_val, exc_tb) -> None +class SnapshotStatus(Enum) ``` -Context manager exit - automatically closes the client. +Status of a sandbox snapshot. - + -#### \_\_del\_\_ +## Snapshot Objects ```python -def __del__() +@dataclass +class Snapshot() ``` -Clean up client on deletion (fallback, not guaranteed to run). +Represents a sandbox snapshot resource. - +A snapshot captures the state of a sandbox at a specific point in time, +including its filesystem and optionally running processes. Sandboxes can +be spawned from snapshots to create pre-configured environments. -#### health + + +#### get ```python -def health() -> Dict[str, str] +@classmethod +def get(cls, + snapshot_id: str, + api_token: Optional[str] = None, + host: Optional[str] = None) -> Snapshot ``` -Check the health status of the server. +Get a snapshot by ID. -Uses a short timeout and no retries since callers (wait_ready) -already handle polling with backoff. +Uses the InstanceSnapshots API which is for sandbox/service instance snapshots. + +**Arguments**: + +- `snapshot_id` - The ID of the snapshot to retrieve +- `api_token` - Koyeb API token (falls back to KOYEB_API_TOKEN env var) +- `host` - Koyeb API host + **Returns**: - Dict with status information +- `Snapshot` - The snapshot object **Raises**: -- `httpx.HTTPStatusError` - If the health check fails -- `httpx.TimeoutException` - If the health check times out +- `SandboxError` - If snapshot cannot be retrieved - + -#### run +#### list ```python -def run(cmd: str, - cwd: Optional[str] = None, - env: Optional[Dict[str, str]] = None, - timeout: Optional[float] = None) -> Dict[str, Any] +@classmethod +def list(cls, + service_id: Optional[str] = None, + snapshot_type: Optional[SnapshotType] = None, + status: Optional[SnapshotStatus] = None, + limit: int = 50, + offset: int = 0, + api_token: Optional[str] = None, + host: Optional[str] = None) -> List[Snapshot] ``` -Execute a shell command in the sandbox. +List snapshots with optional filters. + +Uses the InstanceSnapshots API which is for sandbox/service instance snapshots. **Arguments**: -- `cmd` - The shell command to execute -- `cwd` - Optional working directory for command execution -- `env` - Optional environment variables to set/override -- `timeout` - Optional timeout in seconds for the request +- `service_id` - Filter by service ID +- `snapshot_type` - Filter by snapshot type +- `status` - Filter by snapshot status +- `limit` - Maximum number of snapshots to return +- `offset` - Offset for pagination +- `api_token` - Koyeb API token +- `host` - Koyeb API host **Returns**: - Dict containing stdout, stderr, error (if any), and exit code + List of Snapshot objects - + -#### run\_streaming +#### refresh ```python -def run_streaming(cmd: str, - cwd: Optional[str] = None, - env: Optional[Dict[str, str]] = None, - timeout: Optional[float] = None) -> Iterator[Dict[str, Any]] +def refresh() -> None ``` -Execute a shell command in the sandbox and stream the output in real-time. +Refresh snapshot state from the API. -This method uses Server-Sent Events (SSE) to stream command output line-by-line -as it's produced. Use this for long-running commands where you want real-time -output. For simple commands where buffered output is acceptable, use run() instead. + -**Arguments**: +#### wait\_available -- `cmd` - The shell command to execute -- `cwd` - Optional working directory for command execution -- `env` - Optional environment variables to set/override -- `timeout` - Optional timeout in seconds for the streaming request - +```python +def wait_available(timeout: int = 600, poll_interval: float = 5.0) -> bool +``` -**Yields**: +Wait for snapshot to become available. - Dict events with the following types: - - - output events (as command produces output): -- `{"stream"` - "stdout"|"stderr", "data": "line of output"} - - - complete event (when command finishes): -- `{"code"` - , "error": false} - - - error event (if command fails to start): -- `{"error"` - "error message"} +**Arguments**: + +- `timeout` - Maximum time to wait in seconds +- `poll_interval` - Time between status checks in seconds -**Example**: +**Returns**: - >>> client = SandboxClient("http://localhost:8080", "secret") - >>> for event in client.run_streaming("echo 'Hello'; sleep 1; echo 'World'"): - ... if "stream" in event: - ... print(f"{event['stream']}: {event['data']}") - ... elif "code" in event: - ... print(f"Exit code: {event['code']}") + True if snapshot became available, False if timeout - + -#### write\_file +#### delete ```python -def write_file(path: str, content: str) -> Dict[str, Any] +def delete() -> bool ``` -Write content to a file. - -**Arguments**: +Delete this snapshot. -- `path` - The file path to write to -- `content` - The content to write - +Uses the InstanceSnapshots API which is for sandbox/service instance snapshots. **Returns**: - Dict with success status and error if any + True if deletion was successful - + -#### read\_file +#### spawn ```python -def read_file(path: str) -> Dict[str, Any] +def spawn(name: Optional[str] = None, + wait_ready: bool = True, + timeout: int = 300, + **create_kwargs) -> Sandbox ``` -Read content from a file. +Spawn a new sandbox from this snapshot. **Arguments**: -- `path` - The file path to read from +- `name` - Name for the new sandbox +- `wait_ready` - Whether to wait for sandbox to be ready +- `timeout` - Timeout for sandbox creation in seconds +- `**create_kwargs` - Additional arguments to pass to Sandbox.create() **Returns**: - Dict with file content and error if any +- `Sandbox` - A new sandbox instance initialized from this snapshot - + -#### delete\_file +## DeclarativeSnapshot Objects ```python -def delete_file(path: str) -> Dict[str, Any] +class DeclarativeSnapshot() ``` -Delete a file. +Fluent builder for creating sandbox snapshots declaratively. -**Arguments**: +This builder allows you to define a sandbox environment by: +- Writing files +- Copying local files/directories +- Running setup commands +- Setting environment variables -- `path` - The file path to delete - +Then builds a snapshot that can be used to spawn pre-configured sandboxes. -**Returns**: + - Dict with success status and error if any +#### \_\_init\_\_ + +```python +def __init__(name: str, + image: str, + workdir: Optional[str] = None, + api_token: Optional[str] = None, + host: Optional[str] = None, + delete_builder: bool = True) +``` - +Initialize the declarative snapshot builder. -#### make\_dir +**Arguments**: + +- `name` - Name for the template/builder +- `image` - Docker image to use for the sandbox +- `workdir` - Working directory in the sandbox +- `api_token` - Koyeb API token +- `host` - Koyeb API host +- `delete_builder` - Whether to delete the builder sandbox after creating the snapshot (default: True) + + + +#### file ```python -def make_dir(path: str) -> Dict[str, Any] +def file(path: str, content: str) -> DeclarativeSnapshot ``` -Create a directory (including parent directories). +Write a file to the sandbox during build. **Arguments**: -- `path` - The directory path to create +- `path` - Path in the sandbox (e.g., "/workspace/requirements.txt") +- `content` - File content as string **Returns**: - Dict with success status and error if any + self for method chaining - + -#### delete\_dir +#### copy ```python -def delete_dir(path: str) -> Dict[str, Any] +def copy(src: str, dst: str) -> DeclarativeSnapshot ``` -Recursively delete a directory and all its contents. +Copy a local file or directory to the sandbox during build. **Arguments**: -- `path` - The directory path to delete +- `src` - Local source path (file or directory) +- `dst` - Destination path in the sandbox **Returns**: - Dict with success status and error if any + self for method chaining - + -#### list\_dir +#### run ```python -def list_dir(path: str) -> Dict[str, Any] +def run(command: str, cwd: Optional[str] = None) -> DeclarativeSnapshot ``` -List the contents of a directory. +Run a command during build. **Arguments**: -- `path` - The directory path to list +- `command` - Command to execute +- `cwd` - Working directory for the command **Returns**: - Dict with entries list and error if any + self for method chaining - + -#### bind\_port +#### build ```python -def bind_port(port: int) -> Dict[str, Any] +def build(snapshot_name: Optional[str] = None) -> Snapshot ``` -Bind a port to the TCP proxy for external access. +Build the snapshot by creating a temporary sandbox, +applying all configurations, and creating a snapshot. -Configures the TCP proxy to forward traffic to the specified port inside the sandbox. -This allows you to expose services running inside the sandbox to external connections. +The builder sandbox is automatically deleted after the snapshot is created. **Arguments**: -- `port` - The port number to bind to (must be a valid port number) +- `snapshot_name` - Name for the snapshot (defaults to builder name) **Returns**: - Dict with success status, message, and port information - - -**Notes**: - - - Only one port can be bound at a time - - Binding a new port will override the previous binding - - The port must be available and accessible within the sandbox environment +- `Snapshot` - The created snapshot - + -#### unbind\_port +#### get\_operations ```python -def unbind_port(port: Optional[int] = None) -> Dict[str, Any] +def get_operations() -> List[str] ``` -Unbind a port from the TCP proxy. +Get list of operations recorded during build. -Removes the TCP proxy port binding, stopping traffic forwarding to the previously bound port. + -**Arguments**: +# koyeb.sandbox.utils -- `port` - Optional port number to unbind. If provided, it must match the currently bound port. - If not provided, any existing binding will be removed. - +Utility functions for Koyeb Sandbox -**Returns**: + + +#### DEFAULT\_INSTANCE\_WAIT\_TIMEOUT + +seconds + + + +#### DEFAULT\_POLL\_INTERVAL + +seconds + + + +#### DEFAULT\_COMMAND\_TIMEOUT + +seconds - Dict with success status and message - + -**Notes**: +#### DEFAULT\_HTTP\_TIMEOUT - - If a port is specified and doesn't match the currently bound port, the request will fail - - After unbinding, the TCP proxy will no longer forward traffic +seconds for HTTP requests - + -#### start\_process +#### classify\_service\_status ```python -def start_process(cmd: str, - cwd: Optional[str] = None, - env: Optional[Dict[str, str]] = None) -> Dict[str, Any] +def classify_service_status( + status: Union[ServiceStatus, str]) -> StatusClassification ``` -Start a background process in the sandbox. +Classify a service status for readiness, failing closed. -Starts a long-running background process that continues executing even after -the API call completes. Use this for servers, workers, or other long-running tasks. +HEALTHY and DEGRADED are usable, STARTING and RESUMING are still in +progress, and every other state — including unknown forward-compat +values — is a terminal failure. Mirrors the JS SDK's +classifyServiceStatus (src/claim.ts). -**Arguments**: + -- `cmd` - The shell command to execute as a background process -- `cwd` - Optional working directory for the process -- `env` - Optional environment variables to set/override for the process - +#### classify\_deployment\_status -**Returns**: +```python +def classify_deployment_status( + status: Union[DeploymentStatus, str]) -> StatusClassification +``` - Dict with process id and success status: - - id: The unique process ID (UUID string) - - success: True if the process was started successfully - +Classify a deployment status for readiness, failing closed. -**Example**: +HEALTHY and DEGRADED are ready, the pre-ready states (PENDING, +PROVISIONING, SCHEDULED, ALLOCATING, STARTING) are in progress, and every +other state — including SLEEPING, STASHED, and unknown forward-compat +values — is terminal: it will not become ready on its own during a wait. - >>> client = SandboxClient("http://localhost:8080", "secret") - >>> result = client.start_process("python -u server.py") - >>> process_id = result["id"] - >>> print(f"Started process: {process_id}") + + +## ApiClients Objects + +```python +@dataclass(frozen=True) +class ApiClients() +``` - +Bundle of Koyeb API clients sharing a single underlying ApiClient. -#### kill\_process + + +#### get\_api\_clients ```python -def kill_process(process_id: str) -> Dict[str, Any] +def get_api_clients(api_token: Optional[str] = None, + host: Optional[str] = None) -> ApiClients ``` -Kill a background process by its ID. +Get configured API clients for Koyeb operations. -Terminates a running background process. This sends a SIGTERM signal to the process, -allowing it to clean up gracefully. If the process doesn't terminate within a timeout, -it will be forcefully killed with SIGKILL. +Caches clients by (token, host) to reuse the underlying HTTP connection pool. **Arguments**: -- `process_id` - The unique process ID (UUID string) to kill +- `api_token` - Koyeb API token. If not provided, will try to get from KOYEB_API_TOKEN env var +- `host` - Koyeb API host URL. If not provided, will try to get from KOYEB_API_HOST env var (defaults to https://app.koyeb.com) **Returns**: - Dict with success status and error message if any + ApiClients with apps, services, instances, catalog_instances, deployments, and secrets attributes -**Example**: +**Raises**: - >>> client = SandboxClient("http://localhost:8080", "secret") - >>> result = client.kill_process("550e8400-e29b-41d4-a716-446655440000") - >>> if result.get("success"): - ... print("Process killed successfully") +- `ValueError` - If API token is not provided - + -#### list\_processes +## AsyncApiClients Objects ```python -def list_processes() -> Dict[str, Any] +@dataclass(frozen=True) +class AsyncApiClients() ``` -List all background processes. +Bundle of async Koyeb API clients sharing a single underlying AsyncApiClient. -Returns information about all currently running and recently completed background -processes. This includes both active processes and processes that have completed -(which remain in memory until server restart). + -**Returns**: +#### get\_async\_api\_clients - Dict with a list of processes: - - processes: List of process objects, each containing: - - id: Process ID (UUID string) - - command: The command that was executed - - status: Process status (e.g., "running", "completed") - - pid: OS process ID (if running) - - exit_code: Exit code (if completed) - - started_at: ISO 8601 timestamp when process started - - completed_at: ISO 8601 timestamp when process completed (if applicable) - +```python +def get_async_api_clients(api_token: Optional[str] = None, + host: Optional[str] = None) -> AsyncApiClients +``` -**Example**: +Get configured async API clients for Koyeb operations. - >>> client = SandboxClient("http://localhost:8080", "secret") - >>> result = client.list_processes() - >>> for process in result.get("processes", []): - ... print(f"{process['id']}: {process['command']} - {process['status']}") +Caches clients by (token, host) to reuse the underlying HTTP connection pool. - +**Arguments**: -## AsyncSandboxClient Objects +- `api_token` - Koyeb API token. If not provided, will try to get from KOYEB_API_TOKEN env var +- `host` - Koyeb API host URL. If not provided, will try to get from KOYEB_API_HOST env var + -```python -class AsyncSandboxClient() -``` +**Returns**: -Async client for the Sandbox Executor API using httpx. + AsyncApiClients with async API client instances + - +**Raises**: -#### \_\_init\_\_ +- `ValueError` - If API token is not provided + + + +#### build\_env\_vars ```python -def __init__(conn_info: ConnectionInfo, timeout: float = DEFAULT_HTTP_TIMEOUT) +def build_env_vars(env: Optional[Dict[str, Any]]) -> List[DeploymentEnv] ``` -Initialize the Async Sandbox Client. +Build environment variables list from dictionary. **Arguments**: -- `conn_info` - The parameters needed to connect to the sandbox -- `timeout` - Request timeout in seconds (default: 30) - - - -#### close +- `env` - Dictionary of environment variables. Values can be plain strings + or ``Secret`` instances. A ``Secret`` value is rendered as + ``"{{ secret. }}"`` so the Koyeb API substitutes the secret + value at deploy time. + -```python -async def close() -> None -``` +**Returns**: -Close the HTTP client and release resources. + List of DeploymentEnv objects - + -#### \_\_aenter\_\_ +#### build\_config\_files ```python -async def __aenter__() +def build_config_files( + config_files: Optional[Dict[str, Any]]) -> List[ConfigFile] ``` -Async context manager entry - returns self. +Build config files list from dictionary. - +**Arguments**: -#### \_\_aexit\_\_ +- `config_files` - Dictionary mapping file paths to file contents. + Values can be plain strings (default permissions 0644) or + ``ConfigFile`` instances (custom permissions). The dict key is + always used as the file path. + -```python -async def __aexit__(exc_type, exc_val, exc_tb) -> None -``` +**Returns**: -Async context manager exit - automatically closes the client. + List of ConfigFile objects - + -#### health +#### create\_docker\_source ```python -async def health() -> Dict[str, str] +def create_docker_source(image: str, + privileged: Optional[bool] = None, + image_registry_secret: Optional[str] = None, + entrypoint: Optional[List[str]] = None, + command: Optional[str] = None, + args: Optional[List[str]] = None) -> DockerSource ``` -Check the health status of the server. - -Uses a short timeout and no retries since callers (wait_ready) -already handle polling with backoff. +Create Docker source configuration. -**Returns**: +**Arguments**: - Dict with status information +- `image` - Docker image name +- `privileged` - If True, run the container in privileged mode (default: None/False) +- `image_registry_secret` - Name of the secret containing registry credentials + for pulling private images +- `entrypoint` - Override the default entrypoint of the Docker image +- `command` - Override the default command of the Docker image +- `args` - Arguments to pass to the command -**Raises**: +**Returns**: -- `httpx.HTTPStatusError` - If the health check fails -- `httpx.TimeoutException` - If the health check times out + DockerSource object - + -#### run +#### create\_koyeb\_sandbox\_ports ```python -async def run(cmd: str, - cwd: Optional[str] = None, - env: Optional[Dict[str, str]] = None, - timeout: Optional[float] = None) -> Dict[str, Any] +def create_koyeb_sandbox_ports(protocol: str = "http") -> List[DeploymentPort] ``` -Execute a shell command in the sandbox. +Create port configuration for koyeb/sandbox image. + +Creates two ports: +- Port 3030 exposed on HTTP, mounted on /koyeb-sandbox/ +- Port 3031 exposed with the specified protocol, mounted on / **Arguments**: -- `cmd` - The shell command to execute -- `cwd` - Optional working directory for command execution -- `env` - Optional environment variables to set/override -- `timeout` - Optional timeout in seconds for the request +- `protocol` - Protocol to use for port 3031 ("http" or "http2"), defaults to "http" **Returns**: - Dict containing stdout, stderr, error (if any), and exit code + List of DeploymentPort objects configured for koyeb/sandbox - + -#### run\_streaming +#### create\_koyeb\_sandbox\_proxy\_ports ```python -async def run_streaming( - cmd: str, - cwd: Optional[str] = None, - env: Optional[Dict[str, str]] = None, - timeout: Optional[float] = None) -> AsyncIterator[Dict[str, Any]] +def create_koyeb_sandbox_proxy_ports() -> List[DeploymentProxyPort] ``` -Execute a shell command in the sandbox and stream the output in real-time. +Create TCP proxy port configuration for koyeb/sandbox image. -This method uses Server-Sent Events (SSE) to stream command output line-by-line -as it's produced. Use this for long-running commands where you want real-time -output. For simple commands where buffered output is acceptable, use run() instead. +Creates proxy port for direct TCP access: +- Port 3031 exposed via TCP proxy -**Arguments**: +**Returns**: -- `cmd` - The shell command to execute -- `cwd` - Optional working directory for command execution -- `env` - Optional environment variables to set/override -- `timeout` - Optional timeout in seconds for the streaming request - + List of DeploymentProxyPort objects configured for TCP proxy access -**Yields**: + - Dict events with the following types: - - - output events (as command produces output): -- `{"stream"` - "stdout"|"stderr", "data": "line of output"} - - - complete event (when command finishes): -- `{"code"` - , "error": false} - - - error event (if command fails to start): -- `{"error"` - "error message"} - +#### create\_koyeb\_sandbox\_routes -**Example**: +```python +def create_koyeb_sandbox_routes() -> List[DeploymentRoute] +``` - >>> client = AsyncSandboxClient("http://localhost:8080", "secret") - >>> async for event in client.run_streaming("echo 'Hello'; sleep 1; echo 'World'"): - ... if "stream" in event: - ... print(f"{event['stream']}: {event['data']}") - ... elif "code" in event: - ... print(f"Exit code: {event['code']}") +Create route configuration for koyeb/sandbox image to make it publicly accessible. + +Creates two routes: +- Port 3030 accessible at /koyeb-sandbox/ +- Port 3031 accessible at / + +**Returns**: - + List of DeploymentRoute objects configured for koyeb/sandbox -#### write\_file + + +#### create\_deployment\_definition ```python -async def write_file(path: str, content: str) -> Dict[str, Any] +def create_deployment_definition( + name: str, + docker_source: DockerSource, + env_vars: List[DeploymentEnv], + instance_type: str, + exposed_port_protocol: Optional[str] = None, + region: Optional[str] = None, + routes: Optional[List[DeploymentRoute]] = None, + idle_timeout: int = 300, + enable_tcp_proxy: bool = False, + _experimental_enable_light_sleep: bool = False, + _experimental_deep_sleep_value: int = 3900, + enable_mesh: Optional[bool] = None, + config_files: Optional[List[ConfigFile]] = None, + network_policy: Optional[NetworkPolicy] = None +) -> DeploymentDefinition ``` -Write content to a file. +Create deployment definition for a sandbox service. **Arguments**: -- `path` - The file path to write to -- `content` - The content to write +- `name` - Service name +- `docker_source` - Docker configuration +- `env_vars` - Environment variables +- `instance_type` - Instance type +- `exposed_port_protocol` - Protocol to expose ports with ("http" or "http2"). + If None, defaults to "http". + If provided, must be one of "http" or "http2". +- `region` - Region to deploy to. Defaults to KOYEB_REGION env var, or "na" if not set. +- `routes` - List of routes for public access +- `idle_timeout` - Number of seconds to wait before sleeping the instance if it receives no traffic +- `enable_tcp_proxy` - If True, enables TCP proxy for direct TCP access to port 3031 +- `_experimental_enable_light_sleep` - If True, uses light sleep when reaching idle_timeout. + Light Sleep reduces cold starts to ~200ms. After scaling to zero, the service stays in Light Sleep for idle_timeout seconds before going into Deep Sleep. +- `_experimental_deep_sleep_value` - Number of seconds for deep sleep when light sleep is enabled (default: 3900). + Only used if _experimental_enable_light_sleep is True. Ignored otherwise. +- `enable_mesh` - Mesh tri-state: None (default) = auto, True = enabled, False = disabled +- `network_policy` - Optional network policy restricting egress traffic **Returns**: - Dict with success status and error if any + DeploymentDefinition object - + -#### read\_file +#### build\_network\_policy ```python -async def read_file(path: str) -> Dict[str, Any] +def build_network_policy( + block_network: bool = False, + outbound_allowlist: Optional[List[str]] = None +) -> Optional[NetworkPolicy] ``` -Read content from a file. +Build a NetworkPolicy from sandbox network policy arguments. **Arguments**: -- `path` - The file path to read from +- `block_network` - If True, block all outbound network access +- `outbound_allowlist` - List of IPs/CIDRs allowed as outbound + destinations; all other outbound traffic is blocked. Bare IPs + are normalized to /32 (IPv4) or /128 (IPv6). An empty list + blocks all outbound traffic. **Returns**: - Dict with file content and error if any + NetworkPolicy, or None when both arguments are unset + (block_network=False and outbound_allowlist=None) + - +**Raises**: -#### delete\_file +- `EgressPolicyError` - If both arguments are passed, or an allowlist + entry is not a valid IP address or CIDR + + + +#### escape\_shell\_arg ```python -async def delete_file(path: str) -> Dict[str, Any] +def escape_shell_arg(arg: str) -> str ``` -Delete a file. +Escape a shell argument for safe use in shell commands. **Arguments**: -- `path` - The file path to delete +- `arg` - The argument to escape **Returns**: - Dict with success status and error if any + Properly escaped shell argument - + -#### make\_dir +#### validate\_port ```python -async def make_dir(path: str) -> Dict[str, Any] +def validate_port(port: int) -> None ``` -Create a directory (including parent directories). +Validate that a port number is in the valid range. **Arguments**: -- `path` - The directory path to create +- `port` - Port number to validate -**Returns**: +**Raises**: - Dict with success status and error if any +- `ValueError` - If port is not in valid range [1, 65535] - + -#### delete\_dir +#### check\_error\_message ```python -async def delete_dir(path: str) -> Dict[str, Any] +def check_error_message(error_msg: str, error_type: str) -> bool ``` -Recursively delete a directory and all its contents. +Check if an error message matches a specific error type. +Uses case-insensitive matching against known error patterns. **Arguments**: -- `path` - The directory path to delete +- `error_msg` - The error message to check +- `error_type` - The type of error to check for (key in ERROR_MESSAGES) **Returns**: - Dict with success status and error if any + True if error message matches the error type - + -#### list\_dir +#### create\_sandbox\_client ```python -async def list_dir(path: str) -> Dict[str, Any] +def create_sandbox_client(conn_info: Optional["ConnectionInfo"], + existing_client: Optional[Any] = None) -> Any ``` -List the contents of a directory. +Create or return existing SandboxClient instance with validation. + +Helper function to create SandboxClient instances with consistent validation. +Used by Sandbox, SandboxExecutor, and SandboxFilesystem to avoid duplication. **Arguments**: -- `path` - The directory path to list +- `conn_info` - The information needed to connect to the sandbox executor API +- `existing_client` - Existing client instance to return if not None **Returns**: - Dict with entries list and error if any +- `SandboxClient` - Configured client instance + - +**Raises**: -#### bind\_port +- `SandboxError` - If sandbox URL or secret is not available + + + +#### create\_async\_sandbox\_client ```python -async def bind_port(port: int) -> Dict[str, Any] +def create_async_sandbox_client(conn_info: Optional["ConnectionInfo"], + existing_client: Optional[Any] = None) -> Any ``` -Bind a port to the TCP proxy for external access. +Create or return existing AsyncSandboxClient instance with validation. -Configures the TCP proxy to forward traffic to the specified port inside the sandbox. -This allows you to expose services running inside the sandbox to external connections. +Helper function to create AsyncSandboxClient instances with consistent validation. +Used by AsyncSandbox to avoid duplication. **Arguments**: -- `port` - The port number to bind to (must be a valid port number) +- `conn_info` - The information needed to connect to the sandbox executor API +- `existing_client` - Existing client instance to return if not None **Returns**: - Dict with success status, message, and port information +- `AsyncSandboxClient` - Configured async client instance -**Notes**: +**Raises**: - - Only one port can be bound at a time - - Binding a new port will override the previous binding - - The port must be available and accessible within the sandbox environment +- `SandboxError` - If sandbox URL or secret is not available - + -#### unbind\_port +## SandboxError Objects ```python -async def unbind_port(port: Optional[int] = None) -> Dict[str, Any] +class SandboxError(Exception) ``` -Unbind a port from the TCP proxy. +Base exception for sandbox operations -Removes the TCP proxy port binding, stopping traffic forwarding to the previously bound port. + -**Arguments**: +## MissingApiTokenError Objects -- `port` - Optional port number to unbind. If provided, it must match the currently bound port. - If not provided, any existing binding will be removed. - +```python +class MissingApiTokenError(SandboxError, ValueError) +``` -**Returns**: +Raised when no API token is provided and KOYEB_API_TOKEN is unset. - Dict with success status and message - +Also inherits ValueError for back-compat with published 1.5.x callers +that catch the old plain ValueError from the token gates. -**Notes**: + - - If a port is specified and doesn't match the currently bound port, the request will fail - - After unbinding, the TCP proxy will no longer forward traffic +## InvalidPortError Objects - +```python +class InvalidPortError(SandboxError, ValueError) +``` -#### start\_process +Raised when a port is not an integer in [MIN_PORT, MAX_PORT]. + +Also inherits ValueError for back-compat with published 1.5.x callers +that catch the old plain ValueError from validate_port. + + + +## NoSandboxSecretError Objects ```python -async def start_process( - cmd: str, - cwd: Optional[str] = None, - env: Optional[Dict[str, str]] = None) -> Dict[str, Any] +class NoSandboxSecretError(SandboxError) ``` -Start a background process in the sandbox. +Raised when a sandbox deployment carries no SANDBOX_SECRET, so the +executor connection cannot be established. -Starts a long-running background process that continues executing even after -the API call completes. Use this for servers, workers, or other long-running tasks. + -**Arguments**: +## SandboxTimeoutError Objects -- `cmd` - The shell command to execute as a background process -- `cwd` - Optional working directory for the process -- `env` - Optional environment variables to set/override for the process - +```python +class SandboxTimeoutError(SandboxError) +``` -**Returns**: +Raised when a sandbox operation times out - Dict with process id and success status: - - id: The unique process ID (UUID string) - - success: True if the process was started successfully - + -**Example**: +## SandboxDeploymentError Objects - >>> client = AsyncSandboxClient("http://localhost:8080", "secret") - >>> result = await client.start_process("python -u server.py") - >>> process_id = result["id"] - >>> print(f"Started process: {process_id}") +```python +class SandboxDeploymentError(SandboxError) +``` + +Raised when a sandbox deployment reaches an error state - + -#### kill\_process +## SandboxRequestError Objects ```python -async def kill_process(process_id: str) -> Dict[str, Any] +class SandboxRequestError(SandboxError) ``` -Kill a background process by its ID. +Raised when the sandbox executor returns a non-OK HTTP response. -Terminates a running background process. This sends a SIGTERM signal to the process, -allowing it to clean up gracefully. If the process doesn't terminate within a timeout, -it will be forcefully killed with SIGKILL. +Carries the HTTP status code and response body. SandboxServiceError +(HTTP 5xx) subclasses this, so `except SandboxRequestError` catches +every executor HTTP failure — mirroring the JS SDK's SandboxRequestError. -**Arguments**: + -- `process_id` - The unique process ID (UUID string) to kill - +## SandboxServiceError Objects -**Returns**: +```python +class SandboxServiceError(SandboxRequestError) +``` - Dict with success status and error message if any - +Raised when the sandbox executor returns an HTTP 5xx error -**Example**: + - >>> client = AsyncSandboxClient("http://localhost:8080", "secret") - >>> result = await client.kill_process("550e8400-e29b-41d4-a716-446655440000") - >>> if result.get("success"): - ... print("Process killed successfully") +## EgressPolicyError Objects + +```python +class EgressPolicyError(SandboxError) +``` + +Raised when egress policy arguments are invalid or conflicting - + -#### list\_processes +## PoolClaimError Objects ```python -async def list_processes() -> Dict[str, Any] +class PoolClaimError(SandboxError) ``` -List all background processes. +Raised when claiming a sandbox from a service pool fails -Returns information about all currently running and recently completed background -processes. This includes both active processes and processes that have completed -(which remain in memory until server restart). + -**Returns**: +## ServicePoolError Objects - Dict with a list of processes: - - processes: List of process objects, each containing: - - id: Process ID (UUID string) - - command: The command that was executed - - status: Process status (e.g., "running", "completed") - - pid: OS process ID (if running) - - exit_code: Exit code (if completed) - - started_at: ISO 8601 timestamp when process started - - completed_at: ISO 8601 timestamp when process completed (if applicable) - +```python +class ServicePoolError(SandboxError) +``` -**Example**: +Raised when a service pool operation fails - >>> client = AsyncSandboxClient("http://localhost:8080", "secret") - >>> result = await client.list_processes() - >>> for process in result.get("processes", []): - ... print(f"{process['id']}: {process['command']} - {process['status']}") + + +## ServiceTerminalStateError Objects + +```python +class ServiceTerminalStateError(SandboxError) +``` + +Raised when a service reaches a state that will never become ready diff --git a/koyeb/sandbox/exec.py b/koyeb/sandbox/exec.py index e858003b..a77d1a51 100644 --- a/koyeb/sandbox/exec.py +++ b/koyeb/sandbox/exec.py @@ -73,7 +73,6 @@ def _check_result(result: CommandResult, raise_on_error: bool) -> CommandResult: return result - class SandboxExecutor: """ Synchronous command execution interface for Koyeb Sandbox instances. diff --git a/scripts/generate_docs.sh b/scripts/generate_docs.sh index fae6c059..168c95a3 100755 --- a/scripts/generate_docs.sh +++ b/scripts/generate_docs.sh @@ -1,3 +1,14 @@ uv run pydoc-markdown -p koyeb/api >docs/api.md uv run pydoc-markdown -p koyeb/api_async >docs/api_async.md -uv run pydoc-markdown -p koyeb/sandbox >docs/sandbox.md +# Explicit module list so test modules and fakes stay out of the docs. +# PYTHONPATH is required: the module loader imports instead of walking paths. +PYTHONPATH=. uv run pydoc-markdown \ + -m koyeb.sandbox \ + -m koyeb.sandbox.sandbox \ + -m koyeb.sandbox.exec \ + -m koyeb.sandbox.executor_client \ + -m koyeb.sandbox.filesystem \ + -m koyeb.sandbox.pool \ + -m koyeb.sandbox.snapshot \ + -m koyeb.sandbox.utils \ + >docs/sandbox.md From 2ab04ceea69c23a1d50b8751ca6b6501791e578b Mon Sep 17 00:00:00 2001 From: sfroment Date: Fri, 25 Sep 2026 14:24:52 +0200 Subject: [PATCH 13/14] docs: add examples for pools, claims, list, raise_on_error Ports the pool and claim examples from #64 onto the spec-based pool API and covers the two other new public surfaces: lazy Sandbox.list handles and opt-in exec errors. --- examples/28_service_pool.py | 45 ++++++++++++++++++ examples/29_pool_claim.py | 72 +++++++++++++++++++++++++++++ examples/29_pool_claim_async.py | 67 +++++++++++++++++++++++++++ examples/30_sandbox_list.py | 49 ++++++++++++++++++++ examples/30_sandbox_list_async.py | 47 +++++++++++++++++++ examples/31_raise_on_error.py | 41 ++++++++++++++++ examples/31_raise_on_error_async.py | 38 +++++++++++++++ examples/README.md | 7 +++ 8 files changed, 366 insertions(+) create mode 100644 examples/28_service_pool.py create mode 100644 examples/29_pool_claim.py create mode 100644 examples/29_pool_claim_async.py create mode 100644 examples/30_sandbox_list.py create mode 100644 examples/30_sandbox_list_async.py create mode 100644 examples/31_raise_on_error.py create mode 100644 examples/31_raise_on_error_async.py diff --git a/examples/28_service_pool.py b/examples/28_service_pool.py new file mode 100644 index 00000000..92b2cc9f --- /dev/null +++ b/examples/28_service_pool.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python3 +"""Service pool lifecycle: create, list, update, and delete a pool. + +A service pool keeps a target number of warm sandboxes ready so that +claiming (see examples/29_pool_claim.py) hands out a pre-provisioned +service instead of provisioning one on demand. +""" + +import os +import sys + +from koyeb.sandbox import ServicePool + + +def main() -> int: + api_token = os.environ.get("KOYEB_API_TOKEN") + if not api_token: + print("KOYEB_API_TOKEN is not set", file=sys.stderr) + return 1 + + # Create a pool of 3 warm sandboxes. Definition options mirror + # Sandbox.create (image, instance_type, env, region, ...). + pool = ServicePool.create(name="my-pool", size=3, api_token=api_token) + print(f"✓ Created {pool}") + + # List every pool the caller can see. + pools = ServicePool.list(api_token=api_token) + print(f"✓ Listed {len(pools)} pool(s)") + + # Update the pool's target size. + pool.update(size=5) + print("✓ Updated: size=5") + + # Refresh re-fetches the pool (status, ready_count, ...). + pool.refresh() + print(f"✓ Refreshed, ready_count={pool.ready_count}, status={pool.status}") + + # Delete the pool. The server fences it until outstanding claims drain. + pool.delete() + print("✓ Deleted") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/examples/29_pool_claim.py b/examples/29_pool_claim.py new file mode 100644 index 00000000..466aeeab --- /dev/null +++ b/examples/29_pool_claim.py @@ -0,0 +1,72 @@ +#!/usr/bin/env python3 +"""Claim a sandbox from a service pool (sync). + +Set KOYEB_POOL_ID (create one with examples/28_service_pool.py first). +claim() is idempotent per (pool_id, request_id): replaying the same pair +returns the same sandbox instead of consuming another. +""" + +import os +import sys + +from koyeb.sandbox import ( + PoolClaimError, + Sandbox, + SandboxError, + claim, + wait_claim_ready, +) + + +def main() -> int: + api_token = os.getenv("KOYEB_API_TOKEN") + pool_id = os.getenv("KOYEB_POOL_ID") + if not api_token: + print("Error: KOYEB_API_TOKEN not set") + return 1 + if not pool_id: + print("Error: KOYEB_POOL_ID not set (create a service pool first)") + return 1 + + try: + # Claim a sandbox from the pool. The request id is generated once + # and preserved across internal retries. + print(f"Claiming a sandbox from pool {pool_id}...") + result = claim(pool_id, api_token=api_token) + + print("✓ Claim fulfilled") + print(f" Claim ID: {result.claim_id}") + print(f" Service ID: {result.service_id}") + print(f" Prewarmed: {result.prewarmed}") + print(f" Request ID: {result.request_id}") + + if not result.prewarmed: + # Cold path: no warm sandbox was available, so the claimed + # service was provisioned on demand — wait for it to boot. + wait_claim_ready(result, api_token=api_token) + print("✓ Claimed sandbox is ready") + + # Attach to the claimed service and use it like any other sandbox. + # The pool owns the claimed sandbox's lifecycle — no delete here. + sandbox = Sandbox.get_from_id(result.service_id, api_token=api_token) + out = sandbox.exec("echo 'Hello from a claimed sandbox!'") + print(f" Output: {out.stdout.strip()}") + + # Replay demo: the same (pool_id, request_id) returns the same claim. + replay = claim( + pool_id, request_id=result.request_id, api_token=api_token + ) + assert replay.service_id == result.service_id + print("✓ Replay with the same request_id returned the same service") + return 0 + except PoolClaimError as e: + # Claim failed (pool missing, terminal state, retries exhausted, ...) + print(f"Claim failed: {e}") + return 1 + except SandboxError as e: + print(f"Sandbox error: {e}") + return 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/examples/29_pool_claim_async.py b/examples/29_pool_claim_async.py new file mode 100644 index 00000000..69a5d4b9 --- /dev/null +++ b/examples/29_pool_claim_async.py @@ -0,0 +1,67 @@ +#!/usr/bin/env python3 +"""Claim a sandbox from a service pool (async variant)""" + +import asyncio +import os +import sys + +from koyeb.sandbox import ( + AsyncSandbox, + PoolClaimError, + SandboxError, + claim_async, + wait_claim_ready_async, +) + + +async def main() -> int: + api_token = os.getenv("KOYEB_API_TOKEN") + pool_id = os.getenv("KOYEB_POOL_ID") + if not api_token: + print("Error: KOYEB_API_TOKEN not set") + return 1 + if not pool_id: + print("Error: KOYEB_POOL_ID not set (create a service pool first)") + return 1 + + try: + # Claim a sandbox from the pool. The request id is generated once + # and preserved across internal retries. + print(f"Claiming a sandbox from pool {pool_id}...") + result = await claim_async(pool_id, api_token=api_token) + + print("✓ Claim fulfilled") + print(f" Claim ID: {result.claim_id}") + print(f" Service ID: {result.service_id}") + print(f" Prewarmed: {result.prewarmed}") + print(f" Request ID: {result.request_id}") + + if not result.prewarmed: + # Cold path: the claimed service was provisioned on demand. + await wait_claim_ready_async(result, api_token=api_token) + print("✓ Claimed sandbox is ready") + + # The pool owns the claimed sandbox's lifecycle — no delete here. + sandbox = await AsyncSandbox.get_from_id( + result.service_id, api_token=api_token + ) + out = await sandbox.exec("echo 'Hello from a claimed sandbox!'") + print(f" Output: {out.stdout.strip()}") + + # Replay demo: the same (pool_id, request_id) returns the same claim. + replay = await claim_async( + pool_id, request_id=result.request_id, api_token=api_token + ) + assert replay.service_id == result.service_id + print("✓ Replay with the same request_id returned the same service") + return 0 + except PoolClaimError as e: + print(f"Claim failed: {e}") + return 1 + except SandboxError as e: + print(f"Sandbox error: {e}") + return 1 + + +if __name__ == "__main__": + sys.exit(asyncio.run(main())) diff --git a/examples/30_sandbox_list.py b/examples/30_sandbox_list.py new file mode 100644 index 00000000..97a03b6d --- /dev/null +++ b/examples/30_sandbox_list.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python3 +"""List sandboxes with Sandbox.list() and connect a lazy handle. + +list() returns lazy handles: they know id/name but carry no executor +secret, so connected operations raise NoSandboxSecretError — connect +with Sandbox.get_from_id(handle.id) when you need to run commands. +""" + +import os +import sys + +from koyeb.sandbox import NoSandboxSecretError, Sandbox + + +def main() -> int: + api_token = os.environ.get("KOYEB_API_TOKEN") + if not api_token: + print("KOYEB_API_TOKEN is not set", file=sys.stderr) + return 1 + + # Create one sandbox so the listing has something of ours to find. + ours = Sandbox.create(name="list-demo", api_token=api_token) + print(f"✓ Created {ours.service_id}") + + try: + handles = Sandbox.list(api_token=api_token) + print(f"✓ Listed {len(handles)} sandbox service(s)") + for handle in handles[:5]: + print(f" {handle.id} {handle.name}") + + # Lazy handles have no executor secret... + try: + ours_handle = next(h for h in handles if h.id == ours.service_id) + ours_handle.exec("echo hi") + except NoSandboxSecretError: + print("✓ Lazy handle has no secret, as documented") + + # ...so connect through get_from_id before running commands. + connected = Sandbox.get_from_id(ours.service_id, api_token=api_token) + out = connected.exec("echo hello from the list demo") + print(f"✓ Connected handle output: {out.stdout.strip()}") + finally: + ours.delete() + print("✓ Cleaned up") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/examples/30_sandbox_list_async.py b/examples/30_sandbox_list_async.py new file mode 100644 index 00000000..bf976e50 --- /dev/null +++ b/examples/30_sandbox_list_async.py @@ -0,0 +1,47 @@ +#!/usr/bin/env python3 +"""List sandboxes with AsyncSandbox.list() and connect a lazy handle (async)""" + +import asyncio +import os +import sys + +from koyeb.sandbox import AsyncSandbox, NoSandboxSecretError + + +async def main() -> int: + api_token = os.environ.get("KOYEB_API_TOKEN") + if not api_token: + print("KOYEB_API_TOKEN is not set", file=sys.stderr) + return 1 + + # Create one sandbox so the listing has something of ours to find. + ours = await AsyncSandbox.create(name="list-demo", api_token=api_token) + print(f"✓ Created {ours.service_id}") + + try: + handles = await AsyncSandbox.list(api_token=api_token) + print(f"✓ Listed {len(handles)} sandbox service(s)") + for handle in handles[:5]: + print(f" {handle.id} {handle.name}") + + # Lazy handles have no executor secret... + try: + ours_handle = next(h for h in handles if h.id == ours.service_id) + await ours_handle.exec("echo hi") + except NoSandboxSecretError: + print("✓ Lazy handle has no secret, as documented") + + # ...so connect through get_from_id before running commands. + connected = await AsyncSandbox.get_from_id( + ours.service_id, api_token=api_token + ) + out = await connected.exec("echo hello from the list demo") + print(f"✓ Connected handle output: {out.stdout.strip()}") + finally: + await ours.delete() + print("✓ Cleaned up") + return 0 + + +if __name__ == "__main__": + sys.exit(asyncio.run(main())) diff --git a/examples/31_raise_on_error.py b/examples/31_raise_on_error.py new file mode 100644 index 00000000..21d4f52b --- /dev/null +++ b/examples/31_raise_on_error.py @@ -0,0 +1,41 @@ +#!/usr/bin/env python3 +"""Opt-in exec errors: raise_on_error turns a failed command into an exception. + +By default a failed command returns a failed CommandResult; with +raise_on_error=True it raises SandboxCommandError carrying the result. +""" + +import os +import sys + +from koyeb.sandbox import Sandbox, SandboxCommandError + + +def main() -> int: + api_token = os.environ.get("KOYEB_API_TOKEN") + if not api_token: + print("KOYEB_API_TOKEN is not set", file=sys.stderr) + return 1 + + sandbox = Sandbox.create(name="raise-demo", api_token=api_token) + print(f"✓ Created {sandbox.service_id}") + + try: + # Default: a failed command is a value, not an exception. + result = sandbox.exec("ls /definitely-missing") + print(f"✓ Default returned success={result.success}, exit={result.exit_code}") + + # Opt-in: the same command raises, with the result attached. + try: + sandbox.exec("ls /definitely-missing", raise_on_error=True) + except SandboxCommandError as e: + print(f"✓ Raised SandboxCommandError: exit={e.result.exit_code}") + print(f" stderr: {e.result.stderr.strip()}") + return 0 + finally: + sandbox.delete() + print("✓ Cleaned up") + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/examples/31_raise_on_error_async.py b/examples/31_raise_on_error_async.py new file mode 100644 index 00000000..89ffa63b --- /dev/null +++ b/examples/31_raise_on_error_async.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +"""Opt-in exec errors, async variant (raise_on_error)""" + +import asyncio +import os +import sys + +from koyeb.sandbox import AsyncSandbox, SandboxCommandError + + +async def main() -> int: + api_token = os.environ.get("KOYEB_API_TOKEN") + if not api_token: + print("KOYEB_API_TOKEN is not set", file=sys.stderr) + return 1 + + sandbox = await AsyncSandbox.create(name="raise-demo", api_token=api_token) + print(f"✓ Created {sandbox.service_id}") + + try: + # Default: a failed command is a value, not an exception. + result = await sandbox.exec("ls /definitely-missing") + print(f"✓ Default returned success={result.success}, exit={result.exit_code}") + + # Opt-in: the same command raises, with the result attached. + try: + await sandbox.exec("ls /definitely-missing", raise_on_error=True) + except SandboxCommandError as e: + print(f"✓ Raised SandboxCommandError: exit={e.result.exit_code}") + print(f" stderr: {e.result.stderr.strip()}") + return 0 + finally: + await sandbox.delete() + print("✓ Cleaned up") + + +if __name__ == "__main__": + sys.exit(asyncio.run(main())) diff --git a/examples/README.md b/examples/README.md index a12cb8ff..b326a894 100644 --- a/examples/README.md +++ b/examples/README.md @@ -41,6 +41,13 @@ uv run python examples/01_create_sandbox.py - **25_full_snapshot_and_spawn.py** - Full snapshots with process state preservation - **26_snapshot_boot_benchmark.py** - Benchmark snapshot boot times (sync) - **27_docker_in_docker.py** - Run containers inside a sandbox (docker-in-docker), building an image from scratch with no registry pull +- **28_service_pool.py** - Service pool lifecycle: create, list, update, and delete a pool +- **29_pool_claim.py** - Claim a sandbox from a service pool (idempotent by request_id), then attach and use it +- **29_pool_claim_async.py** - Claim a sandbox from a service pool (async variant) +- **30_sandbox_list.py** - List sandbox services with lazy handles, connect one via get_from_id +- **30_sandbox_list_async.py** - List sandbox services with lazy handles (async variant) +- **31_raise_on_error.py** - Opt-in exec errors: SandboxCommandError carries the failed CommandResult +- **31_raise_on_error_async.py** - Opt-in exec errors (async variant) ## Basic Usage From 01869535e8ece5189c1f0a15751017bcb5c991d9 Mon Sep 17 00:00:00 2001 From: sfroment Date: Fri, 25 Sep 2026 15:35:35 +0200 Subject: [PATCH 14/14] docs: align claim example with JS ownership semantics A claimed service is detached from the pool and caller-owned: delete it when done. The example now spawns its own pool, shows get_claim, and keeps the request_id replay demo. --- examples/29_pool_claim.py | 61 +++++++++++++++++++-------------- examples/29_pool_claim_async.py | 60 ++++++++++++++++++-------------- examples/README.md | 4 +-- 3 files changed, 73 insertions(+), 52 deletions(-) diff --git a/examples/29_pool_claim.py b/examples/29_pool_claim.py index 466aeeab..4c94c5a5 100644 --- a/examples/29_pool_claim.py +++ b/examples/29_pool_claim.py @@ -1,7 +1,7 @@ #!/usr/bin/env python3 """Claim a sandbox from a service pool (sync). -Set KOYEB_POOL_ID (create one with examples/28_service_pool.py first). +Spawns a pool, claims a sandbox, runs a command, and cleans up both. claim() is idempotent per (pool_id, request_id): replaying the same pair returns the same sandbox instead of consuming another. """ @@ -13,51 +13,59 @@ PoolClaimError, Sandbox, SandboxError, + ServicePool, claim, + get_claim, wait_claim_ready, ) def main() -> int: - api_token = os.getenv("KOYEB_API_TOKEN") - pool_id = os.getenv("KOYEB_POOL_ID") + api_token = os.environ.get("KOYEB_API_TOKEN") if not api_token: - print("Error: KOYEB_API_TOKEN not set") - return 1 - if not pool_id: - print("Error: KOYEB_POOL_ID not set (create a service pool first)") + print("KOYEB_API_TOKEN is not set", file=sys.stderr) return 1 + pool = ServicePool.create(name="claim-demo", size=1, api_token=api_token) + print(f"✓ Created pool {pool.id} (size {pool.size})") + try: # Claim a sandbox from the pool. The request id is generated once # and preserved across internal retries. - print(f"Claiming a sandbox from pool {pool_id}...") - result = claim(pool_id, api_token=api_token) - + result = claim(pool.id, api_token=api_token) print("✓ Claim fulfilled") print(f" Claim ID: {result.claim_id}") print(f" Service ID: {result.service_id}") print(f" Prewarmed: {result.prewarmed}") print(f" Request ID: {result.request_id}") - if not result.prewarmed: - # Cold path: no warm sandbox was available, so the claimed - # service was provisioned on demand — wait for it to boot. - wait_claim_ready(result, api_token=api_token) - print("✓ Claimed sandbox is ready") + # Fetch the claim record by id. + info = get_claim(result.claim_id, api_token=api_token) + print(f" Claim status: {info.status}") - # Attach to the claimed service and use it like any other sandbox. - # The pool owns the claimed sandbox's lifecycle — no delete here. + # A claimed service is detached from the pool and owned by the + # caller: delete it like any other sandbox when done. sandbox = Sandbox.get_from_id(result.service_id, api_token=api_token) - out = sandbox.exec("echo 'Hello from a claimed sandbox!'") - print(f" Output: {out.stdout.strip()}") + try: + if not result.prewarmed: + # Cold path: no warm sandbox was available, so the claimed + # service was provisioned on demand — wait for it to boot. + wait_claim_ready(result, api_token=api_token) + print("✓ Claimed sandbox is ready") + + out = sandbox.exec("echo 'Hello from a claimed sandbox!'") + print(f" Output: {out.stdout.strip()}") - # Replay demo: the same (pool_id, request_id) returns the same claim. - replay = claim( - pool_id, request_id=result.request_id, api_token=api_token - ) - assert replay.service_id == result.service_id - print("✓ Replay with the same request_id returned the same service") + # Replay demo: the same (pool_id, request_id) returns the same + # claim — safe to retry after a network failure. + replay = claim( + pool.id, request_id=result.request_id, api_token=api_token + ) + assert replay.service_id == result.service_id + print("✓ Replay with the same request_id returned the same service") + finally: + sandbox.delete() + print("✓ Deleted the claimed sandbox service") return 0 except PoolClaimError as e: # Claim failed (pool missing, terminal state, retries exhausted, ...) @@ -66,6 +74,9 @@ def main() -> int: except SandboxError as e: print(f"Sandbox error: {e}") return 1 + finally: + pool.delete() + print("✓ Deleted the pool") if __name__ == "__main__": diff --git a/examples/29_pool_claim_async.py b/examples/29_pool_claim_async.py index 69a5d4b9..94372293 100644 --- a/examples/29_pool_claim_async.py +++ b/examples/29_pool_claim_async.py @@ -9,51 +9,58 @@ AsyncSandbox, PoolClaimError, SandboxError, + ServicePool, claim_async, + get_claim_async, wait_claim_ready_async, ) async def main() -> int: - api_token = os.getenv("KOYEB_API_TOKEN") - pool_id = os.getenv("KOYEB_POOL_ID") + api_token = os.environ.get("KOYEB_API_TOKEN") if not api_token: - print("Error: KOYEB_API_TOKEN not set") - return 1 - if not pool_id: - print("Error: KOYEB_POOL_ID not set (create a service pool first)") + print("KOYEB_API_TOKEN is not set", file=sys.stderr) return 1 + pool = await ServicePool.create(name="claim-demo", size=1, api_token=api_token) + print(f"✓ Created pool {pool.id} (size {pool.size})") + try: # Claim a sandbox from the pool. The request id is generated once # and preserved across internal retries. - print(f"Claiming a sandbox from pool {pool_id}...") - result = await claim_async(pool_id, api_token=api_token) - + result = await claim_async(pool.id, api_token=api_token) print("✓ Claim fulfilled") print(f" Claim ID: {result.claim_id}") print(f" Service ID: {result.service_id}") print(f" Prewarmed: {result.prewarmed}") print(f" Request ID: {result.request_id}") - if not result.prewarmed: - # Cold path: the claimed service was provisioned on demand. - await wait_claim_ready_async(result, api_token=api_token) - print("✓ Claimed sandbox is ready") + # Fetch the claim record by id. + info = await get_claim_async(result.claim_id, api_token=api_token) + print(f" Claim status: {info.status}") + + # A claimed service is detached from the pool and owned by the + # caller: delete it like any other sandbox when done. + sandbox = await AsyncSandbox.get_from_id(result.service_id, api_token=api_token) + try: + if not result.prewarmed: + # Cold path: the claimed service was provisioned on demand. + await wait_claim_ready_async(result, api_token=api_token) + print("✓ Claimed sandbox is ready") - # The pool owns the claimed sandbox's lifecycle — no delete here. - sandbox = await AsyncSandbox.get_from_id( - result.service_id, api_token=api_token - ) - out = await sandbox.exec("echo 'Hello from a claimed sandbox!'") - print(f" Output: {out.stdout.strip()}") + out = await sandbox.exec("echo 'Hello from a claimed sandbox!'") + print(f" Output: {out.stdout.strip()}") - # Replay demo: the same (pool_id, request_id) returns the same claim. - replay = await claim_async( - pool_id, request_id=result.request_id, api_token=api_token - ) - assert replay.service_id == result.service_id - print("✓ Replay with the same request_id returned the same service") + # Replay demo: the same (pool_id, request_id) returns the same + # claim — safe to retry after a network failure. + replay = await claim_async( + pool.id, request_id=result.request_id, api_token=api_token + ) + assert replay.service_id == result.service_id + print("✓ Replay with the same request_id returned the same service") + finally: + await sandbox.delete() + print("✓ Deleted the claimed sandbox service") return 0 except PoolClaimError as e: print(f"Claim failed: {e}") @@ -61,6 +68,9 @@ async def main() -> int: except SandboxError as e: print(f"Sandbox error: {e}") return 1 + finally: + await pool.delete() + print("✓ Deleted the pool") if __name__ == "__main__": diff --git a/examples/README.md b/examples/README.md index b326a894..1c74d2b8 100644 --- a/examples/README.md +++ b/examples/README.md @@ -42,8 +42,8 @@ uv run python examples/01_create_sandbox.py - **26_snapshot_boot_benchmark.py** - Benchmark snapshot boot times (sync) - **27_docker_in_docker.py** - Run containers inside a sandbox (docker-in-docker), building an image from scratch with no registry pull - **28_service_pool.py** - Service pool lifecycle: create, list, update, and delete a pool -- **29_pool_claim.py** - Claim a sandbox from a service pool (idempotent by request_id), then attach and use it -- **29_pool_claim_async.py** - Claim a sandbox from a service pool (async variant) +- **29_pool_claim.py** - Spawn a pool, claim a sandbox (idempotent by request_id), inspect the claim, run code, clean up both +- **29_pool_claim_async.py** - Spawn a pool, claim a sandbox, clean up both (async variant) - **30_sandbox_list.py** - List sandbox services with lazy handles, connect one via get_from_id - **30_sandbox_list_async.py** - List sandbox services with lazy handles (async variant) - **31_raise_on_error.py** - Opt-in exec errors: SandboxCommandError carries the failed CommandResult