volcano-sdk-python 0.6.7__py3-none-any.whl

volcano_sdk/_generated/models/variable.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.variable_deploy_source import check_variable_deploy_source
+from ..models.variable_deploy_source import VariableDeploySource
+from ..models.variable_status import check_variable_status
+from ..models.variable_status import VariableStatus
+from ..types import UNSET, Unset
+from typing import cast
+from uuid import UUID
+import datetime
+
+
+
+
+
+
+T = TypeVar("T", bound="Variable")
+
+
+
+@_attrs_define
+class Variable:
+    """ 
+        Attributes:
+            id (UUID):
+            project_id (UUID):
+            name (str):
+            value (str):
+            created_at (datetime.datetime):
+            updated_at (datetime.datetime):
+            status (VariableStatus | Unset): Latest project variable propagation status, when a sync has run.
+            current_sync_id (UUID | Unset): Identifier of the latest variable propagation sync.
+            provisioning_started_at (datetime.datetime | Unset): Timestamp when the current variable propagation phase
+                started.
+            deploy_source (VariableDeploySource | Unset): What initiated the latest variable propagation sync, when one has
+                run.
+     """
+
+    id: UUID
+    project_id: UUID
+    name: str
+    value: str
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    status: VariableStatus | Unset = UNSET
+    current_sync_id: UUID | Unset = UNSET
+    provisioning_started_at: datetime.datetime | Unset = UNSET
+    deploy_source: VariableDeploySource | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        id = str(self.id)
+
+        project_id = str(self.project_id)
+
+        name = self.name
+
+        value = self.value
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+        status: str | Unset = UNSET
+        if not isinstance(self.status, Unset):
+            status = self.status
+
+
+        current_sync_id: str | Unset = UNSET
+        if not isinstance(self.current_sync_id, Unset):
+            current_sync_id = str(self.current_sync_id)
+
+        provisioning_started_at: str | Unset = UNSET
+        if not isinstance(self.provisioning_started_at, Unset):
+            provisioning_started_at = self.provisioning_started_at.isoformat()
+
+        deploy_source: str | Unset = UNSET
+        if not isinstance(self.deploy_source, Unset):
+            deploy_source = self.deploy_source
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "id": id,
+            "project_id": project_id,
+            "name": name,
+            "value": value,
+            "created_at": created_at,
+            "updated_at": updated_at,
+        })
+        if status is not UNSET:
+            field_dict["status"] = status
+        if current_sync_id is not UNSET:
+            field_dict["current_sync_id"] = current_sync_id
+        if provisioning_started_at is not UNSET:
+            field_dict["provisioning_started_at"] = provisioning_started_at
+        if deploy_source is not UNSET:
+            field_dict["deploy_source"] = deploy_source
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = UUID(d.pop("id"))
+
+
+
+
+        project_id = UUID(d.pop("project_id"))
+
+
+
+
+        name = d.pop("name")
+
+        value = d.pop("value")
+
+        created_at = datetime.datetime.fromisoformat(d.pop("created_at"))
+
+
+
+
+        updated_at = datetime.datetime.fromisoformat(d.pop("updated_at"))
+
+
+
+
+        _status = d.pop("status", UNSET)
+        status: VariableStatus | Unset
+        if isinstance(_status,  Unset):
+            status = UNSET
+        else:
+            status = check_variable_status(_status)
+
+
+
+
+        _current_sync_id = d.pop("current_sync_id", UNSET)
+        current_sync_id: UUID | Unset
+        if isinstance(_current_sync_id,  Unset):
+            current_sync_id = UNSET
+        else:
+            current_sync_id = UUID(_current_sync_id)
+
+
+
+
+        _provisioning_started_at = d.pop("provisioning_started_at", UNSET)
+        provisioning_started_at: datetime.datetime | Unset
+        if isinstance(_provisioning_started_at,  Unset):
+            provisioning_started_at = UNSET
+        else:
+            provisioning_started_at = datetime.datetime.fromisoformat(_provisioning_started_at)
+
+
+
+
+        _deploy_source = d.pop("deploy_source", UNSET)
+        deploy_source: VariableDeploySource | Unset
+        if isinstance(_deploy_source,  Unset):
+            deploy_source = UNSET
+        else:
+            deploy_source = check_variable_deploy_source(_deploy_source)
+
+
+
+
+        variable = cls(
+            id=id,
+            project_id=project_id,
+            name=name,
+            value=value,
+            created_at=created_at,
+            updated_at=updated_at,
+            status=status,
+            current_sync_id=current_sync_id,
+            provisioning_started_at=provisioning_started_at,
+            deploy_source=deploy_source,
+        )
+
+
+        variable.additional_properties = d
+        return variable
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

