vers-sdk 0.1.1__tar.gz

vers_sdk-0.1.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: vers-sdk
+Version: 0.1.1
+Summary: SDK for Orchestrator Control Plane API
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/hdresearch/python-sdk
+Project-URL: Repository, https://github.com/hdresearch/python-sdk
+Keywords: vers,sdk,api,vm,orchestration
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.24

vers_sdk-0.1.1/README.md

@@ -0,0 +1,81 @@
+# Vers Python API Library
+
+This library provides convenient access to the [Vers](https://hdr.is) REST API from Python.
+
+It is generated with [Sterling](https://github.com/hdresearch/sterling).
+
+## Installation
+
+```sh
+pip install vers-sdk
+```
+
+## Usage
+
+```python
+import asyncio
+from vers_sdk import VersSdkClient
+
+async def main():
+    client = VersSdkClient(
+        api_key="your-api-key",  # or set VERS_API_KEY env var
+    )
+
+    # List all VMs
+    response = await client.list_vms()
+    print(response.json())
+
+    # Create a new root VM
+    vm = await client.create_new_root_vm(body={"vm_config": {}})
+    print(vm.json())
+
+    await client.close()
+
+asyncio.run(main())
+```
+
+## Configuration
+
+```python
+client = VersSdkClient(
+    api_key="your-api-key",       # or set VERS_API_KEY env var
+    base_url="https://api.vers.sh", # or set VERS_BASE_URL env var
+    max_retries=2,
+    timeout=30.0,
+    http_client=custom_httpx_client,  # optional custom httpx.AsyncClient
+)
+```
+
+## Error handling
+
+```python
+from vers_sdk.errors import APIError, NotFoundError, RateLimitError
+
+try:
+    await client.delete_vm("nonexistent-id")
+except NotFoundError as e:
+    print(f"Not found: {e.status} {e.message}")
+except APIError as e:
+    print(f"API error: {e.status}")
+```
+
+## Retries
+
+Requests are automatically retried up to 2 times on 5xx errors and connection failures,
+with exponential backoff and jitter. The client respects `Retry-After` headers (capped at 60s).
+
+## Async context manager
+
+```python
+async with VersSdkClient(api_key="...") as client:
+    vms = await client.list_vms()
+```
+
+## Requirements
+
+- Python 3.10+
+- httpx
+
+## License
+
+MIT

vers_sdk-0.1.1/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "vers-sdk"
+version = "0.1.1"
+description = "SDK for Orchestrator Control Plane API"
+requires-python = ">=3.10"
+license = "MIT"
+keywords = ["vers", "sdk", "api", "vm", "orchestration"]
+dependencies = ["httpx>=0.24"]
+
+[project.urls]
+Homepage = "https://github.com/hdresearch/python-sdk"
+Repository = "https://github.com/hdresearch/python-sdk"
+
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]

vers_sdk-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vers_sdk-0.1.1/src/vers_sdk/__init__.py

@@ -0,0 +1,34 @@
+# Generated by Sterling SDK Generator
+# Orchestrator Control Plane API v0.1.0
+
+from .client import VersSdkClient
+from .errors import (
+    VersSDKError,
+    APIError,
+    APIConnectionError,
+    APIConnectionTimeoutError,
+    BadRequestError,
+    AuthenticationError,
+    PermissionDeniedError,
+    NotFoundError,
+    ConflictError,
+    UnprocessableEntityError,
+    RateLimitError,
+    InternalServerError,
+)
+
+__all__ = [
+    "VersSdkClient",
+    "VersSDKError",
+    "APIError",
+    "APIConnectionError",
+    "APIConnectionTimeoutError",
+    "BadRequestError",
+    "AuthenticationError",
+    "PermissionDeniedError",
+    "NotFoundError",
+    "ConflictError",
+    "UnprocessableEntityError",
+    "RateLimitError",
+    "InternalServerError",
+]

vers_sdk-0.1.1/src/vers_sdk/client.py

@@ -0,0 +1,529 @@
+# Generated by Sterling SDK Generator
+# Orchestrator Control Plane API v0.1.0
+
+import asyncio
+import calendar
+import email.utils
+import logging
+import os
+import random
+import time as _time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+import httpx
+
+from .errors import APIError, APIConnectionError
+from .models import *  # noqa: F403
+
+
+@dataclass
+class RequestOptions:
+    """Per-request options that override client defaults."""
+
+    #: Additional headers to send with the request.
+    #: Set a header to None to remove it.
+    headers: dict[str, str | None] | None = None
+
+    #: Request timeout in seconds. Overrides the client-level timeout.
+    timeout: float | None = None
+
+logger = logging.getLogger("vers_sdk")
+
+_LOG_LEVEL_MAP = {
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warn": logging.WARNING,
+    "error": logging.ERROR,
+    "off": logging.CRITICAL + 1,
+}
+
+
+def _configure_logger() -> None:
+    env_level = os.environ.get("VERS_LOG", "warn").lower()
+    level = _LOG_LEVEL_MAP.get(env_level, logging.WARNING)
+    logger.setLevel(level)
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("%(asctime)s [vers_sdk %(levelname)s] %(message)s"))
+        logger.addHandler(handler)
+
+
+_configure_logger()
+
+
+# Status codes that are retryable even though they are 4xx
+RETRYABLE_STATUS_CODES = {408, 409, 429}
+
+
+def _is_retryable_status(status: int) -> bool:
+    return status >= 500 or status in RETRYABLE_STATUS_CODES
+
+
+def _retry_delay(attempt: int) -> float:
+    base = 0.5 * (2 ** attempt)
+    jitter = random.random() * base * 0.25
+    return base + jitter
+
+
+def _parse_retry_after(header_value: Optional[str]) -> Optional[float]:
+    if header_value is None:
+        return None
+    try:
+        delay = float(header_value)
+        return min(max(delay, 0.0), 60.0)
+    except (ValueError, OverflowError):
+        pass
+    parsed = email.utils.parsedate(header_value)
+    if parsed is not None:
+        retry_time = calendar.timegm(parsed)
+        delay = retry_time - _time.time()
+        return min(max(delay, 0.0), 60.0)
+    return None
+
+
+class VersSdkClient:
+    """Client for Orchestrator Control Plane API"""
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        headers: Optional[dict[str, str | None]] = None,
+        max_retries: int = 2,
+        timeout: float = 30.0,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ):
+        self.base_url = base_url or os.environ.get("VERS_BASE_URL", "https://api.vers.sh")
+        self.api_key = api_key or os.environ.get("VERS_API_KEY")
+        self.max_retries = max_retries
+        self.timeout = timeout
+        self._custom_headers: dict[str, str | None] = headers or {}
+        if http_client is not None:
+            self._client = http_client
+        else:
+            import platform as _platform
+            default_headers: dict[str, str] = {
+                "User-Agent": f"vers-sdk/0.1.1 python/{_platform.python_version()} {_platform.system().lower()}/{_platform.machine()}",
+            }
+            if self.api_key:
+                default_headers["Authorization"] = f"Bearer {self.api_key}"
+            merged = self._merge_headers(default_headers, self._custom_headers)
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers=merged,
+                timeout=self.timeout,
+            )
+
+    @staticmethod
+    def _merge_headers(*sources: Optional[dict[str, str | None]]) -> dict[str, str]:
+        """Merge header dicts. Later sources override earlier ones (case-insensitive).
+        A ``None`` value removes the header."""
+        merged: dict[str, str] = {}
+        for source in sources:
+            if source is None:
+                continue
+            for key, value in source.items():
+                if value is None:
+                    # Remove header (case-insensitive)
+                    merged = {
+                        k: v for k, v in merged.items()
+                        if k.lower() != key.lower()
+                    }
+                else:
+                    merged[key] = value
+        return merged
+
+    def _check_response(self, response: httpx.Response) -> None:
+        if response.is_success:
+            return
+        body: Any = None
+        message: str | None = None
+        try:
+            body = response.json()
+        except Exception:
+            message = response.text
+        headers = dict(response.headers)
+        raise APIError.generate(
+            status=response.status_code,
+            body=body,
+            message=message,
+            headers=headers,
+        )
+
+    async def _request(self, method: str, path: str, options: RequestOptions | None = None, **kwargs: Any) -> httpx.Response:
+        logger.debug("request: %s %s", method, path)
+
+        req_headers: dict[str, str] = kwargs.pop("headers", {})
+        if method.upper() in ("POST", "PUT", "PATCH", "DELETE"):
+            req_headers["X-Idempotency-Key"] = str(uuid.uuid4())
+        # Apply per-request header overrides
+        if options and options.headers:
+            for k, v in options.headers.items():
+                if v is None:
+                    req_headers.pop(k, None)
+                else:
+                    req_headers[k] = v
+        if req_headers:
+            kwargs["headers"] = req_headers
+        effective_timeout = options.timeout if options and options.timeout is not None else None
+
+        last_exc: Optional[Exception] = None
+        retry_after_used = False
+        for attempt in range(self.max_retries + 1):
+            if attempt > 0 and not retry_after_used:
+                logger.info("retry attempt %d/%d for %s %s", attempt, self.max_retries, method, path)
+                await asyncio.sleep(_retry_delay(attempt - 1))
+            retry_after_used = False
+            try:
+                req_kwargs = dict(kwargs)
+                if effective_timeout is not None:
+                    req_kwargs["timeout"] = effective_timeout
+                response = await self._client.request(method, path, **req_kwargs)
+                # Remove headers that were set to None
+                logger.debug("response: %d for %s %s", response.status_code, method, path)
+                if _is_retryable_status(response.status_code) and attempt < self.max_retries:
+                    ra_delay = _parse_retry_after(response.headers.get("retry-after"))
+                    if ra_delay is not None:
+                        retry_after_used = True
+                        logger.info("retry attempt %d/%d for %s %s (retry-after: %.1fs)", attempt + 1, self.max_retries, method, path, ra_delay)
+                        await asyncio.sleep(ra_delay)
+                    last_exc = Exception(f"HTTP {response.status_code}")
+                    continue
+                self._check_response(response)
+                return response
+            except APIError:
+                raise
+            except (httpx.ConnectError, httpx.TimeoutException) as exc:
+                logger.error("connection error: %s %s - %s", method, path, exc)
+                if attempt == self.max_retries:
+                    raise APIConnectionError(cause=exc) from exc
+                last_exc = exc
+        raise last_exc  # type: ignore[misc]
+
+    async def resize_vm_disk(self, vm_id: str, body: dict[str, Any], params: ResizeVmDiskParams | None = None, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/{vm_id}/disk"
+        query: dict[str, Any] = {}
+        if params is not None:
+            if params.skip_wait_boot is not None:
+                query["skip_wait_boot"] = params.skip_wait_boot
+        return await self._request("PATCH", path, options, json=body, params=query)
+
+    async def exec_vm_stream_attach(self, vm_id: str, body: dict[str, Any], options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/{vm_id}/exec/stream/attach"
+        return await self._request("POST", path, options, json=body)
+
+    async def create_new_root_vm(self, body: dict[str, Any], params: CreateNewRootVmParams | None = None, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/vm/new_root"
+        query: dict[str, Any] = {}
+        if params is not None:
+            if params.wait_boot is not None:
+                query["wait_boot"] = params.wait_boot
+        return await self._request("POST", path, options, json=body, params=query)
+
+    async def vm_logs(self, vm_id: str, params: VmLogsParams | None = None, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/{vm_id}/logs"
+        query: dict[str, Any] = {}
+        if params is not None:
+            if params.offset is not None:
+                query["offset"] = params.offset
+            if params.max_entries is not None:
+                query["max_entries"] = params.max_entries
+            if params.stream is not None:
+                query["stream"] = params.stream
+        return await self._request("GET", path, options, params=query)
+
+    async def branch_by_ref(self, repo_name: str, tag_name: str, body: dict[str, Any] | None = None, params: BranchByRefParams | None = None, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/branch/by_ref/{repo_name}/{tag_name}"
+        query: dict[str, Any] = {}
+        if params is not None:
+            if params.count is not None:
+                query["count"] = params.count
+        return await self._request("POST", path, options, json=body, params=query)
+
+    async def list_public_commits(self, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/commits/public"
+        return await self._request("GET", path, options)
+
+    async def list_public_repo_tags(self, org_name: str, repo_name: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/public/repositories/{org_name}/{repo_name}/tags"
+        return await self._request("GET", path, options)
+
+    async def branch_by_tag(self, tag_name: str, body: dict[str, Any] | None = None, params: BranchByTagParams | None = None, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/branch/by_tag/{tag_name}"
+        query: dict[str, Any] = {}
+        if params is not None:
+            if params.count is not None:
+                query["count"] = params.count
+        return await self._request("POST", path, options, json=body, params=query)
+
+    async def branch_vm(self, vm_or_commit_id: str, body: dict[str, Any] | None = None, params: BranchVmParams | None = None, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/{vm_or_commit_id}/branch"
+        query: dict[str, Any] = {}
+        if params is not None:
+            if params.keep_paused is not None:
+                query["keep_paused"] = params.keep_paused
+            if params.skip_wait_boot is not None:
+                query["skip_wait_boot"] = params.skip_wait_boot
+            if params.count is not None:
+                query["count"] = params.count
+        return await self._request("POST", path, options, json=body, params=query)
+
+    async def get_repo_tag(self, repo_name: str, tag_name: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/repositories/{repo_name}/tags/{tag_name}"
+        return await self._request("GET", path, options)
+
+    async def delete_repo_tag(self, repo_name: str, tag_name: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/repositories/{repo_name}/tags/{tag_name}"
+        return await self._request("DELETE", path, options)
+
+    async def update_repo_tag(self, repo_name: str, tag_name: str, body: dict[str, Any], options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/repositories/{repo_name}/tags/{tag_name}"
+        return await self._request("PATCH", path, options, json=body)
+
+    async def get_repository(self, repo_name: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/repositories/{repo_name}"
+        return await self._request("GET", path, options)
+
+    async def delete_repository(self, repo_name: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/repositories/{repo_name}"
+        return await self._request("DELETE", path, options)
+
+    async def list_parent_commits(self, commit_id: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/commits/{commit_id}/parents"
+        return await self._request("GET", path, options)
+
+    async def update_vm_state(self, vm_id: str, body: dict[str, Any], params: UpdateVmStateParams | None = None, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/{vm_id}/state"
+        query: dict[str, Any] = {}
+        if params is not None:
+            if params.skip_wait_boot is not None:
+                query["skip_wait_boot"] = params.skip_wait_boot
+        return await self._request("PATCH", path, options, json=body, params=query)
+
+    async def fork_repository(self, body: dict[str, Any], options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/repositories/fork"
+        return await self._request("POST", path, options, json=body)
+
+    async def list_repositories(self, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/repositories"
+        return await self._request("GET", path, options)
+
+    async def create_repository(self, body: dict[str, Any], options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/repositories"
+        return await self._request("POST", path, options, json=body)
+
+    async def restore_from_commit(self, body: dict[str, Any], options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/vm/from_commit"
+        return await self._request("POST", path, options, json=body)
+
+    async def get_domain(self, domain_id: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/domains/{domain_id}"
+        return await self._request("GET", path, options)
+
+    async def delete_domain(self, domain_id: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/domains/{domain_id}"
+        return await self._request("DELETE", path, options)
+
+    async def list_tags(self, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/commit_tags"
+        return await self._request("GET", path, options)
+
+    async def create_tag(self, body: dict[str, Any], options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/commit_tags"
+        return await self._request("POST", path, options, json=body)
+
+    async def list_public_repositories(self, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/public/repositories"
+        return await self._request("GET", path, options)
+
+    async def get_public_repo_tag(self, org_name: str, repo_name: str, tag_name: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/public/repositories/{org_name}/{repo_name}/tags/{tag_name}"
+        return await self._request("GET", path, options)
+
+    async def get_vm_metadata(self, vm_id: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/{vm_id}/metadata"
+        return await self._request("GET", path, options)
+
+    async def list_env_vars(self, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/env_vars"
+        return await self._request("GET", path, options)
+
+    async def set_env_vars(self, body: dict[str, Any], options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/env_vars"
+        return await self._request("PUT", path, options, json=body)
+
+    async def delete_vm(self, vm_id: str, params: DeleteVmParams | None = None, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/{vm_id}"
+        query: dict[str, Any] = {}
+        if params is not None:
+            if params.skip_wait_boot is not None:
+                query["skip_wait_boot"] = params.skip_wait_boot
+        return await self._request("DELETE", path, options, params=query)
+
+    async def list_commits(self, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/commits"
+        return await self._request("GET", path, options)
+
+    async def get_tag(self, tag_name: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/commit_tags/{tag_name}"
+        return await self._request("GET", path, options)
+
+    async def delete_tag(self, tag_name: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/commit_tags/{tag_name}"
+        return await self._request("DELETE", path, options)
+
+    async def update_tag(self, tag_name: str, body: dict[str, Any], options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/commit_tags/{tag_name}"
+        return await self._request("PATCH", path, options, json=body)
+
+    async def branch_by_vm(self, vm_id: str, body: dict[str, Any] | None = None, params: BranchByVmParams | None = None, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/branch/by_vm/{vm_id}"
+        query: dict[str, Any] = {}
+        if params is not None:
+            if params.keep_paused is not None:
+                query["keep_paused"] = params.keep_paused
+            if params.skip_wait_boot is not None:
+                query["skip_wait_boot"] = params.skip_wait_boot
+            if params.count is not None:
+                query["count"] = params.count
+        return await self._request("POST", path, options, json=body, params=query)
+
+    async def delete_env_var(self, key: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/env_vars/{key}"
+        return await self._request("DELETE", path, options)
+
+    async def exec_vm_stream(self, vm_id: str, body: dict[str, Any], options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/{vm_id}/exec/stream"
+        return await self._request("POST", path, options, json=body)
+
+    async def commit_vm(self, vm_id: str, body: dict[str, Any] | None = None, params: CommitVmParams | None = None, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/{vm_id}/commit"
+        query: dict[str, Any] = {}
+        if params is not None:
+            if params.keep_paused is not None:
+                query["keep_paused"] = params.keep_paused
+            if params.skip_wait_boot is not None:
+                query["skip_wait_boot"] = params.skip_wait_boot
+        return await self._request("POST", path, options, json=body, params=query)
+
+    async def delete_commit(self, commit_id: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/commits/{commit_id}"
+        return await self._request("DELETE", path, options)
+
+    async def update_commit(self, commit_id: str, body: dict[str, Any], options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/commits/{commit_id}"
+        return await self._request("PATCH", path, options, json=body)
+
+    async def list_repo_tags(self, repo_name: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/repositories/{repo_name}/tags"
+        return await self._request("GET", path, options)
+
+    async def create_repo_tag(self, repo_name: str, body: dict[str, Any], options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/repositories/{repo_name}/tags"
+        return await self._request("POST", path, options, json=body)
+
+    async def ssh_key(self, vm_id: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/{vm_id}/ssh_key"
+        return await self._request("GET", path, options)
+
+    async def exec_vm(self, vm_id: str, body: dict[str, Any], options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/{vm_id}/exec"
+        return await self._request("POST", path, options, json=body)
+
+    async def set_repository_visibility(self, repo_name: str, body: dict[str, Any], options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/repositories/{repo_name}/visibility"
+        return await self._request("PATCH", path, options, json=body)
+
+    async def list_vms(self, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/vms"
+        return await self._request("GET", path, options)
+
+    async def list_domains(self, params: ListDomainsParams | None = None, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/domains"
+        query: dict[str, Any] = {}
+        if params is not None:
+            if params.vm_id is not None:
+                query["vm_id"] = params.vm_id
+        return await self._request("GET", path, options, params=query)
+
+    async def create_domain(self, body: dict[str, Any], options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = "/api/v1/domains"
+        return await self._request("POST", path, options, json=body)
+
+    async def vm_status(self, vm_id: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/{vm_id}/status"
+        return await self._request("GET", path, options)
+
+    async def get_public_repository(self, org_name: str, repo_name: str, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/public/repositories/{org_name}/{repo_name}"
+        return await self._request("GET", path, options)
+
+    async def branch_by_commit(self, commit_id: str, body: dict[str, Any] | None = None, params: BranchByCommitParams | None = None, options: RequestOptions | None = None) -> httpx.Response:
+        """"""
+        path = f"/api/v1/vm/branch/by_commit/{commit_id}"
+        query: dict[str, Any] = {}
+        if params is not None:
+            if params.count is not None:
+                query["count"] = params.count
+        return await self._request("POST", path, options, json=body, params=query)
+
+    async def close(self) -> None:
+        await self._client.aclose()
+
+    async def __aenter__(self) -> "VersSdkClient":
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.close()