chalkcompute 2.1.2__tar.gz → 2.1.8__tar.gz

{chalkcompute-2.1.2 → chalkcompute-2.1.8}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: chalkcompute
-Version: 2.1.2
+Version: 2.1.8
 Requires-Dist: grpcio>=1.60.0
 Requires-Dist: protobuf>=4.25.0
 Requires-Dist: httpx>=0.25.0
 Requires-Dist: blake3>=1.0.0
-Requires-Dist: chalk-remote-call-python>=1.6.3
+Requires-Dist: chalk-remote-call-python>=1.8.1
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: opentelemetry-api>=1.20.0
 Requires-Dist: opentelemetry-sdk>=1.20.0
@@ -25,6 +25,10 @@ Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 
 Python SDK for the Chalk Sandbox gRPC service. Create sandboxes, execute commands, and stream output over bidirectional gRPC streams.
 
+Contributor note: for testing deployed functions against local `chalkcompute`
+or local `chalk-remote-call-python` changes, see
+`local-sdk-remote-call-testing.md`.
+
 ## Install
 
 ```

{chalkcompute-2.1.2 → chalkcompute-2.1.8}/README.md

@@ -2,6 +2,10 @@
 
 Python SDK for the Chalk Sandbox gRPC service. Create sandboxes, execute commands, and stream output over bidirectional gRPC streams.
 
+Contributor note: for testing deployed functions against local `chalkcompute`
+or local `chalk-remote-call-python` changes, see
+`local-sdk-remote-call-testing.md`.
+
 ## Install
 
 ```

{chalkcompute-2.1.2 → chalkcompute-2.1.8}/chalkcompute/__init__.py