volcano_sdk/_generated/models/variable_deploy_source.py

@@ -0,0 +1,10 @@
+from typing import Literal
+
+VariableDeploySource = Literal['api', 'cli', 'git', 'system', 'unknown', 'web']
+
+VARIABLE_DEPLOY_SOURCE_VALUES: set[VariableDeploySource] = { 'api', 'cli', 'git', 'system', 'unknown', 'web',  }
+
+def check_variable_deploy_source(value: str) -> VariableDeploySource:
+    if value in VARIABLE_DEPLOY_SOURCE_VALUES:
+        return value
+    raise TypeError(f"Unexpected value {value!r}. Expected one of {VARIABLE_DEPLOY_SOURCE_VALUES!r}")

volcano_sdk/_generated/models/variable_status.py

@@ -0,0 +1,10 @@
+from typing import Literal
+
+VariableStatus = Literal['active', 'failed', 'provisioning']
+
+VARIABLE_STATUS_VALUES: set[VariableStatus] = { 'active', 'failed', 'provisioning',  }
+
+def check_variable_status(value: str) -> VariableStatus:
+    if value in VARIABLE_STATUS_VALUES:
+        return value
+    raise TypeError(f"Unexpected value {value!r}. Expected one of {VARIABLE_STATUS_VALUES!r}")

volcano_sdk/_generated/types.py

@@ -0,0 +1,53 @@
+""" Contains some shared types for properties """
+
+from collections.abc import Mapping, MutableMapping
+from http import HTTPStatus
+from typing import BinaryIO, Generic, TypeVar, Literal, IO
+
+from attrs import define
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+# The types that `httpx.Client(files=)` can accept, copied from that library.
+FileContent = IO[bytes] | bytes | str
+FileTypes = (
+    # (filename, file (or bytes), content_type)
+    tuple[str | None, FileContent, str | None]
+    # (filename, file (or bytes), content_type, headers)
+    | tuple[str | None, FileContent, str | None, Mapping[str, str]]
+)
+RequestFiles = list[tuple[str, FileTypes]]
+
+@define
+class File:
+    """ Contains information for file uploads """
+
+    payload: BinaryIO
+    file_name: str | None = None
+    mime_type: str | None = None
+
+    def to_tuple(self) -> FileTypes:
+        """ Return a tuple representation that httpx will accept for multipart/form-data """
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """ A response from an endpoint """
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: T | None
+
+
+__all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"]

volcano_sdk/_lock_guard.py

