volcano-sdk-python 0.7.1__py3-none-any.whl → 0.7.3__py3-none-any.whl

volcano_sdk/_transport.py

@@ -13,14 +13,10 @@ from uuid import UUID, uuid4
 import httpx
 
 from ._generated.api.authentication import (
-    auth_confirm_email_change,
-    auth_convert_anonymous,
-    auth_get_user,
     auth_logout,
     auth_refresh,
     auth_signin,
     auth_signup,
-    auth_update_user,
 )
 from ._generated.api.authentication.auth_cancel_email_change import (
     _get_kwargs as cancel_email_change_kwargs,
@@ -28,6 +24,18 @@ from ._generated.api.authentication.auth_cancel_email_change import (
 from ._generated.api.authentication.auth_confirm_email import (
     _get_kwargs as confirm_email_kwargs,
 )
+from ._generated.api.authentication.auth_confirm_email_change import (
+    _build_response as build_auth_confirm_email_change_response,
+)
+from ._generated.api.authentication.auth_confirm_email_change import (
+    _get_kwargs as auth_confirm_email_change_kwargs,
+)
+from ._generated.api.authentication.auth_convert_anonymous import (
+    _build_response as build_auth_convert_anonymous_response,
+)
+from ._generated.api.authentication.auth_convert_anonymous import (
+    _get_kwargs as auth_convert_anonymous_kwargs,
+)
 from ._generated.api.authentication.auth_delete_all_my_sessions import (
     _get_kwargs as delete_all_my_sessions_kwargs,
 )
@@ -40,6 +48,12 @@ from ._generated.api.authentication.auth_forgot_password import (
 from ._generated.api.authentication.auth_get_my_sessions import (
     _get_kwargs as get_my_sessions_kwargs,
 )
+from ._generated.api.authentication.auth_get_user import (
+    _build_response as build_auth_get_user_response,
+)
+from ._generated.api.authentication.auth_get_user import (
+    _get_kwargs as auth_get_user_kwargs,
+)
 from ._generated.api.authentication.auth_request_email_change import (
     _get_kwargs as request_email_change_kwargs,
 )
@@ -52,6 +66,12 @@ from ._generated.api.authentication.auth_reset_password import (
 from ._generated.api.authentication.auth_signup_anonymous import (
     _get_kwargs as signup_anonymous_kwargs,
 )
+from ._generated.api.authentication.auth_update_user import (
+    _build_response as build_auth_update_user_response,
+)
+from ._generated.api.authentication.auth_update_user import (
+    _get_kwargs as auth_update_user_kwargs,
+)
 from ._generated.api.database_queries import (
     query_database_select,
 )
@@ -829,9 +849,13 @@ class GeneratedTransport:
         )
         try:
             with self._client(authorization) as client:
-                response = auth_convert_anonymous.sync_detailed(
-                    client=client,
-                    body=body,
+                raw_response = client.get_httpx_client().request(
+                    **auth_convert_anonymous_kwargs(body=body)
+                )
+                if raw_response.status_code == HTTP_UNAUTHORIZED:
+                    return self._raw_response(raw_response)
+                response = build_auth_convert_anonymous_response(
+                    client=client, response=raw_response
                 )
         except (
             AttributeError,
@@ -928,9 +952,13 @@ class GeneratedTransport:
         body = AuthConfirmEmailChangeBody(email_change_token=token)
         try:
             with self._client(authorization) as client:
-                response = auth_confirm_email_change.sync_detailed(
-                    client=client,
-                    body=body,
+                raw_response = client.get_httpx_client().request(
+                    **auth_confirm_email_change_kwargs(body=body)
+                )
+                if raw_response.status_code == HTTP_UNAUTHORIZED:
+                    return self._raw_response(raw_response)
+                response = build_auth_confirm_email_change_response(
+                    client=client, response=raw_response
                 )
         except (
             AttributeError,
@@ -1204,7 +1232,14 @@ class GeneratedTransport:
     def auth_get_user(self, *, authorization: str) -> TransportResponse:
         try:
             with self._client(authorization) as client:
-                response = auth_get_user.sync_detailed(client=client)
+                raw_response = client.get_httpx_client().request(
+                    **auth_get_user_kwargs()
+                )
+                if raw_response.status_code == HTTP_UNAUTHORIZED:
+                    return self._raw_response(raw_response)
+                response = build_auth_get_user_response(
+                    client=client, response=raw_response
+                )
         except (
             AttributeError,
             KeyError,
@@ -1239,7 +1274,14 @@ class GeneratedTransport:
         )
         try:
             with self._client(authorization) as client:
-                response = auth_update_user.sync_detailed(client=client, body=body)
+                raw_response = client.get_httpx_client().request(
+                    **auth_update_user_kwargs(body=body)
+                )
+                if raw_response.status_code == HTTP_UNAUTHORIZED:
+                    return self._raw_response(raw_response)
+                response = build_auth_update_user_response(
+                    client=client, response=raw_response
+                )
         except (
             AttributeError,
             KeyError,

volcano_sdk/auth.py

@@ -9,6 +9,7 @@ import secrets
 import threading
 from collections.abc import Mapping
 from contextlib import suppress
+from copy import deepcopy
 from dataclasses import replace
 from datetime import datetime
 from http import HTTPStatus
@@ -574,18 +575,22 @@ class Auth:
         metadata: Mapping[str, object] | None = None,
     ) -> User:
         """Attach email credentials to the current anonymous account."""
-        generation, current = self._client._capture_session()
-        if current is None:
+        binding = self._client._capture_session_binding()
+        if binding[2] is None:
             raise AuthenticationError(_NO_ACTIVE_SESSION)
         transport = cast("AuthConvertAnonymousTransport", self._client._transport)
-        response = invoke(
-            transport.auth_convert_anonymous,
-            authorization=current.access_token,
-            email=email,
-            password=password,
-            metadata=dict(metadata or {}),
+        request_metadata = deepcopy(dict(metadata or {}))
+        response = self._session_request(
+            lambda access_token: invoke(
+                transport.auth_convert_anonymous,
+                authorization=access_token,
+                email=email,
+                password=password,
+                metadata=request_metadata,
+            ),
+            binding=binding,
         )
-        return self._update_current_user(response_payload(response, 200), generation)
+        return self._update_current_user(response_payload(response, 200), binding)
 
     def reset_password_for_email(self, *, email: str) -> None:
         """Request a reset email without revealing whether the account exists."""
@@ -629,16 +634,19 @@ class Auth:
 
     def confirm_email_change(self, *, token: str) -> User:
         """Confirm a pending email change and return the updated user."""
-        generation, current = self._client._capture_session()
-        if current is None:
+        binding = self._client._capture_session_binding()
+        if binding[2] is None:
             raise AuthenticationError(_NO_ACTIVE_SESSION)
         transport = cast("AuthConfirmEmailChangeTransport", self._client._transport)
-        response = invoke(
-            transport.auth_confirm_email_change,
-            authorization=current.access_token,
-            token=token,
+        response = self._session_request(
+            lambda access_token: invoke(
+                transport.auth_confirm_email_change,
+                authorization=access_token,
+                token=token,
+            ),
+            binding=binding,
         )
-        return self._update_current_user(response_payload(response, 200), generation)
+        return self._update_current_user(response_payload(response, 200), binding)
 
     def delete_all_other_sessions(self) -> None:
         """Delete every other session while preserving the current session."""
@@ -944,7 +952,10 @@ class Auth:
         )
         response_payload(response, 200)
 
-    def _update_current_user(self, payload: object, generation: int) -> User:
+    def _update_current_user(
+        self, payload: object, binding: tuple[int, int, Session | None]
+    ) -> User:
+        generation = self._owned_refresh_session(binding)[0]
         user, snapshot = _user_from_payload(payload)
         if not self._client._update_session_user_if_current(snapshot, generation):
             raise SessionChangedError
@@ -952,12 +963,17 @@ class Auth:
 
     def get_user(self) -> User:
         """Load a server-validated profile for the current session."""
-        generation, current = self._client._capture_session()
-        if current is None:
+        binding = self._client._capture_session_binding()
+        if binding[2] is None:
             raise AuthenticationError(_NO_ACTIVE_SESSION)
         transport = cast("AuthGetUserTransport", self._client._transport)
-        response = invoke(transport.auth_get_user, authorization=current.access_token)
-        return self._update_current_user(response_payload(response, 200), generation)
+        response = self._session_request(
+            lambda access_token: invoke(
+                transport.auth_get_user, authorization=access_token
+            ),
+            binding=binding,
+        )
+        return self._update_current_user(response_payload(response, 200), binding)
 
     def update_user(
         self,
@@ -966,17 +982,21 @@ class Auth:
         metadata: Mapping[str, object] | None = None,
     ) -> User:
         """Update and return the current user's server-validated profile."""
-        generation, current = self._client._capture_session()
-        if current is None:
+        binding = self._client._capture_session_binding()
+        if binding[2] is None:
             raise AuthenticationError(_NO_ACTIVE_SESSION)
         transport = cast("AuthUpdateUserTransport", self._client._transport)
-        response = invoke(
-            transport.auth_update_user,
-            authorization=current.access_token,
-            password=password,
-            metadata=None if metadata is None else dict(metadata),
+        request_metadata = None if metadata is None else deepcopy(dict(metadata))
+        response = self._session_request(
+            lambda access_token: invoke(
+                transport.auth_update_user,
+                authorization=access_token,
+                password=password,
+                metadata=request_metadata,
+            ),
+            binding=binding,
         )
-        return self._update_current_user(response_payload(response, 200), generation)
+        return self._update_current_user(response_payload(response, 200), binding)
 
     def sign_in(self, *, email: str, password: str) -> Session:
         """Sign in a user and store the returned session."""
@@ -1007,12 +1027,20 @@ class Auth:
         )
 
     def _session_request(
-        self, operation: Callable[[str], TransportResponse]
+        self,
+        operation: Callable[[str], TransportResponse],
+        *,
+        binding: tuple[int, int, Session | None] | None = None,
     ) -> TransportResponse:
-        binding = self._client._capture_session_binding()
+        if binding is None:
+            binding = self._client._capture_session_binding()
         if binding[2] is None:
             raise RuntimeError(_NO_ACTIVE_SESSION)
-        response = operation(binding[2].access_token)
+        binding = self._owned_refresh_session(binding)
+        current = binding[2]
+        if current is None:
+            raise SessionChangedError
+        response = operation(current.access_token)
         if response.status_code != HTTPStatus.UNAUTHORIZED:
             return response
         try:

volcano_sdk/storage.py

@@ -11,7 +11,7 @@ from dataclasses import dataclass
 from datetime import datetime
 from io import SEEK_END, BytesIO
 from tempfile import TemporaryFile
-from typing import Any, BinaryIO, Protocol, cast
+from typing import TYPE_CHECKING, Any, BinaryIO, Protocol, cast
 from urllib.parse import quote
 
 from ._transport import (
@@ -25,6 +25,7 @@ from ._transport import (
 )
 from .models import (
     JSONValue,
+    Session,
     StorageObject,
     StoragePage,
     UploadPart,
@@ -33,6 +34,9 @@ from .models import (
     UploadSessionStatus,
 )
 
+if TYPE_CHECKING:
+    from .auth import Auth
+
 _INVALID_STORAGE_PAGE = "Expected a complete storage page"
 _INVALID_CONTENT_TYPE = "content_type must be a non-blank printable ASCII string"
 _INVALID_STORAGE_PATH = "Storage path must be a non-empty string"
@@ -280,6 +284,7 @@ class StorageContext(Protocol):
     """Client capabilities required by object storage."""
 
     _transport: Transport
+    auth: Auth
 
     def _anon_token(self) -> str: ...
 
@@ -287,6 +292,8 @@ class StorageContext(Protocol):
 
     def _session_token(self) -> str: ...
 
+    def _capture_session_binding(self) -> tuple[int, int, Session | None]: ...
+
 
 class StorageListTransport(Protocol):
     """Transport capability required to list storage objects."""
@@ -462,25 +469,33 @@ class StorageBucket:
     ) -> dict[str, Any]:
         """Upload bytes or the remaining contents of a binary stream."""
         mime_type = _upload_content_type(content_type)
-        response = invoke(
-            self._client._transport.upload_storage_object,
-            authorization=self._client._session_token(),
-            bucket_name=self._name,
-            path=path,
-            data=_simple_upload_bytes(data),
-            content_type=mime_type,
+        binding = self._client._capture_session_binding()
+        self._client._session_token()
+        content = _simple_upload_bytes(data)
+        response = self._client.auth._session_request(
+            lambda token: invoke(
+                self._client._transport.upload_storage_object,
+                authorization=token,
+                bucket_name=self._name,
+                path=path,
+                data=content,
+                content_type=mime_type,
+            ),
+            binding=binding,
         )
         payload = response_payload(response, 201)
         return dict(payload)
 
     def download(self, path: str, *, byte_range: str | None = None) -> bytes:
         """Download bytes from a path in this bucket."""
-        response = invoke(
-            self._client._transport.download_storage_object,
-            authorization=self._client._session_token(),
-            bucket_name=self._name,
-            path=path,
-            byte_range=byte_range,
+        response = self._client.auth._session_request(
+            lambda token: invoke(
+                self._client._transport.download_storage_object,
+                authorization=token,
+                bucket_name=self._name,
+                path=path,
+                byte_range=byte_range,
+            )
         )
         expected_status = (
             _HTTP_PARTIAL_CONTENT
@@ -500,16 +515,18 @@ class StorageBucket:
     ) -> UploadSession:
         """Create server state for a resumable upload."""
         transport = cast("StorageUploadSessionTransport", self._client._transport)
-        response = invoke(
-            transport.create_upload_session,
-            authorization=self._client._session_token(),
-            bucket_name=self._name,
-            request=StorageUploadSessionRequest(
-                path=_storage_path(path),
-                content_type=content_type,
-                total_size=total_size,
-                part_size=part_size,
-            ),
+        response = self._client.auth._session_request(
+            lambda token: invoke(
+                transport.create_upload_session,
+                authorization=token,
+                bucket_name=self._name,
+                request=StorageUploadSessionRequest(
+                    path=_storage_path(path),
+                    content_type=content_type,
+                    total_size=total_size,
+                    part_size=part_size,
+                ),
+            )
         )
         return _upload_session(response_payload(response, 201))
 
@@ -523,16 +540,18 @@ class StorageBucket:
     ) -> UploadPart:
         """Upload one part of a resumable upload session."""
         transport = cast("StorageUploadPartTransport", self._client._transport)
-        response = invoke(
-            transport.upload_part,
-            authorization=self._client._session_token(),
-            bucket_name=self._name,
-            request=StorageUploadPartRequest(
-                path=_storage_path(path),
-                session_id=session_id,
-                part_number=part_number,
-                data=data,
-            ),
+        response = self._client.auth._session_request(
+            lambda token: invoke(
+                transport.upload_part,
+                authorization=token,
+                bucket_name=self._name,
+                request=StorageUploadPartRequest(
+                    path=_storage_path(path),
+                    session_id=session_id,
+                    part_number=part_number,
+                    data=data,
+                ),
+            )
         )
         return _upload_part(response_payload(response, 200))
 
@@ -544,14 +563,16 @@ class StorageBucket:
     ) -> StorageObject:
         """Complete a resumable upload and return the stored object."""
         transport = cast("StorageCompleteUploadTransport", self._client._transport)
-        response = invoke(
-            transport.complete_upload_session,
-            authorization=self._client._session_token(),
-            bucket_name=self._name,
-            request=StorageUploadSessionReference(
-                path=_storage_path(path),
-                session_id=session_id,
-            ),
+        response = self._client.auth._session_request(
+            lambda token: invoke(
+                transport.complete_upload_session,
+                authorization=token,
+                bucket_name=self._name,
+                request=StorageUploadSessionReference(
+                    path=_storage_path(path),
+                    session_id=session_id,
+                ),
+            )
         )
         payload = cast("Mapping[str, object]", response_payload(response, 200))
         return _storage_object(payload["object"])
@@ -564,14 +585,16 @@ class StorageBucket:
     ) -> UploadSessionStatus:
         """Get resumable upload progress and uploaded part metadata."""
         transport = cast("StorageUploadStatusTransport", self._client._transport)
-        response = invoke(
-            transport.get_upload_session,
-            authorization=self._client._session_token(),
-            bucket_name=self._name,
-            request=StorageUploadSessionReference(
-                path=_storage_path(path),
-                session_id=session_id,
-            ),
+        response = self._client.auth._session_request(
+            lambda token: invoke(
+                transport.get_upload_session,
+                authorization=token,
+                bucket_name=self._name,
+                request=StorageUploadSessionReference(
+                    path=_storage_path(path),
+                    session_id=session_id,
+                ),
+            )
         )
         return _upload_session_status(response_payload(response, 200))
 
@@ -583,14 +606,16 @@ class StorageBucket:
     ) -> None:
         """Abort a resumable upload and discard its uploaded parts."""
         transport = cast("StorageAbortUploadTransport", self._client._transport)
-        response = invoke(
-            transport.abort_upload_session,
-            authorization=self._client._session_token(),
-            bucket_name=self._name,
-            request=StorageUploadSessionReference(
-                path=_storage_path(path),
-                session_id=session_id,
-            ),
+        response = self._client.auth._session_request(
+            lambda token: invoke(
+                transport.abort_upload_session,
+                authorization=token,
+                bucket_name=self._name,
+                request=StorageUploadSessionReference(
+                    path=_storage_path(path),
+                    session_id=session_id,
+                ),
+            )
         )
         response_payload(response, 200)
 
@@ -662,41 +687,51 @@ class StorageBucket:
     ) -> StoragePage:
         """List objects under a prefix and return the next-page cursor."""
         transport = cast("StorageListTransport", self._client._transport)
-        response = invoke(
-            transport.list_storage_objects,
-            authorization=self._client._session_token(),
-            bucket_name=self._name,
-            prefix=prefix,
-            limit=limit,
-            cursor=cursor,
+        response = self._client.auth._session_request(
+            lambda token: invoke(
+                transport.list_storage_objects,
+                authorization=token,
+                bucket_name=self._name,
+                prefix=prefix,
+                limit=limit,
+                cursor=cursor,
+            )
         )
         return _storage_page(response_payload(response, 200))
 
     def remove(self, paths: str | Sequence[str]) -> tuple[str, ...]:
         """Delete one or more object paths and return their immutable snapshot."""
         path_list = _storage_paths(paths)
-        transport = cast("StorageDeleteTransport", self._client._transport)
-        authorization = self._client._session_token()
+        binding = self._client._capture_session_binding()
         for path in path_list:
-            response = invoke(
+            self._remove_path(path, binding)
+        return path_list
+
+    def _remove_path(self, path: str, binding: tuple[int, int, Session | None]) -> None:
+        transport = cast("StorageDeleteTransport", self._client._transport)
+        response = self._client.auth._session_request(
+            lambda token: invoke(
                 transport.delete_storage_object,
-                authorization=authorization,
+                authorization=token,
                 bucket_name=self._name,
                 path=path,
-            )
-            response_payload(response, 200)
-        return path_list
+            ),
+            binding=binding,
+        )
+        response_payload(response, 200)
 
     def move(self, from_path: str, to_path: str) -> StorageObject:
         """Move or rename an object within this bucket."""
         source, destination = _storage_paths((from_path, to_path))
         transport = cast("StorageMoveTransport", self._client._transport)
-        response = invoke(
-            transport.move_storage_object,
-            authorization=self._client._session_token(),
-            bucket_name=self._name,
-            from_path=source,
-            to_path=destination,
+        response = self._client.auth._session_request(
+            lambda token: invoke(
+                transport.move_storage_object,
+                authorization=token,
+                bucket_name=self._name,
+                from_path=source,
+                to_path=destination,
+            )
         )
         return _storage_object(response_payload(response, 200))
 
@@ -704,12 +739,14 @@ class StorageBucket:
         """Copy an object to another path within this bucket."""
         source, destination = _storage_paths((from_path, to_path))
         transport = cast("StorageCopyTransport", self._client._transport)
-        response = invoke(
-            transport.copy_storage_object,
-            authorization=self._client._session_token(),
-            bucket_name=self._name,
-            from_path=source,
-            to_path=destination,
+        response = self._client.auth._session_request(
+            lambda token: invoke(
+                transport.copy_storage_object,
+                authorization=token,
+                bucket_name=self._name,
+                from_path=source,
+                to_path=destination,
+            )
         )
         return _storage_object(response_payload(response, 201))
 
@@ -718,12 +755,14 @@ class StorageBucket:
         object_path = _storage_paths(path)[0]
         visibility = _storage_visibility(is_public)
         transport = cast("StorageVisibilityTransport", self._client._transport)
-        response = invoke(
-            transport.update_storage_object_visibility,
-            authorization=self._client._session_token(),
-            bucket_name=self._name,
-            path=object_path,
-            is_public=visibility,
+        response = self._client.auth._session_request(
+            lambda token: invoke(
+                transport.update_storage_object_visibility,
+                authorization=token,
+                bucket_name=self._name,
+                path=object_path,
+                is_public=visibility,
+            )
         )
         return _storage_object(response_payload(response, 200))
 

{volcano_sdk_python-0.7.1.dist-info → volcano_sdk_python-0.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: volcano-sdk-python
-Version: 0.7.1
+Version: 0.7.3
 Summary: Official Python SDK for Volcano
 Project-URL: Homepage, https://volcano.dev
 Project-URL: Repository, https://github.com/Kong/volcano-sdk-python
@@ -25,6 +25,8 @@ Description-Content-Type: text/markdown
 Use the Volcano Python SDK to access authentication, databases, storage,
 functions, locks, logs, and realtime events. Requires Python 3.11 or later.
 
+Start with the [Python quickstart](https://github.com/Kong/volcano-sdk-python/blob/main/docs/README.md).
+
 ## Install
 
 ```shell
@@ -219,7 +221,8 @@ events. Pass `next_cursor` back as `cursor` to continue a search. `logs.activity
 returns immutable time buckets using the same resource selector and query syntax.
 Both methods require an active user session.
 
-Database selects, inserts, updates, deletes, and log reads refresh the captured
+Database selects, inserts, updates, deletes, log reads, and authenticated storage
+requests (including upload sessions and parts) refresh the captured
 session after an HTTP 401 and retry the same request once. Concurrent requests reuse a successful
 refresh for that session.
 Replacing or signing out the session before replay, or while replay is in flight,

{volcano_sdk_python-0.7.1.dist-info → volcano_sdk_python-0.7.3.dist-info}/RECORD

@@ -4,8 +4,8 @@ volcano_sdk/_lock_guard.py,sha256=EZzcwOPTFTCNUrIWIQ0-nMg9tm_nPkaYkcocgeLbu94,55
 volcano_sdk/_lock_renewer.py,sha256=tFo1ZeRiPKB5VSbW61uoMpNR67ZDYyMEe-dCjpAM3As,841
 volcano_sdk/_lock_worker.py,sha256=QhSmwR0WcwgT-7ueJMlbCogLqOakQ5eRAtyWV74fgV0,3057
 volcano_sdk/_realtime_fetch_worker.py,sha256=zQTgFF4cIUBeAL4J2OpWAlz_sIynv2BLfu588EogAdo,9269
-volcano_sdk/_transport.py,sha256=apXZLuT9W17vO-7Ag2E289o2B-uL-Rndv_wRPm69x0I,55481
-volcano_sdk/auth.py,sha256=6TXpCZ0mPqluPh-nJSYUbjcryJTwZBz03zDSHuP1eZA,42262
+volcano_sdk/_transport.py,sha256=PzdO7uhqvgI2L-Ff0rwZCWeF7yuH_Ty-OvZx0F7dMpo,57509
+volcano_sdk/auth.py,sha256=Z5UCrqdvmHBS6n6ZleXya04hYV94rH4SRV1GW2yimXo,43185
 volcano_sdk/client.py,sha256=KutjBUOEJyK73OibKilrcWazpWeXKEZYUehSAH8qxUE,10366
 volcano_sdk/connection_string.py,sha256=LlTZigsrCF4IfAqQ8SDTWJv35hnnzNu1MfeVv5JW-Kk,2331
 volcano_sdk/database.py,sha256=p_5OaqlBjKAtIUfKQCflXM_CGqokrVmpOMsp6KHiJ8A,9493
@@ -16,7 +16,7 @@ volcano_sdk/logs.py,sha256=lxORRQBvsnJ0BdMau19MXrIeig5_mEucQSyJ4F1CZxU,4666
 volcano_sdk/models.py,sha256=43zM6LQ9eJ3Hn6q9PiVSozSmOzPSr4m4OL8G8KVb-gg,8619
 volcano_sdk/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 volcano_sdk/realtime.py,sha256=VkxZyrC7PlddnCSv8wBBLVg4nPWjpyuGo1FoBWhpf6M,59295
-volcano_sdk/storage.py,sha256=bY4yNYPnavVeQtjZ99hCOFNuR_gPRg5a785lUu_MLXo,24724
+volcano_sdk/storage.py,sha256=1bAgzGO-dhUCVG8B-5x40jenHeh68Id2csIJF57KSGk,26126
 volcano_sdk/_generated/__init__.py,sha256=ZlB8wMYdN6EjpUS5W_lX3jsxq9G1kOcmUr-j3Fccfn8,164
 volcano_sdk/_generated/client.py,sha256=GDzw6T2uRmPlUb1DImpBGxwy0dNbhmBknfvvIQW0GuU,12387
 volcano_sdk/_generated/errors.py,sha256=trp-p5qn1_JLRxGZhdHtICaNPaCrcDCe4TgIihBravk,546
@@ -773,7 +773,7 @@ volcano_sdk/_generated/models/usage_data_point.py,sha256=d4U08JbVTiIMM_l2BmRILL1
 volcano_sdk/_generated/models/variable.py,sha256=tvGDOMv77gW6j5skufnfrlNAhzCzA1F7nuPCQWx79yY,5926
 volcano_sdk/_generated/models/variable_deploy_source.py,sha256=G_aCiFHzQx8WhJFs0GvYZEFclfTrfkDvd3kT1e3vty8,463
 volcano_sdk/_generated/models/variable_status.py,sha256=THSsKBSiAYG4kAtBzGA4TZqxjgx8hdL0Q4qCdZfOj00,391
-volcano_sdk_python-0.7.1.dist-info/METADATA,sha256=oRwloD8TI-9Hkx55sLPyoD_Mt-9U-4eqwhZsYZI_YfQ,33381
-volcano_sdk_python-0.7.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-volcano_sdk_python-0.7.1.dist-info/licenses/LICENSE,sha256=AIHJy-5MFqM8fHfuGFTTb9a8rvJGypcVgN4aZ-7XTWw,11387
-volcano_sdk_python-0.7.1.dist-info/RECORD,,
+volcano_sdk_python-0.7.3.dist-info/METADATA,sha256=0lDdNzghgpaKsYFFqMZZrWCn0rUt9nqdaGWSg0FhU_U,33557
+volcano_sdk_python-0.7.3.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+volcano_sdk_python-0.7.3.dist-info/licenses/LICENSE,sha256=AIHJy-5MFqM8fHfuGFTTb9a8rvJGypcVgN4aZ-7XTWw,11387
+volcano_sdk_python-0.7.3.dist-info/RECORD,,

{volcano_sdk_python-0.7.1.dist-info → volcano_sdk_python-0.7.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.0
+Generator: hatchling 1.32.3
 Root-Is-Purelib: true
 Tag: py3-none-any