@@ -18,6 +18,7 @@ _LAZY_MAP: dict[str, tuple[str, str]] = {
     "AllowedRoute": ("chalkcompute._container", "AllowedRoute"),
     "ImageBuildError": ("chalkcompute._container", "ImageBuildError"),
     "KernelPolicy": ("chalkcompute._container", "KernelPolicy"),
+    "ComputeClass": ("chalkcompute._container", "ComputeClass"),
     "NetworkPolicy": ("chalkcompute._container", "NetworkPolicy"),
     "PortRange": ("chalkcompute._container", "PortRange"),
     # _cls.py
@@ -65,6 +66,7 @@ _LAZY_MAP: dict[str, tuple[str, str]] = {
     "LazyLocalFile": ("chalkcompute._image", "LazyLocalFile"),
     # _secret.py
     "Secret": ("chalkcompute._secret", "Secret"),
+    "resolve_lazy_secrets": ("chalkcompute._secret", "resolve_lazy_secrets"),
     # _sandbox.py
     "ExecError": ("chalkcompute._sandbox", "ExecError"),
     "ExecEvent": ("chalkcompute._sandbox", "ExecEvent"),
@@ -92,6 +94,10 @@ _LAZY_MAP: dict[str, tuple[str, str]] = {
     "VolumeFileNotFoundError": ("chalkcompute._volume", "VolumeFileNotFoundError"),
     "VolumeInfo": ("chalkcompute._volume", "VolumeInfo"),
     "VolumeNotFoundError": ("chalkcompute._volume", "VolumeNotFoundError"),
+    "resolve_referenced_volume_type": (
+        "chalkcompute._volume",
+        "resolve_referenced_volume_type",
+    ),
     # _vvolume.py
     "VersionInfo": ("chalkcompute._vvolume", "VersionInfo"),
     "VersionedVolume": ("chalkcompute._vvolume", "VersionedVolume"),

{chalkcompute-2.1.2 → chalkcompute-2.1.8}/chalkcompute/__init__.pyi

@@ -18,6 +18,7 @@ from chalkcompute._container import ContainerInfo as ContainerInfo
 from chalkcompute._container import ContainerSecurityPolicy as ContainerSecurityPolicy
 from chalkcompute._container import ExecResult as ContainerExecResult
 from chalkcompute._container import ImageBuildError as ImageBuildError
+from chalkcompute._container import ComputeClass as ComputeClass
 from chalkcompute._container import KernelPolicy as KernelPolicy
 from chalkcompute._container import NetworkPolicy as NetworkPolicy
 from chalkcompute._container import PortRange as PortRange
@@ -55,6 +56,7 @@ from chalkcompute._scaling_group import ScalingGroupBuildError as ScalingGroupBu
 from chalkcompute._scaling_group import ScalingGroupError as ScalingGroupError
 from chalkcompute._scaling_group import ScalingGroupInfo as ScalingGroupInfo
 from chalkcompute._secret import Secret as Secret
+from chalkcompute._secret import resolve_lazy_secrets as resolve_lazy_secrets
 from chalkcompute._tracing import span as span
 from chalkcompute._tracing import traced as traced
 from chalkcompute._volume import FileInfo as FileInfo
@@ -66,6 +68,9 @@ from chalkcompute._volume import VolumeError as VolumeError
 from chalkcompute._volume import VolumeFileNotFoundError as VolumeFileNotFoundError
 from chalkcompute._volume import VolumeInfo as VolumeInfo
 from chalkcompute._volume import VolumeNotFoundError as VolumeNotFoundError
+from chalkcompute._volume import (
+    resolve_referenced_volume_type as resolve_referenced_volume_type,
+)
 from chalkcompute._vvolume import VersionInfo as VersionInfo
 from chalkcompute._vvolume import VersionedVolume as VersionedVolume
 from chalkcompute._vvolume import VersionedVolumeClient as VersionedVolumeClient
@@ -78,6 +83,7 @@ __all__ = [
     "ContainerExecResult",
     "AllowedRoute",
     "ImageBuildError",
+    "ComputeClass",
     "KernelPolicy",
     "NetworkPolicy",
     "PortRange",
@@ -113,6 +119,7 @@ __all__ = [
     "Image",
     "LazyLocalFile",
     "Secret",
+    "resolve_lazy_secrets",
     "ExecError",
     "ExecEvent",
     "ExecProcess",
@@ -137,6 +144,7 @@ __all__ = [
     "VolumeFileNotFoundError",
     "VolumeInfo",
     "VolumeNotFoundError",
+    "resolve_referenced_volume_type",
     "VersionInfo",
     "VersionedVolume",
     "VersionedVolumeClient",

{chalkcompute-2.1.2 → chalkcompute-2.1.8}/chalkcompute/_auth_config.py

@@ -152,11 +152,7 @@ def load_token(
             activeEnvironment=active_environment,
         )
 
-    global_cfg = (
-        _load_global_config_uncached()
-        if skip_cache
-        else _load_global_config()
-    )
+    global_cfg = _load_global_config_uncached() if skip_cache else _load_global_config()
     if global_cfg is None:
         return None
 
@@ -186,7 +182,9 @@ def _load_project_config_at_path(filename: Path) -> ProjectSettings | None:
     except OSError:
         return None
     except ValueError as exc:
-        raise ValueError(f"Failed to load project config from {filename}: {exc}") from exc
+        raise ValueError(
+            f"Failed to load project config from {filename}: {exc}"
+        ) from exc
 
 
 def load_project_config() -> ProjectSettings | None:

{chalkcompute-2.1.2 → chalkcompute-2.1.8}/chalkcompute/_cls.py

@@ -54,15 +54,8 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, TypeVar, overload
 
+from chalkcompute._concurrency import ConcurrencyPolicy
 from chalkcompute._connect import ConnectClient
-from chalkcompute._naming import sanitize_dns_label, validate_dns_label, validate_env
-from chalkcompute._tracing import _instrumented
-from chalkcompute._volume import (
-    VolumeDriver,
-    VolumeMount,
-    _resolve_driver,
-    resolve_referenced_volume_type,
-)
 from chalkcompute._function import (
     _CATALOG_SVC,
     _REMOTE_ENV_VAR,
@@ -85,10 +78,18 @@ from chalkcompute._function import (
     _source_text_for_deploy,
     _write_temp,
 )
-from chalkcompute._concurrency import ConcurrencyPolicy
+from chalkcompute._naming import sanitize_dns_label, validate_dns_label, validate_env
 from chalkcompute._quota import QueuePolicy
 from chalkcompute._rate_limit import RateLimitPolicy
 from chalkcompute._retry import RetryPolicy
+from chalkcompute._tracing import _instrumented
+from chalkcompute._volume import (
+    VolumeDriver,
+    VolumeMount,
+    cleanup_owned_volumes,
+    resolve_referenced_volume_type,
+)
+from chalkcompute._vvolume import VersionedVolumeClient
 
 if TYPE_CHECKING:
     from chalkcompute._image import Image as _Image
@@ -1163,8 +1164,7 @@ class RemoteClass:
                 if resp.status_code != 200:
                     progress_fail(mkey)
                     raise ClassBuildError(
-                        f"CreateExternalFunctionVersion failed for "
-                        f"'{func_name}': {resp.text}"
+                        f"CreateExternalFunctionVersion failed for '{func_name}': {resp.text}"
                     )
 
                 data = resp.json()
@@ -1294,9 +1294,10 @@ class RemoteClass:
         if self._volumes:
             # Driver is used here only to perform the delete action, not to
             # derive a mount type.
-            driver = self._volume_driver or _resolve_driver(self._client)
-            for v in self._volumes:
-                driver.delete_volume(v.name)
+            driver = self._volume_driver or VersionedVolumeClient.from_connect(
+                self._client
+            )
+            cleanup_owned_volumes(driver, self._volumes, self._referenced_volumes)
         self._volumes = []
         self._volume_driver = None
         self._deployed = False

{chalkcompute-2.1.2 → chalkcompute-2.1.8}/chalkcompute/_concurrency.py

@@ -26,9 +26,7 @@ class ConcurrencyPolicy:
         return d
 
     @classmethod
-    def from_int_or_policy(
-        cls, value: int | ConcurrencyPolicy
-    ) -> ConcurrencyPolicy:
+    def from_int_or_policy(cls, value: int | ConcurrencyPolicy) -> ConcurrencyPolicy:
         if isinstance(value, bool):
             raise TypeError(f"Expected int or {cls.__name__}, got bool")
         if isinstance(value, int):

{chalkcompute-2.1.2 → chalkcompute-2.1.8}/chalkcompute/_connect.py

@@ -44,6 +44,38 @@ def service_auth_context_from_env() -> ServiceAuthContext | None:
         return None
 
 
+def chalk_client_from_env(
+    *,
+    api_server: str | None = None,
+    environment: str | None = None,
+    additional_headers: dict[str, str] | None = None,
+    **kwargs: Any,
+) -> Any:
+    from chalk.client import ChalkClient
+
+    headers = additional_headers
+    has_authorization = any(key.lower() == "authorization" for key in headers or {})
+    service_auth = service_auth_context_from_env()
+    if service_auth is not None and not has_authorization:
+        client = ConnectClient()
+        client._ensure_auth()
+        assert client._access_token is not None
+        assert client._api_server is not None
+        headers = {
+            **(headers or {}),
+            "Authorization": f"Bearer {client._access_token}",
+        }
+        api_server = api_server or client._api_server
+        environment = environment or service_auth.environment_id
+
+    if api_server is not None:
+        kwargs["api_server"] = api_server
+    if environment is not None:
+        kwargs["environment"] = environment
+    kwargs["additional_headers"] = headers
+    return ChalkClient(**kwargs)
+
+
 class ConnectClient:
     """Authenticated Connect-protocol (HTTP/JSON) client for Chalk APIs.
 
@@ -97,6 +129,14 @@ class ConnectClient:
             resp.raise_for_status()
             data = resp.json()
             self._access_token = data.get("accessToken") or data["access_token"]
+            self._grpc_engines = _string_map(
+                data.get("grpcEngines")
+                or data.get("grpc_engines")
+                or data.get("engines"),
+            )
+            self._environment_id_to_name = _string_map(
+                data.get("environment_id_to_name") or data.get("environmentIdToName"),
+            )
             self._env_id = self._resolve_environment_id(service_auth.environment_id)
             self._headers = {
                 "Content-Type": "application/json",
@@ -430,12 +470,16 @@ def build_image_with_volumes(
     from chalkcompute._volume import VolumeClient
 
     image_uri = build_image(
-        client, image, poll_interval=poll_interval, timeout=timeout,
+        client,
+        image,
+        poll_interval=poll_interval,
+        timeout=timeout,
     )
     volumes: list[VolumeMount] = []
     if image.lazy_local_files:
         volumes = VolumeClient.from_connect(client).upload_lazy_files(
-            image, volume_prefix=volume_prefix,
+            image,
+            volume_prefix=volume_prefix,
         )
     return image_uri, volumes
 

{chalkcompute-2.1.2 → chalkcompute-2.1.8}/chalkcompute/_container.py

@@ -28,20 +28,26 @@ from enum import Enum
 from typing import TYPE_CHECKING, Any
 
 from chalkcompute._connect import ConnectClient
+from chalkcompute._naming import (
+    sanitize_dns_label,
+    validate_dns_label,
+    validate_env,
+)
+from chalkcompute._tracing import _instrumented
 from chalkcompute._volume import (
     VolumeDriver,
     VolumeError,
     VolumeMount,
-    _resolve_driver,
+    cleanup_owned_volumes,
     resolve_referenced_volume_type,
 )
-from chalkcompute._naming import sanitize_dns_label, validate_dns_label, validate_env
-from chalkcompute._tracing import _instrumented
+from chalkcompute._vvolume import VersionedVolumeClient
 
 logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
+
     from chalkcompute._image import Image as _Image
     from chalkcompute._secret import Secret
 
@@ -53,6 +59,7 @@ _IMAGE_SVC = "chalk.sandbox.v1.CustomImageService"
 # Exceptions
 # ---------------------------------------------------------------------------
 
+
 class ContainerError(Exception):
     """Base exception for Container errors."""
 
@@ -65,6 +72,7 @@ class ImageBuildError(ContainerError):
 # Data classes
 # ---------------------------------------------------------------------------
 
+
 @dataclass
 class ExecResult:
     """Result of a one-shot command executed inside a container.
@@ -107,6 +115,11 @@ class KernelPolicy(Enum):
     OPEN = "OPEN"
 
 
+class ComputeClass(Enum):
+    K8S = "COMPUTE_CLASS_K8S"
+    HOST = "COMPUTE_CLASS_HOST"
+
+
 @dataclass
 class ContainerSecurityPolicy:
     """Security policy settings for a container.
@@ -233,6 +246,7 @@ class ContainerInfo:
 # Container
 # ---------------------------------------------------------------------------
 
+
 class Container:
     """A managed container backed by the Chalk ``ContainerService``.
 
@@ -277,6 +291,7 @@ class Container:
         enable_ssh: bool = False,
         security_policy: ContainerSecurityPolicy | None = None,
         network_policy: NetworkPolicy | None = None,
+        compute_class: ComputeClass | None = None,
         tags: dict[str, str] | None = None,
         chalk_client: Any | None = None,
     ) -> None:
@@ -287,7 +302,9 @@ class Container:
         if cpu is not None and not isinstance(cpu, str):
             raise TypeError(f"cpu must be a string such as '2' or '500m', got {cpu!r}")
         if memory is not None and not isinstance(memory, str):
-            raise TypeError(f"memory must be a string such as '2Gi' or '512Mi', got {memory!r}")
+            raise TypeError(
+                f"memory must be a string such as '2Gi' or '512Mi', got {memory!r}"
+            )
         if gpu is not None and not isinstance(gpu, str):
             raise TypeError(f"gpu must be a string such as 'nvidia-l4', got {gpu!r}")
         self._cpu = cpu
@@ -299,7 +316,11 @@ class Container:
         referenced_volumes: list[tuple[str, str]] = []
         if volumes is not None:
             for item in volumes:
-                if not (isinstance(item, (tuple, list)) and len(item) == 2 and all(isinstance(s, str) for s in item)):
+                if not (
+                    isinstance(item, (tuple, list))
+                    and len(item) == 2
+                    and all(isinstance(s, str) for s in item)
+                ):
                     raise ValueError(
                         f"Each volumes entry must be a (name, mount_path) string tuple, got {item!r}. "
                         f"Example: volumes=[('my-volume', '/data')]"
@@ -320,6 +341,7 @@ class Container:
         if lifetime is not None:
             from google.protobuf import duration_pb2
             from google.protobuf.json_format import Parse, ParseError
+
             try:
                 _parsed_lifetime = Parse(f'"{lifetime}"', duration_pb2.Duration())  # ty: ignore[unresolved-attribute]
             except ParseError:
@@ -336,6 +358,7 @@ class Container:
         self._enable_ssh = enable_ssh
         self._security_policy = security_policy
         self._network_policy = network_policy
+        self._compute_class = compute_class
         self._tags: dict[str, str] = dict(tags or {})
 
         # Set after .run()
@@ -349,7 +372,9 @@ class Container:
     # -- Alternate constructors ------------------------------------------------
 
     @classmethod
-    def from_id(cls, container_id: str, *, chalk_client: Any | None = None) -> Container:
+    def from_id(
+        cls, container_id: str, *, chalk_client: Any | None = None
+    ) -> Container:
         """Attach to an existing container by ID.
 
         Parameters
@@ -421,7 +446,10 @@ class Container:
         resp = c._client.rpc(_SVC, "ListContainers", {})
         if resp.status_code != 200:
             raise ContainerError(f"ListContainers failed: {resp.text}")
-        return [_parse_container_response(item) for item in resp.json().get("containers", [])]
+        return [
+            _parse_container_response(item)
+            for item in resp.json().get("containers", [])
+        ]
 
     @classmethod
     def _make_empty(cls, *, chalk_client: Any | None = None) -> Container:
@@ -453,7 +481,10 @@ class Container:
     # -- Image building (Container uses BuildCustomImage with retries) ---------
 
     def _build_image(
-        self, *, poll_interval: float = 0.5, timeout: float = 600.0,
+        self,
+        *,
+        poll_interval: float = 0.5,
+        timeout: float = 600.0,
     ) -> str:
         """Build the ``Image`` spec via ``CustomImageService`` and return the URI.
 
@@ -480,8 +511,10 @@ class Container:
         assert isinstance(self._image, Image)
         try:
             return build_image(
-                self._client, self._image,
-                poll_interval=poll_interval, timeout=timeout,
+                self._client,
+                self._image,
+                poll_interval=poll_interval,
+                timeout=timeout,
             )
         except ConnectError as e:
             raise ImageBuildError(str(e)) from e
@@ -586,20 +619,24 @@ class Container:
         >>> c.stop()
         """
         if self._container_id is not None:
-            raise ContainerError("Container is already running. Call .stop() before calling .run() again.")
+            raise ContainerError(
+                "Container is already running. Call .stop() before calling .run() again."
+            )
 
+        from chalkcompute._image import Image
         from chalkcompute._progress import (
             progress_add,
             progress_done,
             progress_fail,
             progress_finish,
         )
-        from chalkcompute._image import Image
 
-        container_name = sanitize_dns_label(self._name or f"container-{uuid.uuid4().hex[:8]}")
+        container_name = sanitize_dns_label(
+            self._name or f"container-{uuid.uuid4().hex[:8]}"
+        )
         self._name = container_name
         ckey = f"container:{container_name}"
-        progress_add(ckey, "container", f"Container \"{container_name}\"")
+        progress_add(ckey, "container", f'Container "{container_name}"')
 
         try:
             # 1. Resolve image URI
@@ -608,10 +645,13 @@ class Container:
                 progress_add(ikey, "image", "Building image", parent=ckey)
                 logger.info("Building image from %r...", self._image)
                 self._built_image_uri = self._build_image(
-                    poll_interval=poll_interval, timeout=build_timeout,
+                    poll_interval=poll_interval,
+                    timeout=build_timeout,
                 )
                 logger.info("Image built: %s", self._built_image_uri)
-                progress_done(ikey, detail="cached" if self._built_image_uri else "built")
+                progress_done(
+                    ikey, detail="cached" if self._built_image_uri else "built"
+                )
             else:
                 self._built_image_uri = self._image
 
@@ -628,24 +668,33 @@ class Container:
 
             # 2b. Upload lazy local files to a volume (if any)
             lazy_files = (
-                self._image.lazy_local_files if isinstance(self._image, Image) else set()
+                self._image.lazy_local_files
+                if isinstance(self._image, Image)
+                else set()
             )
             if lazy_files:
                 vkey = f"volume:{container_name}"
                 progress_add(
-                    vkey, "volume",
+                    vkey,
+                    "volume",
                     f"Uploading {len(lazy_files)} file(s)",
                     parent=ckey,
                 )
-                logger.info("Uploading %d local file(s) to volume(s)...", len(lazy_files))
+                logger.info(
+                    "Uploading %d local file(s) to volume(s)...",
+                    len(lazy_files),
+                )
                 assert isinstance(self._image, Image)
-                driver = _resolve_driver(self._client)
+                driver = VersionedVolumeClient.from_connect(self._client)
                 self._volume_driver = driver
                 self._volumes += driver.upload_lazy_files(
-                    self._image, volume_prefix="container-files",
+                    self._image,
+                    volume_prefix="container-files",
                 )
                 for v in self._volumes:
-                    logger.info("  Volume created: %s (mount: %s)", v.name, v.mount_path)
+                    logger.info(
+                        "  Volume created: %s (mount: %s)", v.name, v.mount_path
+                    )
                 progress_done(vkey)
 
             # 3. Resolve lazy secrets (from_local_env / from_local_env_file)
@@ -657,7 +706,10 @@ class Container:
                 resolved, upserted = resolve_lazy_secrets(self._secrets, self._client)
                 self._secrets = resolved
                 self._upserted_secret_names = upserted
-                logger.info("Upserted %d secret(s) from local environment.", len(upserted))
+                logger.info(
+                    "Upserted %d secret(s) from local environment.",
+                    len(upserted),
+                )
                 progress_done(skey, detail=f"{len(upserted)} secret(s)")
 
             # 4. Build the ContainerService spec
@@ -679,6 +731,8 @@ class Container:
                 spec["securityPolicy"] = self._security_policy.to_dict()
             if self._network_policy is not None:
                 spec["networkPolicy"] = self._network_policy.to_dict()
+            if self._compute_class is not None:
+                spec["computeClass"] = self._compute_class.value
             if self._tags:
                 spec["tags"] = dict(self._tags)
 
@@ -706,7 +760,10 @@ class Container:
 
             logger.info("Starting container '%s'...", container_name)
             resp = self._client.rpc(
-                _SVC, "RunContainer", {"container": {"spec": spec}}, timeout=60,
+                _SVC,
+                "RunContainer",
+                {"container": {"spec": spec}},
+                timeout=60,
             )
             if resp.status_code != 200:
                 raise ContainerError(f"RunContainer failed: {resp.text}")
@@ -716,7 +773,8 @@ class Container:
             self._container_id = self._container_info.id
             logger.info(
                 "Container created: %s (status=%s)",
-                self._container_id, self._container_info.status,
+                self._container_id,
+                self._container_info.status,
             )
 
             # 5. Poll until Running
@@ -725,7 +783,8 @@ class Container:
 
                 progress_update(ckey, detail="booting")
                 self._poll_until_running(
-                    poll_interval=poll_interval, timeout=ready_timeout,
+                    poll_interval=poll_interval,
+                    timeout=ready_timeout,
                 )
 
             # 6. Wait for ChalkFS volume files to become visible
@@ -747,7 +806,10 @@ class Container:
         return self
 
     def _poll_until_running(
-        self, *, poll_interval: float, timeout: float,
+        self,
+        *,
+        poll_interval: float,
+        timeout: float,
     ) -> None:
         assert self._container_id is not None
         deadline = time.monotonic() + timeout
@@ -773,12 +835,14 @@ class Container:
             time.sleep(poll_interval)
         status = self._container_info.status if self._container_info else "unknown"
         raise ContainerError(
-            f"Container {self._container_id} timed out after {timeout}s "
-            f"(last status: {status})"
+            f"Container {self._container_id} timed out after {timeout}s (last status: {status})"
         )
 
     def _wait_for_volume_files(
-        self, *, timeout: float = 120.0, poll_interval: float = 0.5,
+        self,
+        *,
+        timeout: float = 120.0,
+        poll_interval: float = 0.5,
     ) -> None:
         """Poll until at least one uploaded file is visible in the ChalkFS mount.
 
@@ -934,9 +998,10 @@ class Container:
         if self._volumes:
             # Driver is used here only to perform the delete action, not to
             # derive a mount type.
-            driver = self._volume_driver or _resolve_driver(self._client)
-            for v in self._volumes:
-                driver.delete_volume(v.name)
+            driver = self._volume_driver or VersionedVolumeClient.from_connect(
+                self._client
+            )
+            cleanup_owned_volumes(driver, self._volumes, self._referenced_volumes)
         self._volumes = []
         self._volume_driver = None
 
@@ -1005,6 +1070,7 @@ class Container:
 # Helpers
 # ---------------------------------------------------------------------------
 
+
 def _parse_container_response(data: dict) -> ContainerInfo:
     return ContainerInfo(
         id=data["id"],