@@ -0,0 +1,159 @@
+"""Thread-safe state for an automatically renewed lock lease."""
+
+from __future__ import annotations
+
+import threading
+import time
+from typing import TYPE_CHECKING
+
+from ._lock_renewer import renewal_delay as _calculate_renewal_delay
+
+if TYPE_CHECKING:
+    from .models import LockLease
+
+MAX_LOCK_LIFETIME_SECONDS = 7_776_000
+LOSS_POLL_INTERVAL_SECONDS = 1.0
+SUSPEND_AWARE_CLOCK_ID = getattr(time, "CLOCK_BOOTTIME", None)
+_LEASE_EXPIRED = "lock lease expired before renewal completed"
+_NO_SAFE_RENEWAL_WINDOW = "lock renewal returned no safe lease window"
+
+
+class _FallbackClock:
+    """Combine monotonic progress with suspend-aware wall time."""
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._monotonic = time.monotonic()
+        self._value = time.time()
+
+    def __call__(self) -> float:
+        with self._lock:
+            monotonic = time.monotonic()
+            elapsed = max(0.0, monotonic - self._monotonic)
+            self._monotonic = monotonic
+            self._value = max(self._value + elapsed, time.time())
+            return self._value
+
+
+_FALLBACK_CLOCK = _FallbackClock()
+
+
+def _lease_now() -> float:
+    clock_gettime = getattr(time, "clock_gettime", None)
+    if clock_gettime is None or SUSPEND_AWARE_CLOCK_ID is None:
+        return _FALLBACK_CLOCK()
+    return float(clock_gettime(SUSPEND_AWARE_CLOCK_ID))
+
+
+class LockGuard:
+    """Expose the latest lease and whether its ownership has been lost."""
+
+    def __init__(
+        self,
+        lease: LockLease,
+        *,
+        ttl: int,
+        started_at: float,
+    ) -> None:
+        """Track one acquired lease against its local monotonic deadline."""
+        self._state_lock = threading.Lock()
+        self._lease = lease
+        self._ttl = ttl
+        self._absolute_deadline = started_at + MAX_LOCK_LIFETIME_SECONDS
+        self._lease_deadline = min(started_at + ttl, self._absolute_deadline)
+        self._failure: Exception | None = None
+        self._lost = threading.Event()
+
+    @property
+    def lease(self) -> LockLease:
+        """Return the latest successfully renewed immutable lease."""
+        with self._state_lock:
+            return self._lease
+
+    @property
+    def lost(self) -> bool:
+        """Return whether renewal failed or the latest lease expired."""
+        with self._state_lock:
+            self._expire_if_needed_locked(_lease_now())
+            return self._lost.is_set()
+
+    def wait_lost(self, timeout: float | None = None) -> bool:
+        """Wait until ownership is lost or the timeout expires."""
+        timeout_deadline = None if timeout is None else _lease_now() + timeout
+        while True:
+            with self._state_lock:
+                now = _lease_now()
+                self._expire_if_needed_locked(now)
+                if self._lost.is_set():
+                    return True
+                wait = min(
+                    LOSS_POLL_INTERVAL_SECONDS,
+                    self._remaining_seconds_locked(now),
+                )
+            if timeout_deadline is not None:
+                timeout_remaining = timeout_deadline - _lease_now()
+                if timeout_remaining <= 0:
+                    return False
+                wait = min(wait, timeout_remaining)
+            self._lost.wait(wait)
+
+    def replace_lease(self, lease: LockLease, *, started_at: float) -> bool:
+        with self._state_lock:
+            now = _lease_now()
+            self._expire_if_needed_locked(now)
+            if self._lost.is_set():
+                return False
+            deadline = min(started_at + self._ttl, self._absolute_deadline)
+            if deadline <= now:
+                self._mark_lost_locked(TimeoutError(_LEASE_EXPIRED))
+                return False
+            if _calculate_renewal_delay(self._ttl, remaining=deadline - now) == 0:
+                self._mark_lost_locked(TimeoutError(_NO_SAFE_RENEWAL_WINDOW))
+                return False
+            self._lease = lease
+            self._lease_deadline = deadline
+            return True
+
+    def mark_lost(self, failure: Exception) -> None:
+        with self._state_lock:
+            self._expire_if_needed_locked(_lease_now())
+            self._mark_lost_locked(failure)
+
+    def _remaining_seconds(self) -> float:
+        with self._state_lock:
+            now = _lease_now()
+            self._expire_if_needed_locked(now)
+            return self._remaining_seconds_locked(now)
+
+    def renewal_delay(self) -> float:
+        with self._state_lock:
+            now = _lease_now()
+            self._expire_if_needed_locked(now)
+            if self._lost.is_set():
+                return 0.0
+            return _calculate_renewal_delay(
+                self._ttl,
+                remaining=self._remaining_seconds_locked(now),
+            )
+
+    def _renewal_failure(self) -> Exception | None:
+        with self._state_lock:
+            self._expire_if_needed_locked(_lease_now())
+            return self._failure
+
+    def _close(self) -> None:
+        with self._state_lock:
+            self._expire_if_needed_locked(_lease_now())
+            self._lost.set()
+
+    def _mark_lost_locked(self, failure: Exception) -> None:
+        if self._failure is None:
+            self._failure = failure
+        self._lost.set()
+
+    def _remaining_seconds_locked(self, now: float) -> float:
+        return max(0.0, self._lease_deadline - now)
+
+    def _expire_if_needed_locked(self, now: float) -> None:
+        if self._failure is None and self._remaining_seconds_locked(now) == 0:
+            self._mark_lost_locked(TimeoutError(_LEASE_EXPIRED))

volcano_sdk/_lock_renewer.py

@@ -0,0 +1,30 @@
+"""Renewal scheduling for automatically held lock leases."""
+
+from __future__ import annotations
+
+import secrets
+
+MAX_RENEWAL_DELAY_SECONDS = 60.0
+RENEWAL_SAFETY_MARGIN_SECONDS = 1.0
+RENEWAL_REQUEST_BUDGET_SECONDS = 1.0
+_JITTER_STEPS = 2_001
+_JITTER_SCALE = 10_000
+_MINIMUM_JITTER = 0.1
+
+
+def _renewal_jitter() -> float:
+    return (secrets.randbelow(_JITTER_STEPS) / _JITTER_SCALE) - _MINIMUM_JITTER
+
+
+def renewal_delay(ttl: int, *, remaining: float) -> float:
+    """Choose a jittered renewal time inside the current lease window."""
+    latest = max(
+        0.0,
+        remaining - RENEWAL_SAFETY_MARGIN_SECONDS - RENEWAL_REQUEST_BUDGET_SECONDS,
+    )
+    delay = min(ttl / 3, MAX_RENEWAL_DELAY_SECONDS, latest)
+    return min(
+        max(0.0, delay * (1 + _renewal_jitter())),
+        MAX_RENEWAL_DELAY_SECONDS,
+        latest,
+    )

volcano_sdk/_lock_worker.py

@@ -0,0 +1,104 @@
+"""Background renewal for one lock lease."""
+
+from __future__ import annotations
+
+import threading
+from typing import TYPE_CHECKING, Protocol
+
+from ._lock_guard import LockGuard, _lease_now
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+    from .models import LockLease
+
+RENEWER_SHUTDOWN_TIMEOUT_SECONDS = 1.0
+MAX_RENEWAL_WAIT_SLICE_SECONDS = 1.0
+_RENEWER_SHUTDOWN_TIMEOUT_MESSAGE = "lock renewal did not stop before cleanup"
+
+
+class LockRenewalClient(Protocol):
+    """Lock facade capability required by the renewal worker."""
+
+    def renew(self, key: str, lease: LockLease, *, ttl: int) -> LockLease:
+        """Renew one lease."""
+        ...
+
+
+class _RenewalFailureRecorder:
+    def __init__(self, guard: LockGuard) -> None:
+        self._guard = guard
+
+    def __enter__(self) -> None:
+        return None
+
+    def __exit__(
+        self,
+        exception_type: type[BaseException] | None,
+        exception: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool:
+        del exception_type, traceback
+        if not isinstance(exception, Exception):
+            return False
+        self._guard.mark_lost(exception)
+        return True
+
+
+class LockRenewer:
+    """Renew a guarded lease until stopped or ownership is lost."""
+
+    def __init__(
+        self,
+        locks: LockRenewalClient,
+        key: str,
+        guard: LockGuard,
+        *,
+        ttl: int,
+    ) -> None:
+        self._locks = locks
+        self._key = key
+        self._guard = guard
+        self._ttl = ttl
+        self._stop = threading.Event()
+        self._thread = threading.Thread(target=self._run, daemon=True)
+
+    def start(self) -> None:
+        """Start renewing the guarded lease."""
+        self._thread.start()
+
+    def stop(self) -> None:
+        """Stop renewal without waiting indefinitely for a request."""
+        self._stop.set()
+        self._thread.join(timeout=RENEWER_SHUTDOWN_TIMEOUT_SECONDS)
+        if self._thread.is_alive():
+            self._guard.mark_lost(TimeoutError(_RENEWER_SHUTDOWN_TIMEOUT_MESSAGE))
+
+    def _run(self) -> None:
+        with _RenewalFailureRecorder(self._guard):
+            while self._wait_until_renewal():
+                if not self._renew_once():
+                    return
+
+    def _wait_until_renewal(self) -> bool:
+        renew_at = _lease_now() + self._guard.renewal_delay()
+        while not self._stop.is_set():
+            if self._guard.lost:
+                return False
+            remaining = renew_at - _lease_now()
+            if remaining <= 0:
+                return True
+            if self._stop.wait(min(remaining, MAX_RENEWAL_WAIT_SLICE_SECONDS)):
+                return False
+        return False
+
+    def _renew_once(self) -> bool:
+        started_at = _lease_now()
+        with _RenewalFailureRecorder(self._guard):
+            lease = self._locks.renew(
+                self._key,
+                self._guard.lease,
+                ttl=self._ttl,
+            )
+            return self._guard.replace_lease(lease, started_at=started_at)
+        return False