diff --git a/.release-please-manifest.json b/.release-please-manifest.json index caf5ca3f..59acac47 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.26.0" + ".": "0.27.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index f80e20ce..87a747f2 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 641 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/gcore%2Fgcore-2c3abe1f1637f97f6bc750aff6eb77efc45ac2b527376541ac2af6b9626b35af.yml openapi_spec_hash: ff74a4ccd9ec5ddb1a65963d52e709ba -config_hash: 0df262ae146e43627e9daf27e6b3bebf +config_hash: 74d2c4eaca28539e6694ab47fe0c34db diff --git a/CHANGELOG.md b/CHANGELOG.md index 129d52ff..2df7d10e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog +## 0.27.0 (2025-12-30) + +Full Changelog: [v0.26.0...v0.27.0](https://github.com/G-Core/gcore-python/compare/v0.26.0...v0.27.0) + +### Features + +* **api:** manual updates ([e6fec4e](https://github.com/G-Core/gcore-python/commit/e6fec4e8c85de66bd2557833cd03f38c30b19ecd)) + ## 0.26.0 (2025-12-23) Full Changelog: [v0.25.0...v0.26.0](https://github.com/G-Core/gcore-python/compare/v0.25.0...v0.26.0) diff --git a/api.md b/api.md index 562bb4ed..b7509aeb 100644 --- a/api.md +++ b/api.md @@ -773,40 +773,42 @@ Methods: - client.cloud.billing_reservations.list(\*\*params) -> BillingReservations -## GPUBaremetalClusters +## GPUBaremetal + +### Clusters Types: ```python -from gcore.types.cloud import GPUBaremetalCluster +from gcore.types.cloud.gpu_baremetal import GPUBaremetalCluster ``` Methods: -- client.cloud.gpu_baremetal_clusters.create(\*, project_id, region_id, \*\*params) -> TaskIDList -- client.cloud.gpu_baremetal_clusters.list(\*, project_id, region_id, \*\*params) -> SyncOffsetPage[GPUBaremetalCluster] -- client.cloud.gpu_baremetal_clusters.delete(cluster_id, \*, project_id, region_id, \*\*params) -> TaskIDList -- client.cloud.gpu_baremetal_clusters.action(cluster_id, \*, project_id, region_id, \*\*params) -> TaskIDList -- client.cloud.gpu_baremetal_clusters.get(cluster_id, \*, project_id, region_id) -> GPUBaremetalCluster -- client.cloud.gpu_baremetal_clusters.powercycle_all_servers(cluster_id, \*, project_id, region_id) -> GPUBaremetalClusterServerV1List -- client.cloud.gpu_baremetal_clusters.reboot_all_servers(cluster_id, \*, project_id, region_id) -> GPUBaremetalClusterServerV1List -- client.cloud.gpu_baremetal_clusters.rebuild(cluster_id, \*, project_id, region_id, \*\*params) -> TaskIDList -- client.cloud.gpu_baremetal_clusters.resize(cluster_id, \*, project_id, region_id, \*\*params) -> TaskIDList +- client.cloud.gpu_baremetal.clusters.create(\*, project_id, region_id, \*\*params) -> TaskIDList +- client.cloud.gpu_baremetal.clusters.list(\*, project_id, region_id, \*\*params) -> SyncOffsetPage[GPUBaremetalCluster] +- client.cloud.gpu_baremetal.clusters.delete(cluster_id, \*, project_id, region_id, \*\*params) -> TaskIDList +- client.cloud.gpu_baremetal.clusters.action(cluster_id, \*, project_id, region_id, \*\*params) -> TaskIDList +- client.cloud.gpu_baremetal.clusters.get(cluster_id, \*, project_id, region_id) -> GPUBaremetalCluster +- client.cloud.gpu_baremetal.clusters.powercycle_all_servers(cluster_id, \*, project_id, region_id) -> GPUBaremetalClusterServerV1List +- client.cloud.gpu_baremetal.clusters.reboot_all_servers(cluster_id, \*, project_id, region_id) -> GPUBaremetalClusterServerV1List +- client.cloud.gpu_baremetal.clusters.rebuild(cluster_id, \*, project_id, region_id, \*\*params) -> TaskIDList +- client.cloud.gpu_baremetal.clusters.resize(cluster_id, \*, project_id, region_id, \*\*params) -> TaskIDList -### Interfaces +#### Interfaces Methods: -- client.cloud.gpu_baremetal_clusters.interfaces.list(cluster_id, \*, project_id, region_id) -> NetworkInterfaceList -- client.cloud.gpu_baremetal_clusters.interfaces.attach(instance_id, \*, project_id, region_id, \*\*params) -> TaskIDList -- client.cloud.gpu_baremetal_clusters.interfaces.detach(instance_id, \*, project_id, region_id, \*\*params) -> TaskIDList +- client.cloud.gpu_baremetal.clusters.interfaces.list(cluster_id, \*, project_id, region_id) -> NetworkInterfaceList +- client.cloud.gpu_baremetal.clusters.interfaces.attach(instance_id, \*, project_id, region_id, \*\*params) -> TaskIDList +- client.cloud.gpu_baremetal.clusters.interfaces.detach(instance_id, \*, project_id, region_id, \*\*params) -> TaskIDList -### Servers +#### Servers Types: ```python -from gcore.types.cloud.gpu_baremetal_clusters import ( +from gcore.types.cloud.gpu_baremetal.clusters import ( GPUBaremetalClusterServer, GPUBaremetalClusterServerV1, GPUBaremetalClusterServerV1List, @@ -815,32 +817,32 @@ from gcore.types.cloud.gpu_baremetal_clusters import ( Methods: -- client.cloud.gpu_baremetal_clusters.servers.list(cluster_id, \*, project_id, region_id, \*\*params) -> SyncOffsetPage[GPUBaremetalClusterServer] -- client.cloud.gpu_baremetal_clusters.servers.delete(instance_id, \*, project_id, region_id, cluster_id, \*\*params) -> TaskIDList -- client.cloud.gpu_baremetal_clusters.servers.get_console(instance_id, \*, project_id, region_id) -> Console -- client.cloud.gpu_baremetal_clusters.servers.powercycle(instance_id, \*, project_id, region_id) -> GPUBaremetalClusterServerV1 -- client.cloud.gpu_baremetal_clusters.servers.reboot(instance_id, \*, project_id, region_id) -> GPUBaremetalClusterServerV1 +- client.cloud.gpu_baremetal.clusters.servers.list(cluster_id, \*, project_id, region_id, \*\*params) -> SyncOffsetPage[GPUBaremetalClusterServer] +- client.cloud.gpu_baremetal.clusters.servers.delete(instance_id, \*, project_id, region_id, cluster_id, \*\*params) -> TaskIDList +- client.cloud.gpu_baremetal.clusters.servers.get_console(instance_id, \*, project_id, region_id) -> Console +- client.cloud.gpu_baremetal.clusters.servers.powercycle(instance_id, \*, project_id, region_id) -> GPUBaremetalClusterServerV1 +- client.cloud.gpu_baremetal.clusters.servers.reboot(instance_id, \*, project_id, region_id) -> GPUBaremetalClusterServerV1 -### Flavors +#### Flavors Types: ```python -from gcore.types.cloud.gpu_baremetal_clusters import GPUBaremetalFlavor, GPUBaremetalFlavorList +from gcore.types.cloud.gpu_baremetal.clusters import GPUBaremetalFlavor, GPUBaremetalFlavorList ``` Methods: -- client.cloud.gpu_baremetal_clusters.flavors.list(\*, project_id, region_id, \*\*params) -> GPUBaremetalFlavorList +- client.cloud.gpu_baremetal.clusters.flavors.list(\*, project_id, region_id, \*\*params) -> GPUBaremetalFlavorList -### Images +#### Images Methods: -- client.cloud.gpu_baremetal_clusters.images.list(\*, project_id, region_id) -> GPUImageList -- client.cloud.gpu_baremetal_clusters.images.delete(image_id, \*, project_id, region_id) -> TaskIDList -- client.cloud.gpu_baremetal_clusters.images.get(image_id, \*, project_id, region_id) -> GPUImage -- client.cloud.gpu_baremetal_clusters.images.upload(\*, project_id, region_id, \*\*params) -> TaskIDList +- client.cloud.gpu_baremetal.clusters.images.list(\*, project_id, region_id) -> GPUImageList +- client.cloud.gpu_baremetal.clusters.images.delete(image_id, \*, project_id, region_id) -> TaskIDList +- client.cloud.gpu_baremetal.clusters.images.get(image_id, \*, project_id, region_id) -> GPUImage +- client.cloud.gpu_baremetal.clusters.images.upload(\*, project_id, region_id, \*\*params) -> TaskIDList ## GPUVirtual diff --git a/pyproject.toml b/pyproject.toml index 6d4eae5e..62a99509 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "gcore" -version = "0.26.0" +version = "0.27.0" description = "The official Python library for the gcore API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/gcore/_version.py b/src/gcore/_version.py index 3749030a..f59c6bde 100644 --- a/src/gcore/_version.py +++ b/src/gcore/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "gcore" -__version__ = "0.26.0" # x-release-please-version +__version__ = "0.27.0" # x-release-please-version diff --git a/src/gcore/resources/cloud/__init__.py b/src/gcore/resources/cloud/__init__.py index e4c125cc..36c2a495 100644 --- a/src/gcore/resources/cloud/__init__.py +++ b/src/gcore/resources/cloud/__init__.py @@ -176,6 +176,14 @@ FloatingIPsResourceWithStreamingResponse, AsyncFloatingIPsResourceWithStreamingResponse, ) +from .gpu_baremetal import ( + GPUBaremetalResource, + AsyncGPUBaremetalResource, + GPUBaremetalResourceWithRawResponse, + AsyncGPUBaremetalResourceWithRawResponse, + GPUBaremetalResourceWithStreamingResponse, + AsyncGPUBaremetalResourceWithStreamingResponse, +) from .usage_reports import ( UsageReportsResource, AsyncUsageReportsResource, @@ -224,14 +232,6 @@ BillingReservationsResourceWithStreamingResponse, AsyncBillingReservationsResourceWithStreamingResponse, ) -from .gpu_baremetal_clusters import ( - GPUBaremetalClustersResource, - AsyncGPUBaremetalClustersResource, - GPUBaremetalClustersResourceWithRawResponse, - AsyncGPUBaremetalClustersResourceWithRawResponse, - GPUBaremetalClustersResourceWithStreamingResponse, - AsyncGPUBaremetalClustersResourceWithStreamingResponse, -) __all__ = [ "ProjectsResource", @@ -354,12 +354,12 @@ "AsyncBillingReservationsResourceWithRawResponse", "BillingReservationsResourceWithStreamingResponse", "AsyncBillingReservationsResourceWithStreamingResponse", - "GPUBaremetalClustersResource", - "AsyncGPUBaremetalClustersResource", - "GPUBaremetalClustersResourceWithRawResponse", - "AsyncGPUBaremetalClustersResourceWithRawResponse", - "GPUBaremetalClustersResourceWithStreamingResponse", - "AsyncGPUBaremetalClustersResourceWithStreamingResponse", + "GPUBaremetalResource", + "AsyncGPUBaremetalResource", + "GPUBaremetalResourceWithRawResponse", + "AsyncGPUBaremetalResourceWithRawResponse", + "GPUBaremetalResourceWithStreamingResponse", + "AsyncGPUBaremetalResourceWithStreamingResponse", "GPUVirtualResource", "AsyncGPUVirtualResource", "GPUVirtualResourceWithRawResponse", diff --git a/src/gcore/resources/cloud/cloud.py b/src/gcore/resources/cloud/cloud.py index 9db7efd3..f8c91a68 100644 --- a/src/gcore/resources/cloud/cloud.py +++ b/src/gcore/resources/cloud/cloud.py @@ -196,6 +196,14 @@ GPUVirtualResourceWithStreamingResponse, AsyncGPUVirtualResourceWithStreamingResponse, ) +from .gpu_baremetal.gpu_baremetal import ( + GPUBaremetalResource, + AsyncGPUBaremetalResource, + GPUBaremetalResourceWithRawResponse, + AsyncGPUBaremetalResourceWithRawResponse, + GPUBaremetalResourceWithStreamingResponse, + AsyncGPUBaremetalResourceWithStreamingResponse, +) from .load_balancers.load_balancers import ( LoadBalancersResource, AsyncLoadBalancersResource, @@ -220,14 +228,6 @@ ReservedFixedIPsResourceWithStreamingResponse, AsyncReservedFixedIPsResourceWithStreamingResponse, ) -from .gpu_baremetal_clusters.gpu_baremetal_clusters import ( - GPUBaremetalClustersResource, - AsyncGPUBaremetalClustersResource, - GPUBaremetalClustersResourceWithRawResponse, - AsyncGPUBaremetalClustersResourceWithRawResponse, - GPUBaremetalClustersResourceWithStreamingResponse, - AsyncGPUBaremetalClustersResourceWithStreamingResponse, -) __all__ = ["CloudResource", "AsyncCloudResource"] @@ -321,8 +321,8 @@ def billing_reservations(self) -> BillingReservationsResource: return BillingReservationsResource(self._client) @cached_property - def gpu_baremetal_clusters(self) -> GPUBaremetalClustersResource: - return GPUBaremetalClustersResource(self._client) + def gpu_baremetal(self) -> GPUBaremetalResource: + return GPUBaremetalResource(self._client) @cached_property def gpu_virtual(self) -> GPUVirtualResource: @@ -461,8 +461,8 @@ def billing_reservations(self) -> AsyncBillingReservationsResource: return AsyncBillingReservationsResource(self._client) @cached_property - def gpu_baremetal_clusters(self) -> AsyncGPUBaremetalClustersResource: - return AsyncGPUBaremetalClustersResource(self._client) + def gpu_baremetal(self) -> AsyncGPUBaremetalResource: + return AsyncGPUBaremetalResource(self._client) @cached_property def gpu_virtual(self) -> AsyncGPUVirtualResource: @@ -604,8 +604,8 @@ def billing_reservations(self) -> BillingReservationsResourceWithRawResponse: return BillingReservationsResourceWithRawResponse(self._cloud.billing_reservations) @cached_property - def gpu_baremetal_clusters(self) -> GPUBaremetalClustersResourceWithRawResponse: - return GPUBaremetalClustersResourceWithRawResponse(self._cloud.gpu_baremetal_clusters) + def gpu_baremetal(self) -> GPUBaremetalResourceWithRawResponse: + return GPUBaremetalResourceWithRawResponse(self._cloud.gpu_baremetal) @cached_property def gpu_virtual(self) -> GPUVirtualResourceWithRawResponse: @@ -728,8 +728,8 @@ def billing_reservations(self) -> AsyncBillingReservationsResourceWithRawRespons return AsyncBillingReservationsResourceWithRawResponse(self._cloud.billing_reservations) @cached_property - def gpu_baremetal_clusters(self) -> AsyncGPUBaremetalClustersResourceWithRawResponse: - return AsyncGPUBaremetalClustersResourceWithRawResponse(self._cloud.gpu_baremetal_clusters) + def gpu_baremetal(self) -> AsyncGPUBaremetalResourceWithRawResponse: + return AsyncGPUBaremetalResourceWithRawResponse(self._cloud.gpu_baremetal) @cached_property def gpu_virtual(self) -> AsyncGPUVirtualResourceWithRawResponse: @@ -852,8 +852,8 @@ def billing_reservations(self) -> BillingReservationsResourceWithStreamingRespon return BillingReservationsResourceWithStreamingResponse(self._cloud.billing_reservations) @cached_property - def gpu_baremetal_clusters(self) -> GPUBaremetalClustersResourceWithStreamingResponse: - return GPUBaremetalClustersResourceWithStreamingResponse(self._cloud.gpu_baremetal_clusters) + def gpu_baremetal(self) -> GPUBaremetalResourceWithStreamingResponse: + return GPUBaremetalResourceWithStreamingResponse(self._cloud.gpu_baremetal) @cached_property def gpu_virtual(self) -> GPUVirtualResourceWithStreamingResponse: @@ -976,8 +976,8 @@ def billing_reservations(self) -> AsyncBillingReservationsResourceWithStreamingR return AsyncBillingReservationsResourceWithStreamingResponse(self._cloud.billing_reservations) @cached_property - def gpu_baremetal_clusters(self) -> AsyncGPUBaremetalClustersResourceWithStreamingResponse: - return AsyncGPUBaremetalClustersResourceWithStreamingResponse(self._cloud.gpu_baremetal_clusters) + def gpu_baremetal(self) -> AsyncGPUBaremetalResourceWithStreamingResponse: + return AsyncGPUBaremetalResourceWithStreamingResponse(self._cloud.gpu_baremetal) @cached_property def gpu_virtual(self) -> AsyncGPUVirtualResourceWithStreamingResponse: diff --git a/src/gcore/resources/cloud/gpu_baremetal/__init__.py b/src/gcore/resources/cloud/gpu_baremetal/__init__.py new file mode 100644 index 00000000..d8e97060 --- /dev/null +++ b/src/gcore/resources/cloud/gpu_baremetal/__init__.py @@ -0,0 +1,33 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from .clusters import ( + ClustersResource, + AsyncClustersResource, + ClustersResourceWithRawResponse, + AsyncClustersResourceWithRawResponse, + ClustersResourceWithStreamingResponse, + AsyncClustersResourceWithStreamingResponse, +) +from .gpu_baremetal import ( + GPUBaremetalResource, + AsyncGPUBaremetalResource, + GPUBaremetalResourceWithRawResponse, + AsyncGPUBaremetalResourceWithRawResponse, + GPUBaremetalResourceWithStreamingResponse, + AsyncGPUBaremetalResourceWithStreamingResponse, +) + +__all__ = [ + "ClustersResource", + "AsyncClustersResource", + "ClustersResourceWithRawResponse", + "AsyncClustersResourceWithRawResponse", + "ClustersResourceWithStreamingResponse", + "AsyncClustersResourceWithStreamingResponse", + "GPUBaremetalResource", + "AsyncGPUBaremetalResource", + "GPUBaremetalResourceWithRawResponse", + "AsyncGPUBaremetalResourceWithRawResponse", + "GPUBaremetalResourceWithStreamingResponse", + "AsyncGPUBaremetalResourceWithStreamingResponse", +] diff --git a/src/gcore/resources/cloud/gpu_baremetal_clusters/__init__.py b/src/gcore/resources/cloud/gpu_baremetal/clusters/__init__.py similarity index 75% rename from src/gcore/resources/cloud/gpu_baremetal_clusters/__init__.py rename to src/gcore/resources/cloud/gpu_baremetal/clusters/__init__.py index ecfb4752..10acfe5d 100644 --- a/src/gcore/resources/cloud/gpu_baremetal_clusters/__init__.py +++ b/src/gcore/resources/cloud/gpu_baremetal/clusters/__init__.py @@ -24,6 +24,14 @@ ServersResourceWithStreamingResponse, AsyncServersResourceWithStreamingResponse, ) +from .clusters import ( + ClustersResource, + AsyncClustersResource, + ClustersResourceWithRawResponse, + AsyncClustersResourceWithRawResponse, + ClustersResourceWithStreamingResponse, + AsyncClustersResourceWithStreamingResponse, +) from .interfaces import ( InterfacesResource, AsyncInterfacesResource, @@ -32,14 +40,6 @@ InterfacesResourceWithStreamingResponse, AsyncInterfacesResourceWithStreamingResponse, ) -from .gpu_baremetal_clusters import ( - GPUBaremetalClustersResource, - AsyncGPUBaremetalClustersResource, - GPUBaremetalClustersResourceWithRawResponse, - AsyncGPUBaremetalClustersResourceWithRawResponse, - GPUBaremetalClustersResourceWithStreamingResponse, - AsyncGPUBaremetalClustersResourceWithStreamingResponse, -) __all__ = [ "InterfacesResource", @@ -66,10 +66,10 @@ "AsyncImagesResourceWithRawResponse", "ImagesResourceWithStreamingResponse", "AsyncImagesResourceWithStreamingResponse", - "GPUBaremetalClustersResource", - "AsyncGPUBaremetalClustersResource", - "GPUBaremetalClustersResourceWithRawResponse", - "AsyncGPUBaremetalClustersResourceWithRawResponse", - "GPUBaremetalClustersResourceWithStreamingResponse", - "AsyncGPUBaremetalClustersResourceWithStreamingResponse", + "ClustersResource", + "AsyncClustersResource", + "ClustersResourceWithRawResponse", + "AsyncClustersResourceWithRawResponse", + "ClustersResourceWithStreamingResponse", + "AsyncClustersResourceWithStreamingResponse", ] diff --git a/src/gcore/resources/cloud/gpu_baremetal_clusters/gpu_baremetal_clusters.py b/src/gcore/resources/cloud/gpu_baremetal/clusters/clusters.py similarity index 88% rename from src/gcore/resources/cloud/gpu_baremetal_clusters/gpu_baremetal_clusters.py rename to src/gcore/resources/cloud/gpu_baremetal/clusters/clusters.py index 76cfb8d8..130b0821 100644 --- a/src/gcore/resources/cloud/gpu_baremetal_clusters/gpu_baremetal_clusters.py +++ b/src/gcore/resources/cloud/gpu_baremetal/clusters/clusters.py @@ -31,9 +31,8 @@ ServersResourceWithStreamingResponse, AsyncServersResourceWithStreamingResponse, ) -from ...._types import NOT_GIVEN, Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given -from ...._utils import maybe_transform, async_maybe_transform -from ...._compat import cached_property +from ....._types import NOT_GIVEN, Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given +from ....._utils import maybe_transform, async_maybe_transform from .interfaces import ( InterfacesResource, AsyncInterfacesResource, @@ -42,32 +41,33 @@ InterfacesResourceWithStreamingResponse, AsyncInterfacesResourceWithStreamingResponse, ) -from ...._resource import SyncAPIResource, AsyncAPIResource -from ...._response import ( +from ....._compat import cached_property +from ....._resource import SyncAPIResource, AsyncAPIResource +from ....._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from ....pagination import SyncOffsetPage, AsyncOffsetPage -from ....types.cloud import ( - gpu_baremetal_cluster_list_params, - gpu_baremetal_cluster_action_params, - gpu_baremetal_cluster_create_params, - gpu_baremetal_cluster_delete_params, - gpu_baremetal_cluster_resize_params, - gpu_baremetal_cluster_rebuild_params, +from .....pagination import SyncOffsetPage, AsyncOffsetPage +from ....._base_client import AsyncPaginator, make_request_options +from .....types.cloud.task_id_list import TaskIDList +from .....types.cloud.gpu_baremetal import ( + cluster_list_params, + cluster_action_params, + cluster_create_params, + cluster_delete_params, + cluster_resize_params, + cluster_rebuild_params, ) -from ...._base_client import AsyncPaginator, make_request_options -from ....types.cloud.task_id_list import TaskIDList -from ....types.cloud.tag_update_map_param import TagUpdateMapParam -from ....types.cloud.gpu_baremetal_cluster import GPUBaremetalCluster -from ....types.cloud.gpu_baremetal_clusters.gpu_baremetal_cluster_server_v1_list import GPUBaremetalClusterServerV1List +from .....types.cloud.tag_update_map_param import TagUpdateMapParam +from .....types.cloud.gpu_baremetal.gpu_baremetal_cluster import GPUBaremetalCluster +from .....types.cloud.gpu_baremetal.clusters.gpu_baremetal_cluster_server_v1_list import GPUBaremetalClusterServerV1List -__all__ = ["GPUBaremetalClustersResource", "AsyncGPUBaremetalClustersResource"] +__all__ = ["ClustersResource", "AsyncClustersResource"] -class GPUBaremetalClustersResource(SyncAPIResource): +class ClustersResource(SyncAPIResource): @cached_property def interfaces(self) -> InterfacesResource: return InterfacesResource(self._client) @@ -85,23 +85,23 @@ def images(self) -> ImagesResource: return ImagesResource(self._client) @cached_property - def with_raw_response(self) -> GPUBaremetalClustersResourceWithRawResponse: + def with_raw_response(self) -> ClustersResourceWithRawResponse: """ This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. For more information, see https://www.github.com/G-Core/gcore-python#accessing-raw-response-data-eg-headers """ - return GPUBaremetalClustersResourceWithRawResponse(self) + return ClustersResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> GPUBaremetalClustersResourceWithStreamingResponse: + def with_streaming_response(self) -> ClustersResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. For more information, see https://www.github.com/G-Core/gcore-python#with_streaming_response """ - return GPUBaremetalClustersResourceWithStreamingResponse(self) + return ClustersResourceWithStreamingResponse(self) def create( self, @@ -112,7 +112,7 @@ def create( image_id: str, name: str, servers_count: int, - servers_settings: gpu_baremetal_cluster_create_params.ServersSettings, + servers_settings: cluster_create_params.ServersSettings, tags: Dict[str, str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. # The extra values given here take precedence over values defined on the client or passed to this method. @@ -169,7 +169,7 @@ def create( "servers_settings": servers_settings, "tags": tags, }, - gpu_baremetal_cluster_create_params.GPUBaremetalClusterCreateParams, + cluster_create_params.ClusterCreateParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout @@ -236,7 +236,7 @@ def list( "managed_by": managed_by, "offset": offset, }, - gpu_baremetal_cluster_list_params.GPUBaremetalClusterListParams, + cluster_list_params.ClusterListParams, ), ), model=GPUBaremetalCluster, @@ -307,7 +307,7 @@ def delete( "floating_ip_ids": floating_ip_ids, "reserved_fixed_ip_ids": reserved_fixed_ip_ids, }, - gpu_baremetal_cluster_delete_params.GPUBaremetalClusterDeleteParams, + cluster_delete_params.ClusterDeleteParams, ), ), cast_to=TaskIDList, @@ -390,7 +390,7 @@ def action( "action": action, "tags": tags, }, - gpu_baremetal_cluster_action_params.GPUBaremetalClusterActionParams, + cluster_action_params.ClusterActionParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout @@ -573,7 +573,7 @@ def rebuild( "image_id": image_id, "user_data": user_data, }, - gpu_baremetal_cluster_rebuild_params.GPUBaremetalClusterRebuildParams, + cluster_rebuild_params.ClusterRebuildParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout @@ -619,10 +619,7 @@ def resize( raise ValueError(f"Expected a non-empty value for `cluster_id` but received {cluster_id!r}") return self._post( f"/cloud/v1/ai/clusters/gpu/{project_id}/{region_id}/{cluster_id}/resize", - body=maybe_transform( - {"instances_count": instances_count}, - gpu_baremetal_cluster_resize_params.GPUBaremetalClusterResizeParams, - ), + body=maybe_transform({"instances_count": instances_count}, cluster_resize_params.ClusterResizeParams), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout ), @@ -638,7 +635,7 @@ def create_and_poll( image_id: str, name: str, servers_count: int, - servers_settings: gpu_baremetal_cluster_create_params.ServersSettings, + servers_settings: cluster_create_params.ServersSettings, tags: Dict[str, str] | Omit = omit, polling_interval_seconds: int | Omit = omit, polling_timeout_seconds: int | Omit = omit, @@ -792,7 +789,7 @@ def resize_and_poll( ) -class AsyncGPUBaremetalClustersResource(AsyncAPIResource): +class AsyncClustersResource(AsyncAPIResource): @cached_property def interfaces(self) -> AsyncInterfacesResource: return AsyncInterfacesResource(self._client) @@ -810,23 +807,23 @@ def images(self) -> AsyncImagesResource: return AsyncImagesResource(self._client) @cached_property - def with_raw_response(self) -> AsyncGPUBaremetalClustersResourceWithRawResponse: + def with_raw_response(self) -> AsyncClustersResourceWithRawResponse: """ This property can be used as a prefix for any HTTP method call to return the raw response object instead of the parsed content. For more information, see https://www.github.com/G-Core/gcore-python#accessing-raw-response-data-eg-headers """ - return AsyncGPUBaremetalClustersResourceWithRawResponse(self) + return AsyncClustersResourceWithRawResponse(self) @cached_property - def with_streaming_response(self) -> AsyncGPUBaremetalClustersResourceWithStreamingResponse: + def with_streaming_response(self) -> AsyncClustersResourceWithStreamingResponse: """ An alternative to `.with_raw_response` that doesn't eagerly read the response body. For more information, see https://www.github.com/G-Core/gcore-python#with_streaming_response """ - return AsyncGPUBaremetalClustersResourceWithStreamingResponse(self) + return AsyncClustersResourceWithStreamingResponse(self) async def create( self, @@ -837,7 +834,7 @@ async def create( image_id: str, name: str, servers_count: int, - servers_settings: gpu_baremetal_cluster_create_params.ServersSettings, + servers_settings: cluster_create_params.ServersSettings, tags: Dict[str, str] | Omit = omit, # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. # The extra values given here take precedence over values defined on the client or passed to this method. @@ -894,7 +891,7 @@ async def create( "servers_settings": servers_settings, "tags": tags, }, - gpu_baremetal_cluster_create_params.GPUBaremetalClusterCreateParams, + cluster_create_params.ClusterCreateParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout @@ -961,7 +958,7 @@ def list( "managed_by": managed_by, "offset": offset, }, - gpu_baremetal_cluster_list_params.GPUBaremetalClusterListParams, + cluster_list_params.ClusterListParams, ), ), model=GPUBaremetalCluster, @@ -1032,7 +1029,7 @@ async def delete( "floating_ip_ids": floating_ip_ids, "reserved_fixed_ip_ids": reserved_fixed_ip_ids, }, - gpu_baremetal_cluster_delete_params.GPUBaremetalClusterDeleteParams, + cluster_delete_params.ClusterDeleteParams, ), ), cast_to=TaskIDList, @@ -1115,7 +1112,7 @@ async def action( "action": action, "tags": tags, }, - gpu_baremetal_cluster_action_params.GPUBaremetalClusterActionParams, + cluster_action_params.ClusterActionParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout @@ -1298,7 +1295,7 @@ async def rebuild( "image_id": image_id, "user_data": user_data, }, - gpu_baremetal_cluster_rebuild_params.GPUBaremetalClusterRebuildParams, + cluster_rebuild_params.ClusterRebuildParams, ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout @@ -1345,8 +1342,7 @@ async def resize( return await self._post( f"/cloud/v1/ai/clusters/gpu/{project_id}/{region_id}/{cluster_id}/resize", body=await async_maybe_transform( - {"instances_count": instances_count}, - gpu_baremetal_cluster_resize_params.GPUBaremetalClusterResizeParams, + {"instances_count": instances_count}, cluster_resize_params.ClusterResizeParams ), options=make_request_options( extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout @@ -1363,7 +1359,7 @@ async def create_and_poll( image_id: str, name: str, servers_count: int, - servers_settings: gpu_baremetal_cluster_create_params.ServersSettings, + servers_settings: cluster_create_params.ServersSettings, tags: Dict[str, str] | Omit = omit, polling_interval_seconds: int | Omit = omit, polling_timeout_seconds: int | Omit = omit, @@ -1517,233 +1513,233 @@ async def resize_and_poll( ) -class GPUBaremetalClustersResourceWithRawResponse: - def __init__(self, gpu_baremetal_clusters: GPUBaremetalClustersResource) -> None: - self._gpu_baremetal_clusters = gpu_baremetal_clusters +class ClustersResourceWithRawResponse: + def __init__(self, clusters: ClustersResource) -> None: + self._clusters = clusters self.create = to_raw_response_wrapper( - gpu_baremetal_clusters.create, + clusters.create, ) self.list = to_raw_response_wrapper( - gpu_baremetal_clusters.list, + clusters.list, ) self.delete = to_raw_response_wrapper( - gpu_baremetal_clusters.delete, + clusters.delete, ) self.action = to_raw_response_wrapper( - gpu_baremetal_clusters.action, + clusters.action, ) self.get = to_raw_response_wrapper( - gpu_baremetal_clusters.get, + clusters.get, ) self.powercycle_all_servers = to_raw_response_wrapper( - gpu_baremetal_clusters.powercycle_all_servers, + clusters.powercycle_all_servers, ) self.reboot_all_servers = to_raw_response_wrapper( - gpu_baremetal_clusters.reboot_all_servers, + clusters.reboot_all_servers, ) self.rebuild = to_raw_response_wrapper( - gpu_baremetal_clusters.rebuild, + clusters.rebuild, ) self.resize = to_raw_response_wrapper( - gpu_baremetal_clusters.resize, + clusters.resize, ) self.create_and_poll = to_raw_response_wrapper( - gpu_baremetal_clusters.create_and_poll, + clusters.create_and_poll, ) self.rebuild_and_poll = to_raw_response_wrapper( - gpu_baremetal_clusters.rebuild_and_poll, + clusters.rebuild_and_poll, ) self.resize_and_poll = to_raw_response_wrapper( - gpu_baremetal_clusters.resize_and_poll, + clusters.resize_and_poll, ) @cached_property def interfaces(self) -> InterfacesResourceWithRawResponse: - return InterfacesResourceWithRawResponse(self._gpu_baremetal_clusters.interfaces) + return InterfacesResourceWithRawResponse(self._clusters.interfaces) @cached_property def servers(self) -> ServersResourceWithRawResponse: - return ServersResourceWithRawResponse(self._gpu_baremetal_clusters.servers) + return ServersResourceWithRawResponse(self._clusters.servers) @cached_property def flavors(self) -> FlavorsResourceWithRawResponse: - return FlavorsResourceWithRawResponse(self._gpu_baremetal_clusters.flavors) + return FlavorsResourceWithRawResponse(self._clusters.flavors) @cached_property def images(self) -> ImagesResourceWithRawResponse: - return ImagesResourceWithRawResponse(self._gpu_baremetal_clusters.images) + return ImagesResourceWithRawResponse(self._clusters.images) -class AsyncGPUBaremetalClustersResourceWithRawResponse: - def __init__(self, gpu_baremetal_clusters: AsyncGPUBaremetalClustersResource) -> None: - self._gpu_baremetal_clusters = gpu_baremetal_clusters +class AsyncClustersResourceWithRawResponse: + def __init__(self, clusters: AsyncClustersResource) -> None: + self._clusters = clusters self.create = async_to_raw_response_wrapper( - gpu_baremetal_clusters.create, + clusters.create, ) self.list = async_to_raw_response_wrapper( - gpu_baremetal_clusters.list, + clusters.list, ) self.delete = async_to_raw_response_wrapper( - gpu_baremetal_clusters.delete, + clusters.delete, ) self.action = async_to_raw_response_wrapper( - gpu_baremetal_clusters.action, + clusters.action, ) self.get = async_to_raw_response_wrapper( - gpu_baremetal_clusters.get, + clusters.get, ) self.powercycle_all_servers = async_to_raw_response_wrapper( - gpu_baremetal_clusters.powercycle_all_servers, + clusters.powercycle_all_servers, ) self.reboot_all_servers = async_to_raw_response_wrapper( - gpu_baremetal_clusters.reboot_all_servers, + clusters.reboot_all_servers, ) self.rebuild = async_to_raw_response_wrapper( - gpu_baremetal_clusters.rebuild, + clusters.rebuild, ) self.resize = async_to_raw_response_wrapper( - gpu_baremetal_clusters.resize, + clusters.resize, ) self.create_and_poll = async_to_raw_response_wrapper( - gpu_baremetal_clusters.create_and_poll, + clusters.create_and_poll, ) self.rebuild_and_poll = async_to_raw_response_wrapper( - gpu_baremetal_clusters.rebuild_and_poll, + clusters.rebuild_and_poll, ) self.resize_and_poll = async_to_raw_response_wrapper( - gpu_baremetal_clusters.resize_and_poll, + clusters.resize_and_poll, ) @cached_property def interfaces(self) -> AsyncInterfacesResourceWithRawResponse: - return AsyncInterfacesResourceWithRawResponse(self._gpu_baremetal_clusters.interfaces) + return AsyncInterfacesResourceWithRawResponse(self._clusters.interfaces) @cached_property def servers(self) -> AsyncServersResourceWithRawResponse: - return AsyncServersResourceWithRawResponse(self._gpu_baremetal_clusters.servers) + return AsyncServersResourceWithRawResponse(self._clusters.servers) @cached_property def flavors(self) -> AsyncFlavorsResourceWithRawResponse: - return AsyncFlavorsResourceWithRawResponse(self._gpu_baremetal_clusters.flavors) + return AsyncFlavorsResourceWithRawResponse(self._clusters.flavors) @cached_property def images(self) -> AsyncImagesResourceWithRawResponse: - return AsyncImagesResourceWithRawResponse(self._gpu_baremetal_clusters.images) + return AsyncImagesResourceWithRawResponse(self._clusters.images) -class GPUBaremetalClustersResourceWithStreamingResponse: - def __init__(self, gpu_baremetal_clusters: GPUBaremetalClustersResource) -> None: - self._gpu_baremetal_clusters = gpu_baremetal_clusters +class ClustersResourceWithStreamingResponse: + def __init__(self, clusters: ClustersResource) -> None: + self._clusters = clusters self.create = to_streamed_response_wrapper( - gpu_baremetal_clusters.create, + clusters.create, ) self.list = to_streamed_response_wrapper( - gpu_baremetal_clusters.list, + clusters.list, ) self.delete = to_streamed_response_wrapper( - gpu_baremetal_clusters.delete, + clusters.delete, ) self.action = to_streamed_response_wrapper( - gpu_baremetal_clusters.action, + clusters.action, ) self.get = to_streamed_response_wrapper( - gpu_baremetal_clusters.get, + clusters.get, ) self.powercycle_all_servers = to_streamed_response_wrapper( - gpu_baremetal_clusters.powercycle_all_servers, + clusters.powercycle_all_servers, ) self.reboot_all_servers = to_streamed_response_wrapper( - gpu_baremetal_clusters.reboot_all_servers, + clusters.reboot_all_servers, ) self.rebuild = to_streamed_response_wrapper( - gpu_baremetal_clusters.rebuild, + clusters.rebuild, ) self.resize = to_streamed_response_wrapper( - gpu_baremetal_clusters.resize, + clusters.resize, ) self.create_and_poll = to_streamed_response_wrapper( - gpu_baremetal_clusters.create_and_poll, + clusters.create_and_poll, ) self.rebuild_and_poll = to_streamed_response_wrapper( - gpu_baremetal_clusters.rebuild_and_poll, + clusters.rebuild_and_poll, ) self.resize_and_poll = to_streamed_response_wrapper( - gpu_baremetal_clusters.resize_and_poll, + clusters.resize_and_poll, ) @cached_property def interfaces(self) -> InterfacesResourceWithStreamingResponse: - return InterfacesResourceWithStreamingResponse(self._gpu_baremetal_clusters.interfaces) + return InterfacesResourceWithStreamingResponse(self._clusters.interfaces) @cached_property def servers(self) -> ServersResourceWithStreamingResponse: - return ServersResourceWithStreamingResponse(self._gpu_baremetal_clusters.servers) + return ServersResourceWithStreamingResponse(self._clusters.servers) @cached_property def flavors(self) -> FlavorsResourceWithStreamingResponse: - return FlavorsResourceWithStreamingResponse(self._gpu_baremetal_clusters.flavors) + return FlavorsResourceWithStreamingResponse(self._clusters.flavors) @cached_property def images(self) -> ImagesResourceWithStreamingResponse: - return ImagesResourceWithStreamingResponse(self._gpu_baremetal_clusters.images) + return ImagesResourceWithStreamingResponse(self._clusters.images) -class AsyncGPUBaremetalClustersResourceWithStreamingResponse: - def __init__(self, gpu_baremetal_clusters: AsyncGPUBaremetalClustersResource) -> None: - self._gpu_baremetal_clusters = gpu_baremetal_clusters +class AsyncClustersResourceWithStreamingResponse: + def __init__(self, clusters: AsyncClustersResource) -> None: + self._clusters = clusters self.create = async_to_streamed_response_wrapper( - gpu_baremetal_clusters.create, + clusters.create, ) self.list = async_to_streamed_response_wrapper( - gpu_baremetal_clusters.list, + clusters.list, ) self.delete = async_to_streamed_response_wrapper( - gpu_baremetal_clusters.delete, + clusters.delete, ) self.action = async_to_streamed_response_wrapper( - gpu_baremetal_clusters.action, + clusters.action, ) self.get = async_to_streamed_response_wrapper( - gpu_baremetal_clusters.get, + clusters.get, ) self.powercycle_all_servers = async_to_streamed_response_wrapper( - gpu_baremetal_clusters.powercycle_all_servers, + clusters.powercycle_all_servers, ) self.reboot_all_servers = async_to_streamed_response_wrapper( - gpu_baremetal_clusters.reboot_all_servers, + clusters.reboot_all_servers, ) self.rebuild = async_to_streamed_response_wrapper( - gpu_baremetal_clusters.rebuild, + clusters.rebuild, ) self.resize = async_to_streamed_response_wrapper( - gpu_baremetal_clusters.resize, + clusters.resize, ) self.create_and_poll = async_to_streamed_response_wrapper( - gpu_baremetal_clusters.create_and_poll, + clusters.create_and_poll, ) self.rebuild_and_poll = async_to_streamed_response_wrapper( - gpu_baremetal_clusters.rebuild_and_poll, + clusters.rebuild_and_poll, ) self.resize_and_poll = async_to_streamed_response_wrapper( - gpu_baremetal_clusters.resize_and_poll, + clusters.resize_and_poll, ) @cached_property def interfaces(self) -> AsyncInterfacesResourceWithStreamingResponse: - return AsyncInterfacesResourceWithStreamingResponse(self._gpu_baremetal_clusters.interfaces) + return AsyncInterfacesResourceWithStreamingResponse(self._clusters.interfaces) @cached_property def servers(self) -> AsyncServersResourceWithStreamingResponse: - return AsyncServersResourceWithStreamingResponse(self._gpu_baremetal_clusters.servers) + return AsyncServersResourceWithStreamingResponse(self._clusters.servers) @cached_property def flavors(self) -> AsyncFlavorsResourceWithStreamingResponse: - return AsyncFlavorsResourceWithStreamingResponse(self._gpu_baremetal_clusters.flavors) + return AsyncFlavorsResourceWithStreamingResponse(self._clusters.flavors) @cached_property def images(self) -> AsyncImagesResourceWithStreamingResponse: - return AsyncImagesResourceWithStreamingResponse(self._gpu_baremetal_clusters.images) + return AsyncImagesResourceWithStreamingResponse(self._clusters.images) diff --git a/src/gcore/resources/cloud/gpu_baremetal_clusters/flavors.py b/src/gcore/resources/cloud/gpu_baremetal/clusters/flavors.py similarity index 93% rename from src/gcore/resources/cloud/gpu_baremetal_clusters/flavors.py rename to src/gcore/resources/cloud/gpu_baremetal/clusters/flavors.py index 19df3189..486250ea 100644 --- a/src/gcore/resources/cloud/gpu_baremetal_clusters/flavors.py +++ b/src/gcore/resources/cloud/gpu_baremetal/clusters/flavors.py @@ -4,19 +4,19 @@ import httpx -from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given -from ...._utils import maybe_transform, async_maybe_transform -from ...._compat import cached_property -from ...._resource import SyncAPIResource, AsyncAPIResource -from ...._response import ( +from ....._types import Body, Omit, Query, Headers, NotGiven, omit, not_given +from ....._utils import maybe_transform, async_maybe_transform +from ....._compat import cached_property +from ....._resource import SyncAPIResource, AsyncAPIResource +from ....._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from ...._base_client import make_request_options -from ....types.cloud.gpu_baremetal_clusters import flavor_list_params -from ....types.cloud.gpu_baremetal_clusters.gpu_baremetal_flavor_list import GPUBaremetalFlavorList +from ....._base_client import make_request_options +from .....types.cloud.gpu_baremetal.clusters import flavor_list_params +from .....types.cloud.gpu_baremetal.clusters.gpu_baremetal_flavor_list import GPUBaremetalFlavorList __all__ = ["FlavorsResource", "AsyncFlavorsResource"] diff --git a/src/gcore/resources/cloud/gpu_baremetal_clusters/images.py b/src/gcore/resources/cloud/gpu_baremetal/clusters/images.py similarity index 98% rename from src/gcore/resources/cloud/gpu_baremetal_clusters/images.py rename to src/gcore/resources/cloud/gpu_baremetal/clusters/images.py index 26711e88..dee06b23 100644 --- a/src/gcore/resources/cloud/gpu_baremetal_clusters/images.py +++ b/src/gcore/resources/cloud/gpu_baremetal/clusters/images.py @@ -7,21 +7,21 @@ import httpx -from ...._types import NOT_GIVEN, Body, Omit, Query, Headers, NotGiven, omit, not_given -from ...._utils import maybe_transform, async_maybe_transform -from ...._compat import cached_property -from ...._resource import SyncAPIResource, AsyncAPIResource -from ...._response import ( +from ....._types import NOT_GIVEN, Body, Omit, Query, Headers, NotGiven, omit, not_given +from ....._utils import maybe_transform, async_maybe_transform +from ....._compat import cached_property +from ....._resource import SyncAPIResource, AsyncAPIResource +from ....._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from ...._base_client import make_request_options -from ....types.cloud.gpu_image import GPUImage -from ....types.cloud.task_id_list import TaskIDList -from ....types.cloud.gpu_image_list import GPUImageList -from ....types.cloud.gpu_baremetal_clusters import image_upload_params +from ....._base_client import make_request_options +from .....types.cloud.gpu_image import GPUImage +from .....types.cloud.task_id_list import TaskIDList +from .....types.cloud.gpu_image_list import GPUImageList +from .....types.cloud.gpu_baremetal.clusters import image_upload_params __all__ = ["ImagesResource", "AsyncImagesResource"] diff --git a/src/gcore/resources/cloud/gpu_baremetal_clusters/interfaces.py b/src/gcore/resources/cloud/gpu_baremetal/clusters/interfaces.py similarity index 98% rename from src/gcore/resources/cloud/gpu_baremetal_clusters/interfaces.py rename to src/gcore/resources/cloud/gpu_baremetal/clusters/interfaces.py index f7c10022..0b4d0768 100644 --- a/src/gcore/resources/cloud/gpu_baremetal_clusters/interfaces.py +++ b/src/gcore/resources/cloud/gpu_baremetal/clusters/interfaces.py @@ -7,20 +7,20 @@ import httpx -from ...._types import Body, Omit, Query, Headers, NotGiven, omit, not_given -from ...._utils import maybe_transform, async_maybe_transform -from ...._compat import cached_property -from ...._resource import SyncAPIResource, AsyncAPIResource -from ...._response import ( +from ....._types import Body, Omit, Query, Headers, NotGiven, omit, not_given +from ....._utils import maybe_transform, async_maybe_transform +from ....._compat import cached_property +from ....._resource import SyncAPIResource, AsyncAPIResource +from ....._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from ...._base_client import make_request_options -from ....types.cloud.task_id_list import TaskIDList -from ....types.cloud.gpu_baremetal_clusters import interface_attach_params, interface_detach_params -from ....types.cloud.network_interface_list import NetworkInterfaceList +from ....._base_client import make_request_options +from .....types.cloud.task_id_list import TaskIDList +from .....types.cloud.gpu_baremetal.clusters import interface_attach_params, interface_detach_params +from .....types.cloud.network_interface_list import NetworkInterfaceList __all__ = ["InterfacesResource", "AsyncInterfacesResource"] diff --git a/src/gcore/resources/cloud/gpu_baremetal_clusters/servers.py b/src/gcore/resources/cloud/gpu_baremetal/clusters/servers.py similarity index 97% rename from src/gcore/resources/cloud/gpu_baremetal_clusters/servers.py rename to src/gcore/resources/cloud/gpu_baremetal/clusters/servers.py index 044c15a6..c4d6ad91 100644 --- a/src/gcore/resources/cloud/gpu_baremetal_clusters/servers.py +++ b/src/gcore/resources/cloud/gpu_baremetal/clusters/servers.py @@ -8,23 +8,23 @@ import httpx -from ...._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given -from ...._utils import maybe_transform, async_maybe_transform -from ...._compat import cached_property -from ...._resource import SyncAPIResource, AsyncAPIResource -from ...._response import ( +from ....._types import Body, Omit, Query, Headers, NotGiven, SequenceNotStr, omit, not_given +from ....._utils import maybe_transform, async_maybe_transform +from ....._compat import cached_property +from ....._resource import SyncAPIResource, AsyncAPIResource +from ....._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from ....pagination import SyncOffsetPage, AsyncOffsetPage -from ...._base_client import AsyncPaginator, make_request_options -from ....types.cloud.console import Console -from ....types.cloud.task_id_list import TaskIDList -from ....types.cloud.gpu_baremetal_clusters import server_list_params, server_delete_params -from ....types.cloud.gpu_baremetal_clusters.gpu_baremetal_cluster_server import GPUBaremetalClusterServer -from ....types.cloud.gpu_baremetal_clusters.gpu_baremetal_cluster_server_v1 import GPUBaremetalClusterServerV1 +from .....pagination import SyncOffsetPage, AsyncOffsetPage +from ....._base_client import AsyncPaginator, make_request_options +from .....types.cloud.console import Console +from .....types.cloud.task_id_list import TaskIDList +from .....types.cloud.gpu_baremetal.clusters import server_list_params, server_delete_params +from .....types.cloud.gpu_baremetal.clusters.gpu_baremetal_cluster_server import GPUBaremetalClusterServer +from .....types.cloud.gpu_baremetal.clusters.gpu_baremetal_cluster_server_v1 import GPUBaremetalClusterServerV1 __all__ = ["ServersResource", "AsyncServersResource"] diff --git a/src/gcore/resources/cloud/gpu_baremetal/gpu_baremetal.py b/src/gcore/resources/cloud/gpu_baremetal/gpu_baremetal.py new file mode 100644 index 00000000..b752dffd --- /dev/null +++ b/src/gcore/resources/cloud/gpu_baremetal/gpu_baremetal.py @@ -0,0 +1,102 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from ...._compat import cached_property +from ...._resource import SyncAPIResource, AsyncAPIResource +from .clusters.clusters import ( + ClustersResource, + AsyncClustersResource, + ClustersResourceWithRawResponse, + AsyncClustersResourceWithRawResponse, + ClustersResourceWithStreamingResponse, + AsyncClustersResourceWithStreamingResponse, +) + +__all__ = ["GPUBaremetalResource", "AsyncGPUBaremetalResource"] + + +class GPUBaremetalResource(SyncAPIResource): + @cached_property + def clusters(self) -> ClustersResource: + return ClustersResource(self._client) + + @cached_property + def with_raw_response(self) -> GPUBaremetalResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/G-Core/gcore-python#accessing-raw-response-data-eg-headers + """ + return GPUBaremetalResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> GPUBaremetalResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/G-Core/gcore-python#with_streaming_response + """ + return GPUBaremetalResourceWithStreamingResponse(self) + + +class AsyncGPUBaremetalResource(AsyncAPIResource): + @cached_property + def clusters(self) -> AsyncClustersResource: + return AsyncClustersResource(self._client) + + @cached_property + def with_raw_response(self) -> AsyncGPUBaremetalResourceWithRawResponse: + """ + This property can be used as a prefix for any HTTP method call to return + the raw response object instead of the parsed content. + + For more information, see https://www.github.com/G-Core/gcore-python#accessing-raw-response-data-eg-headers + """ + return AsyncGPUBaremetalResourceWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncGPUBaremetalResourceWithStreamingResponse: + """ + An alternative to `.with_raw_response` that doesn't eagerly read the response body. + + For more information, see https://www.github.com/G-Core/gcore-python#with_streaming_response + """ + return AsyncGPUBaremetalResourceWithStreamingResponse(self) + + +class GPUBaremetalResourceWithRawResponse: + def __init__(self, gpu_baremetal: GPUBaremetalResource) -> None: + self._gpu_baremetal = gpu_baremetal + + @cached_property + def clusters(self) -> ClustersResourceWithRawResponse: + return ClustersResourceWithRawResponse(self._gpu_baremetal.clusters) + + +class AsyncGPUBaremetalResourceWithRawResponse: + def __init__(self, gpu_baremetal: AsyncGPUBaremetalResource) -> None: + self._gpu_baremetal = gpu_baremetal + + @cached_property + def clusters(self) -> AsyncClustersResourceWithRawResponse: + return AsyncClustersResourceWithRawResponse(self._gpu_baremetal.clusters) + + +class GPUBaremetalResourceWithStreamingResponse: + def __init__(self, gpu_baremetal: GPUBaremetalResource) -> None: + self._gpu_baremetal = gpu_baremetal + + @cached_property + def clusters(self) -> ClustersResourceWithStreamingResponse: + return ClustersResourceWithStreamingResponse(self._gpu_baremetal.clusters) + + +class AsyncGPUBaremetalResourceWithStreamingResponse: + def __init__(self, gpu_baremetal: AsyncGPUBaremetalResource) -> None: + self._gpu_baremetal = gpu_baremetal + + @cached_property + def clusters(self) -> AsyncClustersResourceWithStreamingResponse: + return AsyncClustersResourceWithStreamingResponse(self._gpu_baremetal.clusters) diff --git a/src/gcore/types/cloud/__init__.py b/src/gcore/types/cloud/__init__.py index 0503e14b..bac65886 100644 --- a/src/gcore/types/cloud/__init__.py +++ b/src/gcore/types/cloud/__init__.py @@ -88,7 +88,6 @@ from .audit_log_list_params import AuditLogListParams as AuditLogListParams from .baremetal_flavor_list import BaremetalFlavorList as BaremetalFlavorList from .ddos_profile_template import DDOSProfileTemplate as DDOSProfileTemplate -from .gpu_baremetal_cluster import GPUBaremetalCluster as GPUBaremetalCluster from .health_monitor_status import HealthMonitorStatus as HealthMonitorStatus from .load_balancer_l7_rule import LoadBalancerL7Rule as LoadBalancerL7Rule from .load_balancer_metrics import LoadBalancerMetrics as LoadBalancerMetrics @@ -164,15 +163,9 @@ from .reserved_fixed_ip_update_params import ReservedFixedIPUpdateParams as ReservedFixedIPUpdateParams from .volume_attach_to_instance_params import VolumeAttachToInstanceParams as VolumeAttachToInstanceParams from .cost_report_get_aggregated_params import CostReportGetAggregatedParams as CostReportGetAggregatedParams -from .gpu_baremetal_cluster_list_params import GPUBaremetalClusterListParams as GPUBaremetalClusterListParams from .laas_index_retention_policy_param import LaasIndexRetentionPolicyParam as LaasIndexRetentionPolicyParam from .load_balancer_member_connectivity import LoadBalancerMemberConnectivity as LoadBalancerMemberConnectivity from .volume_detach_from_instance_params import VolumeDetachFromInstanceParams as VolumeDetachFromInstanceParams -from .gpu_baremetal_cluster_action_params import GPUBaremetalClusterActionParams as GPUBaremetalClusterActionParams -from .gpu_baremetal_cluster_create_params import GPUBaremetalClusterCreateParams as GPUBaremetalClusterCreateParams -from .gpu_baremetal_cluster_delete_params import GPUBaremetalClusterDeleteParams as GPUBaremetalClusterDeleteParams -from .gpu_baremetal_cluster_resize_params import GPUBaremetalClusterResizeParams as GPUBaremetalClusterResizeParams -from .gpu_baremetal_cluster_rebuild_params import GPUBaremetalClusterRebuildParams as GPUBaremetalClusterRebuildParams from .secret_upload_tls_certificate_params import SecretUploadTlsCertificateParams as SecretUploadTlsCertificateParams from .instance_assign_security_group_params import ( InstanceAssignSecurityGroupParams as InstanceAssignSecurityGroupParams, diff --git a/src/gcore/types/cloud/gpu_baremetal/__init__.py b/src/gcore/types/cloud/gpu_baremetal/__init__.py new file mode 100644 index 00000000..baff756f --- /dev/null +++ b/src/gcore/types/cloud/gpu_baremetal/__init__.py @@ -0,0 +1,11 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. + +from __future__ import annotations + +from .cluster_list_params import ClusterListParams as ClusterListParams +from .cluster_action_params import ClusterActionParams as ClusterActionParams +from .cluster_create_params import ClusterCreateParams as ClusterCreateParams +from .cluster_delete_params import ClusterDeleteParams as ClusterDeleteParams +from .cluster_resize_params import ClusterResizeParams as ClusterResizeParams +from .gpu_baremetal_cluster import GPUBaremetalCluster as GPUBaremetalCluster +from .cluster_rebuild_params import ClusterRebuildParams as ClusterRebuildParams diff --git a/src/gcore/types/cloud/gpu_baremetal_cluster_action_params.py b/src/gcore/types/cloud/gpu_baremetal/cluster_action_params.py similarity index 90% rename from src/gcore/types/cloud/gpu_baremetal_cluster_action_params.py rename to src/gcore/types/cloud/gpu_baremetal/cluster_action_params.py index 506d3619..95167930 100644 --- a/src/gcore/types/cloud/gpu_baremetal_cluster_action_params.py +++ b/src/gcore/types/cloud/gpu_baremetal/cluster_action_params.py @@ -5,12 +5,12 @@ from typing import Optional from typing_extensions import Literal, Required, TypedDict -from .tag_update_map_param import TagUpdateMapParam +from ..tag_update_map_param import TagUpdateMapParam -__all__ = ["GPUBaremetalClusterActionParams"] +__all__ = ["ClusterActionParams"] -class GPUBaremetalClusterActionParams(TypedDict, total=False): +class ClusterActionParams(TypedDict, total=False): project_id: int """Project ID""" diff --git a/src/gcore/types/cloud/gpu_baremetal_cluster_create_params.py b/src/gcore/types/cloud/gpu_baremetal/cluster_create_params.py similarity index 98% rename from src/gcore/types/cloud/gpu_baremetal_cluster_create_params.py rename to src/gcore/types/cloud/gpu_baremetal/cluster_create_params.py index 4bc1ea85..7e407d87 100644 --- a/src/gcore/types/cloud/gpu_baremetal_cluster_create_params.py +++ b/src/gcore/types/cloud/gpu_baremetal/cluster_create_params.py @@ -6,7 +6,7 @@ from typing_extensions import Literal, Required, TypeAlias, TypedDict __all__ = [ - "GPUBaremetalClusterCreateParams", + "ClusterCreateParams", "ServersSettings", "ServersSettingsInterface", "ServersSettingsInterfaceExternalInterfaceInputSerializer", @@ -20,7 +20,7 @@ ] -class GPUBaremetalClusterCreateParams(TypedDict, total=False): +class ClusterCreateParams(TypedDict, total=False): project_id: int """Project ID""" diff --git a/src/gcore/types/cloud/gpu_baremetal_cluster_delete_params.py b/src/gcore/types/cloud/gpu_baremetal/cluster_delete_params.py similarity index 83% rename from src/gcore/types/cloud/gpu_baremetal_cluster_delete_params.py rename to src/gcore/types/cloud/gpu_baremetal/cluster_delete_params.py index dc737d14..97104a24 100644 --- a/src/gcore/types/cloud/gpu_baremetal_cluster_delete_params.py +++ b/src/gcore/types/cloud/gpu_baremetal/cluster_delete_params.py @@ -4,12 +4,12 @@ from typing_extensions import TypedDict -from ..._types import SequenceNotStr +from ...._types import SequenceNotStr -__all__ = ["GPUBaremetalClusterDeleteParams"] +__all__ = ["ClusterDeleteParams"] -class GPUBaremetalClusterDeleteParams(TypedDict, total=False): +class ClusterDeleteParams(TypedDict, total=False): project_id: int """Project ID""" diff --git a/src/gcore/types/cloud/gpu_baremetal_cluster_list_params.py b/src/gcore/types/cloud/gpu_baremetal/cluster_list_params.py similarity index 86% rename from src/gcore/types/cloud/gpu_baremetal_cluster_list_params.py rename to src/gcore/types/cloud/gpu_baremetal/cluster_list_params.py index 8112f690..c96a3a7e 100644 --- a/src/gcore/types/cloud/gpu_baremetal_cluster_list_params.py +++ b/src/gcore/types/cloud/gpu_baremetal/cluster_list_params.py @@ -5,10 +5,10 @@ from typing import List from typing_extensions import Literal, TypedDict -__all__ = ["GPUBaremetalClusterListParams"] +__all__ = ["ClusterListParams"] -class GPUBaremetalClusterListParams(TypedDict, total=False): +class ClusterListParams(TypedDict, total=False): project_id: int """Project ID""" diff --git a/src/gcore/types/cloud/gpu_baremetal_cluster_rebuild_params.py b/src/gcore/types/cloud/gpu_baremetal/cluster_rebuild_params.py similarity index 79% rename from src/gcore/types/cloud/gpu_baremetal_cluster_rebuild_params.py rename to src/gcore/types/cloud/gpu_baremetal/cluster_rebuild_params.py index f4d27f43..f9fe6f9d 100644 --- a/src/gcore/types/cloud/gpu_baremetal_cluster_rebuild_params.py +++ b/src/gcore/types/cloud/gpu_baremetal/cluster_rebuild_params.py @@ -5,12 +5,12 @@ from typing import Optional from typing_extensions import Required, TypedDict -from ..._types import SequenceNotStr +from ...._types import SequenceNotStr -__all__ = ["GPUBaremetalClusterRebuildParams"] +__all__ = ["ClusterRebuildParams"] -class GPUBaremetalClusterRebuildParams(TypedDict, total=False): +class ClusterRebuildParams(TypedDict, total=False): project_id: int region_id: int diff --git a/src/gcore/types/cloud/gpu_baremetal_cluster_resize_params.py b/src/gcore/types/cloud/gpu_baremetal/cluster_resize_params.py similarity index 73% rename from src/gcore/types/cloud/gpu_baremetal_cluster_resize_params.py rename to src/gcore/types/cloud/gpu_baremetal/cluster_resize_params.py index 9f8b0391..cb9f2211 100644 --- a/src/gcore/types/cloud/gpu_baremetal_cluster_resize_params.py +++ b/src/gcore/types/cloud/gpu_baremetal/cluster_resize_params.py @@ -4,10 +4,10 @@ from typing_extensions import Required, TypedDict -__all__ = ["GPUBaremetalClusterResizeParams"] +__all__ = ["ClusterResizeParams"] -class GPUBaremetalClusterResizeParams(TypedDict, total=False): +class ClusterResizeParams(TypedDict, total=False): project_id: int region_id: int diff --git a/src/gcore/types/cloud/gpu_baremetal_clusters/__init__.py b/src/gcore/types/cloud/gpu_baremetal/clusters/__init__.py similarity index 100% rename from src/gcore/types/cloud/gpu_baremetal_clusters/__init__.py rename to src/gcore/types/cloud/gpu_baremetal/clusters/__init__.py diff --git a/src/gcore/types/cloud/gpu_baremetal_clusters/flavor_list_params.py b/src/gcore/types/cloud/gpu_baremetal/clusters/flavor_list_params.py similarity index 100% rename from src/gcore/types/cloud/gpu_baremetal_clusters/flavor_list_params.py rename to src/gcore/types/cloud/gpu_baremetal/clusters/flavor_list_params.py diff --git a/src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_cluster_server.py b/src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_cluster_server.py similarity index 96% rename from src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_cluster_server.py rename to src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_cluster_server.py index d2e11700..ff1e581f 100644 --- a/src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_cluster_server.py +++ b/src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_cluster_server.py @@ -4,8 +4,8 @@ from datetime import datetime from typing_extensions import Literal -from ..tag import Tag -from ...._models import BaseModel +from ...tag import Tag +from ....._models import BaseModel __all__ = ["GPUBaremetalClusterServer", "SecurityGroup"] diff --git a/src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_cluster_server_v1.py b/src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_cluster_server_v1.py similarity index 93% rename from src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_cluster_server_v1.py rename to src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_cluster_server_v1.py index 171a164a..9e44be1e 100644 --- a/src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_cluster_server_v1.py +++ b/src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_cluster_server_v1.py @@ -4,14 +4,14 @@ from datetime import datetime from typing_extensions import Literal, TypeAlias -from ..tag import Tag -from ...._models import BaseModel -from ..ddos_profile import DDOSProfile -from ..fixed_address import FixedAddress -from ..blackhole_port import BlackholePort -from ..floating_address import FloatingAddress -from ..instance_isolation import InstanceIsolation -from ..fixed_address_short import FixedAddressShort +from ...tag import Tag +from ....._models import BaseModel +from ...ddos_profile import DDOSProfile +from ...fixed_address import FixedAddress +from ...blackhole_port import BlackholePort +from ...floating_address import FloatingAddress +from ...instance_isolation import InstanceIsolation +from ...fixed_address_short import FixedAddressShort __all__ = [ "GPUBaremetalClusterServerV1", diff --git a/src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_cluster_server_v1_list.py b/src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_cluster_server_v1_list.py similarity index 91% rename from src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_cluster_server_v1_list.py rename to src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_cluster_server_v1_list.py index a6c6a2f2..b3599d3a 100644 --- a/src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_cluster_server_v1_list.py +++ b/src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_cluster_server_v1_list.py @@ -2,7 +2,7 @@ from typing import List -from ...._models import BaseModel +from ....._models import BaseModel from .gpu_baremetal_cluster_server_v1 import GPUBaremetalClusterServerV1 __all__ = ["GPUBaremetalClusterServerV1List"] diff --git a/src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_flavor.py b/src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_flavor.py similarity index 99% rename from src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_flavor.py rename to src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_flavor.py index bca6570c..be48dcf7 100644 --- a/src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_flavor.py +++ b/src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_flavor.py @@ -3,7 +3,7 @@ from typing import Union, Optional from typing_extensions import Literal, TypeAlias -from ...._models import BaseModel +from ....._models import BaseModel __all__ = [ "GPUBaremetalFlavor", diff --git a/src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_flavor_list.py b/src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_flavor_list.py similarity index 90% rename from src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_flavor_list.py rename to src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_flavor_list.py index 2cc4ee84..785daffd 100644 --- a/src/gcore/types/cloud/gpu_baremetal_clusters/gpu_baremetal_flavor_list.py +++ b/src/gcore/types/cloud/gpu_baremetal/clusters/gpu_baremetal_flavor_list.py @@ -2,7 +2,7 @@ from typing import List -from ...._models import BaseModel +from ....._models import BaseModel from .gpu_baremetal_flavor import GPUBaremetalFlavor __all__ = ["GPUBaremetalFlavorList"] diff --git a/src/gcore/types/cloud/gpu_baremetal_clusters/image_upload_params.py b/src/gcore/types/cloud/gpu_baremetal/clusters/image_upload_params.py similarity index 100% rename from src/gcore/types/cloud/gpu_baremetal_clusters/image_upload_params.py rename to src/gcore/types/cloud/gpu_baremetal/clusters/image_upload_params.py diff --git a/src/gcore/types/cloud/gpu_baremetal_clusters/interface_attach_params.py b/src/gcore/types/cloud/gpu_baremetal/clusters/interface_attach_params.py similarity index 100% rename from src/gcore/types/cloud/gpu_baremetal_clusters/interface_attach_params.py rename to src/gcore/types/cloud/gpu_baremetal/clusters/interface_attach_params.py diff --git a/src/gcore/types/cloud/gpu_baremetal_clusters/interface_detach_params.py b/src/gcore/types/cloud/gpu_baremetal/clusters/interface_detach_params.py similarity index 100% rename from src/gcore/types/cloud/gpu_baremetal_clusters/interface_detach_params.py rename to src/gcore/types/cloud/gpu_baremetal/clusters/interface_detach_params.py diff --git a/src/gcore/types/cloud/gpu_baremetal_clusters/server_delete_params.py b/src/gcore/types/cloud/gpu_baremetal/clusters/server_delete_params.py similarity index 100% rename from src/gcore/types/cloud/gpu_baremetal_clusters/server_delete_params.py rename to src/gcore/types/cloud/gpu_baremetal/clusters/server_delete_params.py diff --git a/src/gcore/types/cloud/gpu_baremetal_clusters/server_list_params.py b/src/gcore/types/cloud/gpu_baremetal/clusters/server_list_params.py similarity index 96% rename from src/gcore/types/cloud/gpu_baremetal_clusters/server_list_params.py rename to src/gcore/types/cloud/gpu_baremetal/clusters/server_list_params.py index 35c7f374..89f4cb6d 100644 --- a/src/gcore/types/cloud/gpu_baremetal_clusters/server_list_params.py +++ b/src/gcore/types/cloud/gpu_baremetal/clusters/server_list_params.py @@ -6,8 +6,8 @@ from datetime import datetime from typing_extensions import Literal, Annotated, TypedDict -from ...._types import SequenceNotStr -from ...._utils import PropertyInfo +from ....._types import SequenceNotStr +from ....._utils import PropertyInfo __all__ = ["ServerListParams"] diff --git a/src/gcore/types/cloud/gpu_baremetal_cluster.py b/src/gcore/types/cloud/gpu_baremetal/gpu_baremetal_cluster.py similarity index 98% rename from src/gcore/types/cloud/gpu_baremetal_cluster.py rename to src/gcore/types/cloud/gpu_baremetal/gpu_baremetal_cluster.py index bfbdff15..17cfcf4e 100644 --- a/src/gcore/types/cloud/gpu_baremetal_cluster.py +++ b/src/gcore/types/cloud/gpu_baremetal/gpu_baremetal_cluster.py @@ -4,9 +4,9 @@ from datetime import datetime from typing_extensions import Literal, Annotated, TypeAlias -from .tag import Tag -from ..._utils import PropertyInfo -from ..._models import BaseModel +from ..tag import Tag +from ...._utils import PropertyInfo +from ...._models import BaseModel __all__ = [ "GPUBaremetalCluster", diff --git a/tests/api_resources/cloud/gpu_baremetal_clusters/__init__.py b/tests/api_resources/cloud/gpu_baremetal/__init__.py similarity index 100% rename from tests/api_resources/cloud/gpu_baremetal_clusters/__init__.py rename to tests/api_resources/cloud/gpu_baremetal/__init__.py diff --git a/tests/api_resources/cloud/gpu_baremetal/clusters/__init__.py b/tests/api_resources/cloud/gpu_baremetal/clusters/__init__.py new file mode 100644 index 00000000..fd8019a9 --- /dev/null +++ b/tests/api_resources/cloud/gpu_baremetal/clusters/__init__.py @@ -0,0 +1 @@ +# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/cloud/gpu_baremetal_clusters/test_flavors.py b/tests/api_resources/cloud/gpu_baremetal/clusters/test_flavors.py similarity index 86% rename from tests/api_resources/cloud/gpu_baremetal_clusters/test_flavors.py rename to tests/api_resources/cloud/gpu_baremetal/clusters/test_flavors.py index 9cb9018c..b19b4b99 100644 --- a/tests/api_resources/cloud/gpu_baremetal_clusters/test_flavors.py +++ b/tests/api_resources/cloud/gpu_baremetal/clusters/test_flavors.py @@ -9,7 +9,7 @@ from gcore import Gcore, AsyncGcore from tests.utils import assert_matches_type -from gcore.types.cloud.gpu_baremetal_clusters import GPUBaremetalFlavorList +from gcore.types.cloud.gpu_baremetal.clusters import GPUBaremetalFlavorList base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -19,7 +19,7 @@ class TestFlavors: @parametrize def test_method_list(self, client: Gcore) -> None: - flavor = client.cloud.gpu_baremetal_clusters.flavors.list( + flavor = client.cloud.gpu_baremetal.clusters.flavors.list( project_id=1, region_id=7, ) @@ -27,7 +27,7 @@ def test_method_list(self, client: Gcore) -> None: @parametrize def test_method_list_with_all_params(self, client: Gcore) -> None: - flavor = client.cloud.gpu_baremetal_clusters.flavors.list( + flavor = client.cloud.gpu_baremetal.clusters.flavors.list( project_id=1, region_id=7, hide_disabled=True, @@ -37,7 +37,7 @@ def test_method_list_with_all_params(self, client: Gcore) -> None: @parametrize def test_raw_response_list(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.flavors.with_raw_response.list( + response = client.cloud.gpu_baremetal.clusters.flavors.with_raw_response.list( project_id=1, region_id=7, ) @@ -49,7 +49,7 @@ def test_raw_response_list(self, client: Gcore) -> None: @parametrize def test_streaming_response_list(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.flavors.with_streaming_response.list( + with client.cloud.gpu_baremetal.clusters.flavors.with_streaming_response.list( project_id=1, region_id=7, ) as response: @@ -69,7 +69,7 @@ class TestAsyncFlavors: @parametrize async def test_method_list(self, async_client: AsyncGcore) -> None: - flavor = await async_client.cloud.gpu_baremetal_clusters.flavors.list( + flavor = await async_client.cloud.gpu_baremetal.clusters.flavors.list( project_id=1, region_id=7, ) @@ -77,7 +77,7 @@ async def test_method_list(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_list_with_all_params(self, async_client: AsyncGcore) -> None: - flavor = await async_client.cloud.gpu_baremetal_clusters.flavors.list( + flavor = await async_client.cloud.gpu_baremetal.clusters.flavors.list( project_id=1, region_id=7, hide_disabled=True, @@ -87,7 +87,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncGcore) -> No @parametrize async def test_raw_response_list(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.flavors.with_raw_response.list( + response = await async_client.cloud.gpu_baremetal.clusters.flavors.with_raw_response.list( project_id=1, region_id=7, ) @@ -99,7 +99,7 @@ async def test_raw_response_list(self, async_client: AsyncGcore) -> None: @parametrize async def test_streaming_response_list(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.flavors.with_streaming_response.list( + async with async_client.cloud.gpu_baremetal.clusters.flavors.with_streaming_response.list( project_id=1, region_id=7, ) as response: diff --git a/tests/api_resources/cloud/gpu_baremetal_clusters/test_images.py b/tests/api_resources/cloud/gpu_baremetal/clusters/test_images.py similarity index 87% rename from tests/api_resources/cloud/gpu_baremetal_clusters/test_images.py rename to tests/api_resources/cloud/gpu_baremetal/clusters/test_images.py index e9f6c63f..3657deea 100644 --- a/tests/api_resources/cloud/gpu_baremetal_clusters/test_images.py +++ b/tests/api_resources/cloud/gpu_baremetal/clusters/test_images.py @@ -19,7 +19,7 @@ class TestImages: @parametrize def test_method_list(self, client: Gcore) -> None: - image = client.cloud.gpu_baremetal_clusters.images.list( + image = client.cloud.gpu_baremetal.clusters.images.list( project_id=1, region_id=7, ) @@ -27,7 +27,7 @@ def test_method_list(self, client: Gcore) -> None: @parametrize def test_raw_response_list(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.images.with_raw_response.list( + response = client.cloud.gpu_baremetal.clusters.images.with_raw_response.list( project_id=1, region_id=7, ) @@ -39,7 +39,7 @@ def test_raw_response_list(self, client: Gcore) -> None: @parametrize def test_streaming_response_list(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.images.with_streaming_response.list( + with client.cloud.gpu_baremetal.clusters.images.with_streaming_response.list( project_id=1, region_id=7, ) as response: @@ -53,7 +53,7 @@ def test_streaming_response_list(self, client: Gcore) -> None: @parametrize def test_method_delete(self, client: Gcore) -> None: - image = client.cloud.gpu_baremetal_clusters.images.delete( + image = client.cloud.gpu_baremetal.clusters.images.delete( image_id="8cab6f28-09ca-4201-b3f7-23c7893f4bd6", project_id=1, region_id=7, @@ -62,7 +62,7 @@ def test_method_delete(self, client: Gcore) -> None: @parametrize def test_raw_response_delete(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.images.with_raw_response.delete( + response = client.cloud.gpu_baremetal.clusters.images.with_raw_response.delete( image_id="8cab6f28-09ca-4201-b3f7-23c7893f4bd6", project_id=1, region_id=7, @@ -75,7 +75,7 @@ def test_raw_response_delete(self, client: Gcore) -> None: @parametrize def test_streaming_response_delete(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.images.with_streaming_response.delete( + with client.cloud.gpu_baremetal.clusters.images.with_streaming_response.delete( image_id="8cab6f28-09ca-4201-b3f7-23c7893f4bd6", project_id=1, region_id=7, @@ -91,7 +91,7 @@ def test_streaming_response_delete(self, client: Gcore) -> None: @parametrize def test_path_params_delete(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `image_id` but received ''"): - client.cloud.gpu_baremetal_clusters.images.with_raw_response.delete( + client.cloud.gpu_baremetal.clusters.images.with_raw_response.delete( image_id="", project_id=1, region_id=7, @@ -99,7 +99,7 @@ def test_path_params_delete(self, client: Gcore) -> None: @parametrize def test_method_get(self, client: Gcore) -> None: - image = client.cloud.gpu_baremetal_clusters.images.get( + image = client.cloud.gpu_baremetal.clusters.images.get( image_id="8cab6f28-09ca-4201-b3f7-23c7893f4bd6", project_id=1, region_id=7, @@ -108,7 +108,7 @@ def test_method_get(self, client: Gcore) -> None: @parametrize def test_raw_response_get(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.images.with_raw_response.get( + response = client.cloud.gpu_baremetal.clusters.images.with_raw_response.get( image_id="8cab6f28-09ca-4201-b3f7-23c7893f4bd6", project_id=1, region_id=7, @@ -121,7 +121,7 @@ def test_raw_response_get(self, client: Gcore) -> None: @parametrize def test_streaming_response_get(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.images.with_streaming_response.get( + with client.cloud.gpu_baremetal.clusters.images.with_streaming_response.get( image_id="8cab6f28-09ca-4201-b3f7-23c7893f4bd6", project_id=1, region_id=7, @@ -137,7 +137,7 @@ def test_streaming_response_get(self, client: Gcore) -> None: @parametrize def test_path_params_get(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `image_id` but received ''"): - client.cloud.gpu_baremetal_clusters.images.with_raw_response.get( + client.cloud.gpu_baremetal.clusters.images.with_raw_response.get( image_id="", project_id=1, region_id=7, @@ -145,7 +145,7 @@ def test_path_params_get(self, client: Gcore) -> None: @parametrize def test_method_upload(self, client: Gcore) -> None: - image = client.cloud.gpu_baremetal_clusters.images.upload( + image = client.cloud.gpu_baremetal.clusters.images.upload( project_id=1, region_id=7, name="ubuntu-23.10-x64", @@ -155,7 +155,7 @@ def test_method_upload(self, client: Gcore) -> None: @parametrize def test_method_upload_with_all_params(self, client: Gcore) -> None: - image = client.cloud.gpu_baremetal_clusters.images.upload( + image = client.cloud.gpu_baremetal.clusters.images.upload( project_id=1, region_id=7, name="ubuntu-23.10-x64", @@ -173,7 +173,7 @@ def test_method_upload_with_all_params(self, client: Gcore) -> None: @parametrize def test_raw_response_upload(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.images.with_raw_response.upload( + response = client.cloud.gpu_baremetal.clusters.images.with_raw_response.upload( project_id=1, region_id=7, name="ubuntu-23.10-x64", @@ -187,7 +187,7 @@ def test_raw_response_upload(self, client: Gcore) -> None: @parametrize def test_streaming_response_upload(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.images.with_streaming_response.upload( + with client.cloud.gpu_baremetal.clusters.images.with_streaming_response.upload( project_id=1, region_id=7, name="ubuntu-23.10-x64", @@ -209,7 +209,7 @@ class TestAsyncImages: @parametrize async def test_method_list(self, async_client: AsyncGcore) -> None: - image = await async_client.cloud.gpu_baremetal_clusters.images.list( + image = await async_client.cloud.gpu_baremetal.clusters.images.list( project_id=1, region_id=7, ) @@ -217,7 +217,7 @@ async def test_method_list(self, async_client: AsyncGcore) -> None: @parametrize async def test_raw_response_list(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.images.with_raw_response.list( + response = await async_client.cloud.gpu_baremetal.clusters.images.with_raw_response.list( project_id=1, region_id=7, ) @@ -229,7 +229,7 @@ async def test_raw_response_list(self, async_client: AsyncGcore) -> None: @parametrize async def test_streaming_response_list(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.images.with_streaming_response.list( + async with async_client.cloud.gpu_baremetal.clusters.images.with_streaming_response.list( project_id=1, region_id=7, ) as response: @@ -243,7 +243,7 @@ async def test_streaming_response_list(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_delete(self, async_client: AsyncGcore) -> None: - image = await async_client.cloud.gpu_baremetal_clusters.images.delete( + image = await async_client.cloud.gpu_baremetal.clusters.images.delete( image_id="8cab6f28-09ca-4201-b3f7-23c7893f4bd6", project_id=1, region_id=7, @@ -252,7 +252,7 @@ async def test_method_delete(self, async_client: AsyncGcore) -> None: @parametrize async def test_raw_response_delete(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.images.with_raw_response.delete( + response = await async_client.cloud.gpu_baremetal.clusters.images.with_raw_response.delete( image_id="8cab6f28-09ca-4201-b3f7-23c7893f4bd6", project_id=1, region_id=7, @@ -265,7 +265,7 @@ async def test_raw_response_delete(self, async_client: AsyncGcore) -> None: @parametrize async def test_streaming_response_delete(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.images.with_streaming_response.delete( + async with async_client.cloud.gpu_baremetal.clusters.images.with_streaming_response.delete( image_id="8cab6f28-09ca-4201-b3f7-23c7893f4bd6", project_id=1, region_id=7, @@ -281,7 +281,7 @@ async def test_streaming_response_delete(self, async_client: AsyncGcore) -> None @parametrize async def test_path_params_delete(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `image_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.images.with_raw_response.delete( + await async_client.cloud.gpu_baremetal.clusters.images.with_raw_response.delete( image_id="", project_id=1, region_id=7, @@ -289,7 +289,7 @@ async def test_path_params_delete(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_get(self, async_client: AsyncGcore) -> None: - image = await async_client.cloud.gpu_baremetal_clusters.images.get( + image = await async_client.cloud.gpu_baremetal.clusters.images.get( image_id="8cab6f28-09ca-4201-b3f7-23c7893f4bd6", project_id=1, region_id=7, @@ -298,7 +298,7 @@ async def test_method_get(self, async_client: AsyncGcore) -> None: @parametrize async def test_raw_response_get(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.images.with_raw_response.get( + response = await async_client.cloud.gpu_baremetal.clusters.images.with_raw_response.get( image_id="8cab6f28-09ca-4201-b3f7-23c7893f4bd6", project_id=1, region_id=7, @@ -311,7 +311,7 @@ async def test_raw_response_get(self, async_client: AsyncGcore) -> None: @parametrize async def test_streaming_response_get(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.images.with_streaming_response.get( + async with async_client.cloud.gpu_baremetal.clusters.images.with_streaming_response.get( image_id="8cab6f28-09ca-4201-b3f7-23c7893f4bd6", project_id=1, region_id=7, @@ -327,7 +327,7 @@ async def test_streaming_response_get(self, async_client: AsyncGcore) -> None: @parametrize async def test_path_params_get(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `image_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.images.with_raw_response.get( + await async_client.cloud.gpu_baremetal.clusters.images.with_raw_response.get( image_id="", project_id=1, region_id=7, @@ -335,7 +335,7 @@ async def test_path_params_get(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_upload(self, async_client: AsyncGcore) -> None: - image = await async_client.cloud.gpu_baremetal_clusters.images.upload( + image = await async_client.cloud.gpu_baremetal.clusters.images.upload( project_id=1, region_id=7, name="ubuntu-23.10-x64", @@ -345,7 +345,7 @@ async def test_method_upload(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_upload_with_all_params(self, async_client: AsyncGcore) -> None: - image = await async_client.cloud.gpu_baremetal_clusters.images.upload( + image = await async_client.cloud.gpu_baremetal.clusters.images.upload( project_id=1, region_id=7, name="ubuntu-23.10-x64", @@ -363,7 +363,7 @@ async def test_method_upload_with_all_params(self, async_client: AsyncGcore) -> @parametrize async def test_raw_response_upload(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.images.with_raw_response.upload( + response = await async_client.cloud.gpu_baremetal.clusters.images.with_raw_response.upload( project_id=1, region_id=7, name="ubuntu-23.10-x64", @@ -377,7 +377,7 @@ async def test_raw_response_upload(self, async_client: AsyncGcore) -> None: @parametrize async def test_streaming_response_upload(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.images.with_streaming_response.upload( + async with async_client.cloud.gpu_baremetal.clusters.images.with_streaming_response.upload( project_id=1, region_id=7, name="ubuntu-23.10-x64", diff --git a/tests/api_resources/cloud/gpu_baremetal_clusters/test_interfaces.py b/tests/api_resources/cloud/gpu_baremetal/clusters/test_interfaces.py similarity index 89% rename from tests/api_resources/cloud/gpu_baremetal_clusters/test_interfaces.py rename to tests/api_resources/cloud/gpu_baremetal/clusters/test_interfaces.py index 0afb78c8..de330f4d 100644 --- a/tests/api_resources/cloud/gpu_baremetal_clusters/test_interfaces.py +++ b/tests/api_resources/cloud/gpu_baremetal/clusters/test_interfaces.py @@ -19,7 +19,7 @@ class TestInterfaces: @parametrize def test_method_list(self, client: Gcore) -> None: - interface = client.cloud.gpu_baremetal_clusters.interfaces.list( + interface = client.cloud.gpu_baremetal.clusters.interfaces.list( cluster_id="cluster_id", project_id=0, region_id=0, @@ -28,7 +28,7 @@ def test_method_list(self, client: Gcore) -> None: @parametrize def test_raw_response_list(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.list( + response = client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.list( cluster_id="cluster_id", project_id=0, region_id=0, @@ -41,7 +41,7 @@ def test_raw_response_list(self, client: Gcore) -> None: @parametrize def test_streaming_response_list(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.interfaces.with_streaming_response.list( + with client.cloud.gpu_baremetal.clusters.interfaces.with_streaming_response.list( cluster_id="cluster_id", project_id=0, region_id=0, @@ -57,7 +57,7 @@ def test_streaming_response_list(self, client: Gcore) -> None: @parametrize def test_path_params_list(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.list( + client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.list( cluster_id="", project_id=0, region_id=0, @@ -65,7 +65,7 @@ def test_path_params_list(self, client: Gcore) -> None: @parametrize def test_method_attach_overload_1(self, client: Gcore) -> None: - interface = client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -74,7 +74,7 @@ def test_method_attach_overload_1(self, client: Gcore) -> None: @parametrize def test_method_attach_with_all_params_overload_1(self, client: Gcore) -> None: - interface = client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -103,7 +103,7 @@ def test_method_attach_with_all_params_overload_1(self, client: Gcore) -> None: @parametrize def test_raw_response_attach_overload_1(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + response = client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -116,7 +116,7 @@ def test_raw_response_attach_overload_1(self, client: Gcore) -> None: @parametrize def test_streaming_response_attach_overload_1(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.interfaces.with_streaming_response.attach( + with client.cloud.gpu_baremetal.clusters.interfaces.with_streaming_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -132,7 +132,7 @@ def test_streaming_response_attach_overload_1(self, client: Gcore) -> None: @parametrize def test_path_params_attach_overload_1(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="", project_id=0, region_id=0, @@ -140,7 +140,7 @@ def test_path_params_attach_overload_1(self, client: Gcore) -> None: @parametrize def test_method_attach_overload_2(self, client: Gcore) -> None: - interface = client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -150,7 +150,7 @@ def test_method_attach_overload_2(self, client: Gcore) -> None: @parametrize def test_method_attach_with_all_params_overload_2(self, client: Gcore) -> None: - interface = client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -179,7 +179,7 @@ def test_method_attach_with_all_params_overload_2(self, client: Gcore) -> None: @parametrize def test_raw_response_attach_overload_2(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + response = client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -193,7 +193,7 @@ def test_raw_response_attach_overload_2(self, client: Gcore) -> None: @parametrize def test_streaming_response_attach_overload_2(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.interfaces.with_streaming_response.attach( + with client.cloud.gpu_baremetal.clusters.interfaces.with_streaming_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -210,7 +210,7 @@ def test_streaming_response_attach_overload_2(self, client: Gcore) -> None: @parametrize def test_path_params_attach_overload_2(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="", project_id=0, region_id=0, @@ -219,7 +219,7 @@ def test_path_params_attach_overload_2(self, client: Gcore) -> None: @parametrize def test_method_attach_overload_3(self, client: Gcore) -> None: - interface = client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -229,7 +229,7 @@ def test_method_attach_overload_3(self, client: Gcore) -> None: @parametrize def test_method_attach_with_all_params_overload_3(self, client: Gcore) -> None: - interface = client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -259,7 +259,7 @@ def test_method_attach_with_all_params_overload_3(self, client: Gcore) -> None: @parametrize def test_raw_response_attach_overload_3(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + response = client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -273,7 +273,7 @@ def test_raw_response_attach_overload_3(self, client: Gcore) -> None: @parametrize def test_streaming_response_attach_overload_3(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.interfaces.with_streaming_response.attach( + with client.cloud.gpu_baremetal.clusters.interfaces.with_streaming_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -290,7 +290,7 @@ def test_streaming_response_attach_overload_3(self, client: Gcore) -> None: @parametrize def test_path_params_attach_overload_3(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="", project_id=0, region_id=0, @@ -299,7 +299,7 @@ def test_path_params_attach_overload_3(self, client: Gcore) -> None: @parametrize def test_method_attach_overload_4(self, client: Gcore) -> None: - interface = client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -309,7 +309,7 @@ def test_method_attach_overload_4(self, client: Gcore) -> None: @parametrize def test_method_attach_with_all_params_overload_4(self, client: Gcore) -> None: - interface = client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -338,7 +338,7 @@ def test_method_attach_with_all_params_overload_4(self, client: Gcore) -> None: @parametrize def test_raw_response_attach_overload_4(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + response = client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -352,7 +352,7 @@ def test_raw_response_attach_overload_4(self, client: Gcore) -> None: @parametrize def test_streaming_response_attach_overload_4(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.interfaces.with_streaming_response.attach( + with client.cloud.gpu_baremetal.clusters.interfaces.with_streaming_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -369,7 +369,7 @@ def test_streaming_response_attach_overload_4(self, client: Gcore) -> None: @parametrize def test_path_params_attach_overload_4(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="", project_id=0, region_id=0, @@ -378,7 +378,7 @@ def test_path_params_attach_overload_4(self, client: Gcore) -> None: @parametrize def test_method_detach(self, client: Gcore) -> None: - interface = client.cloud.gpu_baremetal_clusters.interfaces.detach( + interface = client.cloud.gpu_baremetal.clusters.interfaces.detach( instance_id="instance_id", project_id=0, region_id=0, @@ -389,7 +389,7 @@ def test_method_detach(self, client: Gcore) -> None: @parametrize def test_raw_response_detach(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.detach( + response = client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.detach( instance_id="instance_id", project_id=0, region_id=0, @@ -404,7 +404,7 @@ def test_raw_response_detach(self, client: Gcore) -> None: @parametrize def test_streaming_response_detach(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.interfaces.with_streaming_response.detach( + with client.cloud.gpu_baremetal.clusters.interfaces.with_streaming_response.detach( instance_id="instance_id", project_id=0, region_id=0, @@ -422,7 +422,7 @@ def test_streaming_response_detach(self, client: Gcore) -> None: @parametrize def test_path_params_detach(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.detach( + client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.detach( instance_id="", project_id=0, region_id=0, @@ -438,7 +438,7 @@ class TestAsyncInterfaces: @parametrize async def test_method_list(self, async_client: AsyncGcore) -> None: - interface = await async_client.cloud.gpu_baremetal_clusters.interfaces.list( + interface = await async_client.cloud.gpu_baremetal.clusters.interfaces.list( cluster_id="cluster_id", project_id=0, region_id=0, @@ -447,7 +447,7 @@ async def test_method_list(self, async_client: AsyncGcore) -> None: @parametrize async def test_raw_response_list(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.list( + response = await async_client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.list( cluster_id="cluster_id", project_id=0, region_id=0, @@ -460,7 +460,7 @@ async def test_raw_response_list(self, async_client: AsyncGcore) -> None: @parametrize async def test_streaming_response_list(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.interfaces.with_streaming_response.list( + async with async_client.cloud.gpu_baremetal.clusters.interfaces.with_streaming_response.list( cluster_id="cluster_id", project_id=0, region_id=0, @@ -476,7 +476,7 @@ async def test_streaming_response_list(self, async_client: AsyncGcore) -> None: @parametrize async def test_path_params_list(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.list( + await async_client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.list( cluster_id="", project_id=0, region_id=0, @@ -484,7 +484,7 @@ async def test_path_params_list(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_attach_overload_1(self, async_client: AsyncGcore) -> None: - interface = await async_client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = await async_client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -493,7 +493,7 @@ async def test_method_attach_overload_1(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_attach_with_all_params_overload_1(self, async_client: AsyncGcore) -> None: - interface = await async_client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = await async_client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -522,7 +522,7 @@ async def test_method_attach_with_all_params_overload_1(self, async_client: Asyn @parametrize async def test_raw_response_attach_overload_1(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + response = await async_client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -535,7 +535,7 @@ async def test_raw_response_attach_overload_1(self, async_client: AsyncGcore) -> @parametrize async def test_streaming_response_attach_overload_1(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.interfaces.with_streaming_response.attach( + async with async_client.cloud.gpu_baremetal.clusters.interfaces.with_streaming_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -551,7 +551,7 @@ async def test_streaming_response_attach_overload_1(self, async_client: AsyncGco @parametrize async def test_path_params_attach_overload_1(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + await async_client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="", project_id=0, region_id=0, @@ -559,7 +559,7 @@ async def test_path_params_attach_overload_1(self, async_client: AsyncGcore) -> @parametrize async def test_method_attach_overload_2(self, async_client: AsyncGcore) -> None: - interface = await async_client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = await async_client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -569,7 +569,7 @@ async def test_method_attach_overload_2(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_attach_with_all_params_overload_2(self, async_client: AsyncGcore) -> None: - interface = await async_client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = await async_client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -598,7 +598,7 @@ async def test_method_attach_with_all_params_overload_2(self, async_client: Asyn @parametrize async def test_raw_response_attach_overload_2(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + response = await async_client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -612,7 +612,7 @@ async def test_raw_response_attach_overload_2(self, async_client: AsyncGcore) -> @parametrize async def test_streaming_response_attach_overload_2(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.interfaces.with_streaming_response.attach( + async with async_client.cloud.gpu_baremetal.clusters.interfaces.with_streaming_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -629,7 +629,7 @@ async def test_streaming_response_attach_overload_2(self, async_client: AsyncGco @parametrize async def test_path_params_attach_overload_2(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + await async_client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="", project_id=0, region_id=0, @@ -638,7 +638,7 @@ async def test_path_params_attach_overload_2(self, async_client: AsyncGcore) -> @parametrize async def test_method_attach_overload_3(self, async_client: AsyncGcore) -> None: - interface = await async_client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = await async_client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -648,7 +648,7 @@ async def test_method_attach_overload_3(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_attach_with_all_params_overload_3(self, async_client: AsyncGcore) -> None: - interface = await async_client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = await async_client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -678,7 +678,7 @@ async def test_method_attach_with_all_params_overload_3(self, async_client: Asyn @parametrize async def test_raw_response_attach_overload_3(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + response = await async_client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -692,7 +692,7 @@ async def test_raw_response_attach_overload_3(self, async_client: AsyncGcore) -> @parametrize async def test_streaming_response_attach_overload_3(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.interfaces.with_streaming_response.attach( + async with async_client.cloud.gpu_baremetal.clusters.interfaces.with_streaming_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -709,7 +709,7 @@ async def test_streaming_response_attach_overload_3(self, async_client: AsyncGco @parametrize async def test_path_params_attach_overload_3(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + await async_client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="", project_id=0, region_id=0, @@ -718,7 +718,7 @@ async def test_path_params_attach_overload_3(self, async_client: AsyncGcore) -> @parametrize async def test_method_attach_overload_4(self, async_client: AsyncGcore) -> None: - interface = await async_client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = await async_client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -728,7 +728,7 @@ async def test_method_attach_overload_4(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_attach_with_all_params_overload_4(self, async_client: AsyncGcore) -> None: - interface = await async_client.cloud.gpu_baremetal_clusters.interfaces.attach( + interface = await async_client.cloud.gpu_baremetal.clusters.interfaces.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -757,7 +757,7 @@ async def test_method_attach_with_all_params_overload_4(self, async_client: Asyn @parametrize async def test_raw_response_attach_overload_4(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + response = await async_client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -771,7 +771,7 @@ async def test_raw_response_attach_overload_4(self, async_client: AsyncGcore) -> @parametrize async def test_streaming_response_attach_overload_4(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.interfaces.with_streaming_response.attach( + async with async_client.cloud.gpu_baremetal.clusters.interfaces.with_streaming_response.attach( instance_id="instance_id", project_id=0, region_id=0, @@ -788,7 +788,7 @@ async def test_streaming_response_attach_overload_4(self, async_client: AsyncGco @parametrize async def test_path_params_attach_overload_4(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.attach( + await async_client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.attach( instance_id="", project_id=0, region_id=0, @@ -797,7 +797,7 @@ async def test_path_params_attach_overload_4(self, async_client: AsyncGcore) -> @parametrize async def test_method_detach(self, async_client: AsyncGcore) -> None: - interface = await async_client.cloud.gpu_baremetal_clusters.interfaces.detach( + interface = await async_client.cloud.gpu_baremetal.clusters.interfaces.detach( instance_id="instance_id", project_id=0, region_id=0, @@ -808,7 +808,7 @@ async def test_method_detach(self, async_client: AsyncGcore) -> None: @parametrize async def test_raw_response_detach(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.detach( + response = await async_client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.detach( instance_id="instance_id", project_id=0, region_id=0, @@ -823,7 +823,7 @@ async def test_raw_response_detach(self, async_client: AsyncGcore) -> None: @parametrize async def test_streaming_response_detach(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.interfaces.with_streaming_response.detach( + async with async_client.cloud.gpu_baremetal.clusters.interfaces.with_streaming_response.detach( instance_id="instance_id", project_id=0, region_id=0, @@ -841,7 +841,7 @@ async def test_streaming_response_detach(self, async_client: AsyncGcore) -> None @parametrize async def test_path_params_detach(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.interfaces.with_raw_response.detach( + await async_client.cloud.gpu_baremetal.clusters.interfaces.with_raw_response.detach( instance_id="", project_id=0, region_id=0, diff --git a/tests/api_resources/cloud/gpu_baremetal_clusters/test_servers.py b/tests/api_resources/cloud/gpu_baremetal/clusters/test_servers.py similarity index 87% rename from tests/api_resources/cloud/gpu_baremetal_clusters/test_servers.py rename to tests/api_resources/cloud/gpu_baremetal/clusters/test_servers.py index e3631089..d468d7c4 100644 --- a/tests/api_resources/cloud/gpu_baremetal_clusters/test_servers.py +++ b/tests/api_resources/cloud/gpu_baremetal/clusters/test_servers.py @@ -12,7 +12,7 @@ from gcore._utils import parse_datetime from gcore.pagination import SyncOffsetPage, AsyncOffsetPage from gcore.types.cloud import Console, TaskIDList -from gcore.types.cloud.gpu_baremetal_clusters import ( +from gcore.types.cloud.gpu_baremetal.clusters import ( GPUBaremetalClusterServer, GPUBaremetalClusterServerV1, ) @@ -25,7 +25,7 @@ class TestServers: @parametrize def test_method_list(self, client: Gcore) -> None: - server = client.cloud.gpu_baremetal_clusters.servers.list( + server = client.cloud.gpu_baremetal.clusters.servers.list( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -34,7 +34,7 @@ def test_method_list(self, client: Gcore) -> None: @parametrize def test_method_list_with_all_params(self, client: Gcore) -> None: - server = client.cloud.gpu_baremetal_clusters.servers.list( + server = client.cloud.gpu_baremetal.clusters.servers.list( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -52,7 +52,7 @@ def test_method_list_with_all_params(self, client: Gcore) -> None: @parametrize def test_raw_response_list(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.servers.with_raw_response.list( + response = client.cloud.gpu_baremetal.clusters.servers.with_raw_response.list( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -65,7 +65,7 @@ def test_raw_response_list(self, client: Gcore) -> None: @parametrize def test_streaming_response_list(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.servers.with_streaming_response.list( + with client.cloud.gpu_baremetal.clusters.servers.with_streaming_response.list( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -81,7 +81,7 @@ def test_streaming_response_list(self, client: Gcore) -> None: @parametrize def test_path_params_list(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - client.cloud.gpu_baremetal_clusters.servers.with_raw_response.list( + client.cloud.gpu_baremetal.clusters.servers.with_raw_response.list( cluster_id="", project_id=1, region_id=7, @@ -89,7 +89,7 @@ def test_path_params_list(self, client: Gcore) -> None: @parametrize def test_method_delete(self, client: Gcore) -> None: - server = client.cloud.gpu_baremetal_clusters.servers.delete( + server = client.cloud.gpu_baremetal.clusters.servers.delete( instance_id="instance_id", project_id=0, region_id=0, @@ -99,7 +99,7 @@ def test_method_delete(self, client: Gcore) -> None: @parametrize def test_method_delete_with_all_params(self, client: Gcore) -> None: - server = client.cloud.gpu_baremetal_clusters.servers.delete( + server = client.cloud.gpu_baremetal.clusters.servers.delete( instance_id="instance_id", project_id=0, region_id=0, @@ -110,7 +110,7 @@ def test_method_delete_with_all_params(self, client: Gcore) -> None: @parametrize def test_raw_response_delete(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.servers.with_raw_response.delete( + response = client.cloud.gpu_baremetal.clusters.servers.with_raw_response.delete( instance_id="instance_id", project_id=0, region_id=0, @@ -124,7 +124,7 @@ def test_raw_response_delete(self, client: Gcore) -> None: @parametrize def test_streaming_response_delete(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.servers.with_streaming_response.delete( + with client.cloud.gpu_baremetal.clusters.servers.with_streaming_response.delete( instance_id="instance_id", project_id=0, region_id=0, @@ -141,7 +141,7 @@ def test_streaming_response_delete(self, client: Gcore) -> None: @parametrize def test_path_params_delete(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - client.cloud.gpu_baremetal_clusters.servers.with_raw_response.delete( + client.cloud.gpu_baremetal.clusters.servers.with_raw_response.delete( instance_id="instance_id", project_id=0, region_id=0, @@ -149,7 +149,7 @@ def test_path_params_delete(self, client: Gcore) -> None: ) with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - client.cloud.gpu_baremetal_clusters.servers.with_raw_response.delete( + client.cloud.gpu_baremetal.clusters.servers.with_raw_response.delete( instance_id="", project_id=0, region_id=0, @@ -158,7 +158,7 @@ def test_path_params_delete(self, client: Gcore) -> None: @parametrize def test_method_get_console(self, client: Gcore) -> None: - server = client.cloud.gpu_baremetal_clusters.servers.get_console( + server = client.cloud.gpu_baremetal.clusters.servers.get_console( instance_id="instance_id", project_id=0, region_id=0, @@ -167,7 +167,7 @@ def test_method_get_console(self, client: Gcore) -> None: @parametrize def test_raw_response_get_console(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.servers.with_raw_response.get_console( + response = client.cloud.gpu_baremetal.clusters.servers.with_raw_response.get_console( instance_id="instance_id", project_id=0, region_id=0, @@ -180,7 +180,7 @@ def test_raw_response_get_console(self, client: Gcore) -> None: @parametrize def test_streaming_response_get_console(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.servers.with_streaming_response.get_console( + with client.cloud.gpu_baremetal.clusters.servers.with_streaming_response.get_console( instance_id="instance_id", project_id=0, region_id=0, @@ -196,7 +196,7 @@ def test_streaming_response_get_console(self, client: Gcore) -> None: @parametrize def test_path_params_get_console(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - client.cloud.gpu_baremetal_clusters.servers.with_raw_response.get_console( + client.cloud.gpu_baremetal.clusters.servers.with_raw_response.get_console( instance_id="", project_id=0, region_id=0, @@ -204,7 +204,7 @@ def test_path_params_get_console(self, client: Gcore) -> None: @parametrize def test_method_powercycle(self, client: Gcore) -> None: - server = client.cloud.gpu_baremetal_clusters.servers.powercycle( + server = client.cloud.gpu_baremetal.clusters.servers.powercycle( instance_id="instance_id", project_id=0, region_id=0, @@ -213,7 +213,7 @@ def test_method_powercycle(self, client: Gcore) -> None: @parametrize def test_raw_response_powercycle(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.servers.with_raw_response.powercycle( + response = client.cloud.gpu_baremetal.clusters.servers.with_raw_response.powercycle( instance_id="instance_id", project_id=0, region_id=0, @@ -226,7 +226,7 @@ def test_raw_response_powercycle(self, client: Gcore) -> None: @parametrize def test_streaming_response_powercycle(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.servers.with_streaming_response.powercycle( + with client.cloud.gpu_baremetal.clusters.servers.with_streaming_response.powercycle( instance_id="instance_id", project_id=0, region_id=0, @@ -242,7 +242,7 @@ def test_streaming_response_powercycle(self, client: Gcore) -> None: @parametrize def test_path_params_powercycle(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - client.cloud.gpu_baremetal_clusters.servers.with_raw_response.powercycle( + client.cloud.gpu_baremetal.clusters.servers.with_raw_response.powercycle( instance_id="", project_id=0, region_id=0, @@ -250,7 +250,7 @@ def test_path_params_powercycle(self, client: Gcore) -> None: @parametrize def test_method_reboot(self, client: Gcore) -> None: - server = client.cloud.gpu_baremetal_clusters.servers.reboot( + server = client.cloud.gpu_baremetal.clusters.servers.reboot( instance_id="instance_id", project_id=0, region_id=0, @@ -259,7 +259,7 @@ def test_method_reboot(self, client: Gcore) -> None: @parametrize def test_raw_response_reboot(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.servers.with_raw_response.reboot( + response = client.cloud.gpu_baremetal.clusters.servers.with_raw_response.reboot( instance_id="instance_id", project_id=0, region_id=0, @@ -272,7 +272,7 @@ def test_raw_response_reboot(self, client: Gcore) -> None: @parametrize def test_streaming_response_reboot(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.servers.with_streaming_response.reboot( + with client.cloud.gpu_baremetal.clusters.servers.with_streaming_response.reboot( instance_id="instance_id", project_id=0, region_id=0, @@ -288,7 +288,7 @@ def test_streaming_response_reboot(self, client: Gcore) -> None: @parametrize def test_path_params_reboot(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - client.cloud.gpu_baremetal_clusters.servers.with_raw_response.reboot( + client.cloud.gpu_baremetal.clusters.servers.with_raw_response.reboot( instance_id="", project_id=0, region_id=0, @@ -302,7 +302,7 @@ class TestAsyncServers: @parametrize async def test_method_list(self, async_client: AsyncGcore) -> None: - server = await async_client.cloud.gpu_baremetal_clusters.servers.list( + server = await async_client.cloud.gpu_baremetal.clusters.servers.list( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -311,7 +311,7 @@ async def test_method_list(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_list_with_all_params(self, async_client: AsyncGcore) -> None: - server = await async_client.cloud.gpu_baremetal_clusters.servers.list( + server = await async_client.cloud.gpu_baremetal.clusters.servers.list( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -329,7 +329,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncGcore) -> No @parametrize async def test_raw_response_list(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.servers.with_raw_response.list( + response = await async_client.cloud.gpu_baremetal.clusters.servers.with_raw_response.list( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -342,7 +342,7 @@ async def test_raw_response_list(self, async_client: AsyncGcore) -> None: @parametrize async def test_streaming_response_list(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.servers.with_streaming_response.list( + async with async_client.cloud.gpu_baremetal.clusters.servers.with_streaming_response.list( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -358,7 +358,7 @@ async def test_streaming_response_list(self, async_client: AsyncGcore) -> None: @parametrize async def test_path_params_list(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.servers.with_raw_response.list( + await async_client.cloud.gpu_baremetal.clusters.servers.with_raw_response.list( cluster_id="", project_id=1, region_id=7, @@ -366,7 +366,7 @@ async def test_path_params_list(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_delete(self, async_client: AsyncGcore) -> None: - server = await async_client.cloud.gpu_baremetal_clusters.servers.delete( + server = await async_client.cloud.gpu_baremetal.clusters.servers.delete( instance_id="instance_id", project_id=0, region_id=0, @@ -376,7 +376,7 @@ async def test_method_delete(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_delete_with_all_params(self, async_client: AsyncGcore) -> None: - server = await async_client.cloud.gpu_baremetal_clusters.servers.delete( + server = await async_client.cloud.gpu_baremetal.clusters.servers.delete( instance_id="instance_id", project_id=0, region_id=0, @@ -387,7 +387,7 @@ async def test_method_delete_with_all_params(self, async_client: AsyncGcore) -> @parametrize async def test_raw_response_delete(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.servers.with_raw_response.delete( + response = await async_client.cloud.gpu_baremetal.clusters.servers.with_raw_response.delete( instance_id="instance_id", project_id=0, region_id=0, @@ -401,7 +401,7 @@ async def test_raw_response_delete(self, async_client: AsyncGcore) -> None: @parametrize async def test_streaming_response_delete(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.servers.with_streaming_response.delete( + async with async_client.cloud.gpu_baremetal.clusters.servers.with_streaming_response.delete( instance_id="instance_id", project_id=0, region_id=0, @@ -418,7 +418,7 @@ async def test_streaming_response_delete(self, async_client: AsyncGcore) -> None @parametrize async def test_path_params_delete(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.servers.with_raw_response.delete( + await async_client.cloud.gpu_baremetal.clusters.servers.with_raw_response.delete( instance_id="instance_id", project_id=0, region_id=0, @@ -426,7 +426,7 @@ async def test_path_params_delete(self, async_client: AsyncGcore) -> None: ) with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.servers.with_raw_response.delete( + await async_client.cloud.gpu_baremetal.clusters.servers.with_raw_response.delete( instance_id="", project_id=0, region_id=0, @@ -435,7 +435,7 @@ async def test_path_params_delete(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_get_console(self, async_client: AsyncGcore) -> None: - server = await async_client.cloud.gpu_baremetal_clusters.servers.get_console( + server = await async_client.cloud.gpu_baremetal.clusters.servers.get_console( instance_id="instance_id", project_id=0, region_id=0, @@ -444,7 +444,7 @@ async def test_method_get_console(self, async_client: AsyncGcore) -> None: @parametrize async def test_raw_response_get_console(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.servers.with_raw_response.get_console( + response = await async_client.cloud.gpu_baremetal.clusters.servers.with_raw_response.get_console( instance_id="instance_id", project_id=0, region_id=0, @@ -457,7 +457,7 @@ async def test_raw_response_get_console(self, async_client: AsyncGcore) -> None: @parametrize async def test_streaming_response_get_console(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.servers.with_streaming_response.get_console( + async with async_client.cloud.gpu_baremetal.clusters.servers.with_streaming_response.get_console( instance_id="instance_id", project_id=0, region_id=0, @@ -473,7 +473,7 @@ async def test_streaming_response_get_console(self, async_client: AsyncGcore) -> @parametrize async def test_path_params_get_console(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.servers.with_raw_response.get_console( + await async_client.cloud.gpu_baremetal.clusters.servers.with_raw_response.get_console( instance_id="", project_id=0, region_id=0, @@ -481,7 +481,7 @@ async def test_path_params_get_console(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_powercycle(self, async_client: AsyncGcore) -> None: - server = await async_client.cloud.gpu_baremetal_clusters.servers.powercycle( + server = await async_client.cloud.gpu_baremetal.clusters.servers.powercycle( instance_id="instance_id", project_id=0, region_id=0, @@ -490,7 +490,7 @@ async def test_method_powercycle(self, async_client: AsyncGcore) -> None: @parametrize async def test_raw_response_powercycle(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.servers.with_raw_response.powercycle( + response = await async_client.cloud.gpu_baremetal.clusters.servers.with_raw_response.powercycle( instance_id="instance_id", project_id=0, region_id=0, @@ -503,7 +503,7 @@ async def test_raw_response_powercycle(self, async_client: AsyncGcore) -> None: @parametrize async def test_streaming_response_powercycle(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.servers.with_streaming_response.powercycle( + async with async_client.cloud.gpu_baremetal.clusters.servers.with_streaming_response.powercycle( instance_id="instance_id", project_id=0, region_id=0, @@ -519,7 +519,7 @@ async def test_streaming_response_powercycle(self, async_client: AsyncGcore) -> @parametrize async def test_path_params_powercycle(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.servers.with_raw_response.powercycle( + await async_client.cloud.gpu_baremetal.clusters.servers.with_raw_response.powercycle( instance_id="", project_id=0, region_id=0, @@ -527,7 +527,7 @@ async def test_path_params_powercycle(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_reboot(self, async_client: AsyncGcore) -> None: - server = await async_client.cloud.gpu_baremetal_clusters.servers.reboot( + server = await async_client.cloud.gpu_baremetal.clusters.servers.reboot( instance_id="instance_id", project_id=0, region_id=0, @@ -536,7 +536,7 @@ async def test_method_reboot(self, async_client: AsyncGcore) -> None: @parametrize async def test_raw_response_reboot(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.servers.with_raw_response.reboot( + response = await async_client.cloud.gpu_baremetal.clusters.servers.with_raw_response.reboot( instance_id="instance_id", project_id=0, region_id=0, @@ -549,7 +549,7 @@ async def test_raw_response_reboot(self, async_client: AsyncGcore) -> None: @parametrize async def test_streaming_response_reboot(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.servers.with_streaming_response.reboot( + async with async_client.cloud.gpu_baremetal.clusters.servers.with_streaming_response.reboot( instance_id="instance_id", project_id=0, region_id=0, @@ -565,7 +565,7 @@ async def test_streaming_response_reboot(self, async_client: AsyncGcore) -> None @parametrize async def test_path_params_reboot(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `instance_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.servers.with_raw_response.reboot( + await async_client.cloud.gpu_baremetal.clusters.servers.with_raw_response.reboot( instance_id="", project_id=0, region_id=0, diff --git a/tests/api_resources/cloud/test_gpu_baremetal_clusters.py b/tests/api_resources/cloud/gpu_baremetal/test_clusters.py similarity index 70% rename from tests/api_resources/cloud/test_gpu_baremetal_clusters.py rename to tests/api_resources/cloud/gpu_baremetal/test_clusters.py index 90aa7127..cd68c18a 100644 --- a/tests/api_resources/cloud/test_gpu_baremetal_clusters.py +++ b/tests/api_resources/cloud/gpu_baremetal/test_clusters.py @@ -10,21 +10,21 @@ from gcore import Gcore, AsyncGcore from tests.utils import assert_matches_type from gcore.pagination import SyncOffsetPage, AsyncOffsetPage -from gcore.types.cloud import ( - TaskIDList, +from gcore.types.cloud import TaskIDList +from gcore.types.cloud.gpu_baremetal import ( GPUBaremetalCluster, ) -from gcore.types.cloud.gpu_baremetal_clusters import GPUBaremetalClusterServerV1List +from gcore.types.cloud.gpu_baremetal.clusters import GPUBaremetalClusterServerV1List base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") -class TestGPUBaremetalClusters: +class TestClusters: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) @parametrize def test_method_create(self, client: Gcore) -> None: - gpu_baremetal_cluster = client.cloud.gpu_baremetal_clusters.create( + cluster = client.cloud.gpu_baremetal.clusters.create( project_id=1, region_id=7, flavor="g3-ai-32-192-1500-l40s-48-1", @@ -33,11 +33,11 @@ def test_method_create(self, client: Gcore) -> None: servers_count=3, servers_settings={"interfaces": [{"type": "external"}]}, ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize def test_method_create_with_all_params(self, client: Gcore) -> None: - gpu_baremetal_cluster = client.cloud.gpu_baremetal_clusters.create( + cluster = client.cloud.gpu_baremetal.clusters.create( project_id=1, region_id=7, flavor="g3-ai-32-192-1500-l40s-48-1", @@ -68,11 +68,11 @@ def test_method_create_with_all_params(self, client: Gcore) -> None: }, tags={"my-tag": "my-tag-value"}, ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize def test_raw_response_create(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.with_raw_response.create( + response = client.cloud.gpu_baremetal.clusters.with_raw_response.create( project_id=1, region_id=7, flavor="g3-ai-32-192-1500-l40s-48-1", @@ -84,12 +84,12 @@ def test_raw_response_create(self, client: Gcore) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize def test_streaming_response_create(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.with_streaming_response.create( + with client.cloud.gpu_baremetal.clusters.with_streaming_response.create( project_id=1, region_id=7, flavor="g3-ai-32-192-1500-l40s-48-1", @@ -101,68 +101,68 @@ def test_streaming_response_create(self, client: Gcore) -> None: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_method_list(self, client: Gcore) -> None: - gpu_baremetal_cluster = client.cloud.gpu_baremetal_clusters.list( + cluster = client.cloud.gpu_baremetal.clusters.list( project_id=1, region_id=7, ) - assert_matches_type(SyncOffsetPage[GPUBaremetalCluster], gpu_baremetal_cluster, path=["response"]) + assert_matches_type(SyncOffsetPage[GPUBaremetalCluster], cluster, path=["response"]) @parametrize def test_method_list_with_all_params(self, client: Gcore) -> None: - gpu_baremetal_cluster = client.cloud.gpu_baremetal_clusters.list( + cluster = client.cloud.gpu_baremetal.clusters.list( project_id=1, region_id=7, limit=10, managed_by=["k8s"], offset=0, ) - assert_matches_type(SyncOffsetPage[GPUBaremetalCluster], gpu_baremetal_cluster, path=["response"]) + assert_matches_type(SyncOffsetPage[GPUBaremetalCluster], cluster, path=["response"]) @parametrize def test_raw_response_list(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.with_raw_response.list( + response = client.cloud.gpu_baremetal.clusters.with_raw_response.list( project_id=1, region_id=7, ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(SyncOffsetPage[GPUBaremetalCluster], gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(SyncOffsetPage[GPUBaremetalCluster], cluster, path=["response"]) @parametrize def test_streaming_response_list(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.with_streaming_response.list( + with client.cloud.gpu_baremetal.clusters.with_streaming_response.list( project_id=1, region_id=7, ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(SyncOffsetPage[GPUBaremetalCluster], gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(SyncOffsetPage[GPUBaremetalCluster], cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_method_delete(self, client: Gcore) -> None: - gpu_baremetal_cluster = client.cloud.gpu_baremetal_clusters.delete( + cluster = client.cloud.gpu_baremetal.clusters.delete( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize def test_method_delete_with_all_params(self, client: Gcore) -> None: - gpu_baremetal_cluster = client.cloud.gpu_baremetal_clusters.delete( + cluster = client.cloud.gpu_baremetal.clusters.delete( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -171,11 +171,11 @@ def test_method_delete_with_all_params(self, client: Gcore) -> None: floating_ip_ids=["e4a01208-d6ac-4304-bf86-3028154b070a"], reserved_fixed_ip_ids=["a29b8e1e-08d3-4cec-91fb-06e81e5f46d5"], ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize def test_raw_response_delete(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.with_raw_response.delete( + response = client.cloud.gpu_baremetal.clusters.with_raw_response.delete( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -183,12 +183,12 @@ def test_raw_response_delete(self, client: Gcore) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize def test_streaming_response_delete(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.with_streaming_response.delete( + with client.cloud.gpu_baremetal.clusters.with_streaming_response.delete( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -196,15 +196,15 @@ def test_streaming_response_delete(self, client: Gcore) -> None: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_delete(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - client.cloud.gpu_baremetal_clusters.with_raw_response.delete( + client.cloud.gpu_baremetal.clusters.with_raw_response.delete( cluster_id="", project_id=1, region_id=7, @@ -212,18 +212,18 @@ def test_path_params_delete(self, client: Gcore) -> None: @parametrize def test_method_action(self, client: Gcore) -> None: - gpu_baremetal_cluster = client.cloud.gpu_baremetal_clusters.action( + cluster = client.cloud.gpu_baremetal.clusters.action( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, action="update_tags", tags={"foo": "my-tag-value"}, ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize def test_raw_response_action(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.with_raw_response.action( + response = client.cloud.gpu_baremetal.clusters.with_raw_response.action( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -233,12 +233,12 @@ def test_raw_response_action(self, client: Gcore) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize def test_streaming_response_action(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.with_streaming_response.action( + with client.cloud.gpu_baremetal.clusters.with_streaming_response.action( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -248,15 +248,15 @@ def test_streaming_response_action(self, client: Gcore) -> None: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_action(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - client.cloud.gpu_baremetal_clusters.with_raw_response.action( + client.cloud.gpu_baremetal.clusters.with_raw_response.action( cluster_id="", project_id=1, region_id=7, @@ -266,16 +266,16 @@ def test_path_params_action(self, client: Gcore) -> None: @parametrize def test_method_get(self, client: Gcore) -> None: - gpu_baremetal_cluster = client.cloud.gpu_baremetal_clusters.get( + cluster = client.cloud.gpu_baremetal.clusters.get( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, ) - assert_matches_type(GPUBaremetalCluster, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(GPUBaremetalCluster, cluster, path=["response"]) @parametrize def test_raw_response_get(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.with_raw_response.get( + response = client.cloud.gpu_baremetal.clusters.with_raw_response.get( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -283,12 +283,12 @@ def test_raw_response_get(self, client: Gcore) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(GPUBaremetalCluster, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(GPUBaremetalCluster, cluster, path=["response"]) @parametrize def test_streaming_response_get(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.with_streaming_response.get( + with client.cloud.gpu_baremetal.clusters.with_streaming_response.get( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -296,15 +296,15 @@ def test_streaming_response_get(self, client: Gcore) -> None: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(GPUBaremetalCluster, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(GPUBaremetalCluster, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_get(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - client.cloud.gpu_baremetal_clusters.with_raw_response.get( + client.cloud.gpu_baremetal.clusters.with_raw_response.get( cluster_id="", project_id=1, region_id=7, @@ -312,16 +312,16 @@ def test_path_params_get(self, client: Gcore) -> None: @parametrize def test_method_powercycle_all_servers(self, client: Gcore) -> None: - gpu_baremetal_cluster = client.cloud.gpu_baremetal_clusters.powercycle_all_servers( + cluster = client.cloud.gpu_baremetal.clusters.powercycle_all_servers( cluster_id="cluster_id", project_id=0, region_id=0, ) - assert_matches_type(GPUBaremetalClusterServerV1List, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(GPUBaremetalClusterServerV1List, cluster, path=["response"]) @parametrize def test_raw_response_powercycle_all_servers(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.with_raw_response.powercycle_all_servers( + response = client.cloud.gpu_baremetal.clusters.with_raw_response.powercycle_all_servers( cluster_id="cluster_id", project_id=0, region_id=0, @@ -329,12 +329,12 @@ def test_raw_response_powercycle_all_servers(self, client: Gcore) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(GPUBaremetalClusterServerV1List, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(GPUBaremetalClusterServerV1List, cluster, path=["response"]) @parametrize def test_streaming_response_powercycle_all_servers(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.with_streaming_response.powercycle_all_servers( + with client.cloud.gpu_baremetal.clusters.with_streaming_response.powercycle_all_servers( cluster_id="cluster_id", project_id=0, region_id=0, @@ -342,15 +342,15 @@ def test_streaming_response_powercycle_all_servers(self, client: Gcore) -> None: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(GPUBaremetalClusterServerV1List, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(GPUBaremetalClusterServerV1List, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_powercycle_all_servers(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - client.cloud.gpu_baremetal_clusters.with_raw_response.powercycle_all_servers( + client.cloud.gpu_baremetal.clusters.with_raw_response.powercycle_all_servers( cluster_id="", project_id=0, region_id=0, @@ -358,16 +358,16 @@ def test_path_params_powercycle_all_servers(self, client: Gcore) -> None: @parametrize def test_method_reboot_all_servers(self, client: Gcore) -> None: - gpu_baremetal_cluster = client.cloud.gpu_baremetal_clusters.reboot_all_servers( + cluster = client.cloud.gpu_baremetal.clusters.reboot_all_servers( cluster_id="cluster_id", project_id=0, region_id=0, ) - assert_matches_type(GPUBaremetalClusterServerV1List, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(GPUBaremetalClusterServerV1List, cluster, path=["response"]) @parametrize def test_raw_response_reboot_all_servers(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.with_raw_response.reboot_all_servers( + response = client.cloud.gpu_baremetal.clusters.with_raw_response.reboot_all_servers( cluster_id="cluster_id", project_id=0, region_id=0, @@ -375,12 +375,12 @@ def test_raw_response_reboot_all_servers(self, client: Gcore) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(GPUBaremetalClusterServerV1List, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(GPUBaremetalClusterServerV1List, cluster, path=["response"]) @parametrize def test_streaming_response_reboot_all_servers(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.with_streaming_response.reboot_all_servers( + with client.cloud.gpu_baremetal.clusters.with_streaming_response.reboot_all_servers( cluster_id="cluster_id", project_id=0, region_id=0, @@ -388,15 +388,15 @@ def test_streaming_response_reboot_all_servers(self, client: Gcore) -> None: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(GPUBaremetalClusterServerV1List, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(GPUBaremetalClusterServerV1List, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_reboot_all_servers(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - client.cloud.gpu_baremetal_clusters.with_raw_response.reboot_all_servers( + client.cloud.gpu_baremetal.clusters.with_raw_response.reboot_all_servers( cluster_id="", project_id=0, region_id=0, @@ -404,17 +404,17 @@ def test_path_params_reboot_all_servers(self, client: Gcore) -> None: @parametrize def test_method_rebuild(self, client: Gcore) -> None: - gpu_baremetal_cluster = client.cloud.gpu_baremetal_clusters.rebuild( + cluster = client.cloud.gpu_baremetal.clusters.rebuild( cluster_id="cluster_id", project_id=0, region_id=0, nodes=["string"], ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize def test_method_rebuild_with_all_params(self, client: Gcore) -> None: - gpu_baremetal_cluster = client.cloud.gpu_baremetal_clusters.rebuild( + cluster = client.cloud.gpu_baremetal.clusters.rebuild( cluster_id="cluster_id", project_id=0, region_id=0, @@ -422,11 +422,11 @@ def test_method_rebuild_with_all_params(self, client: Gcore) -> None: image_id="f01fd9a0-9548-48ba-82dc-a8c8b2d6f2f1", user_data="user_data", ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize def test_raw_response_rebuild(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.with_raw_response.rebuild( + response = client.cloud.gpu_baremetal.clusters.with_raw_response.rebuild( cluster_id="cluster_id", project_id=0, region_id=0, @@ -435,12 +435,12 @@ def test_raw_response_rebuild(self, client: Gcore) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize def test_streaming_response_rebuild(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.with_streaming_response.rebuild( + with client.cloud.gpu_baremetal.clusters.with_streaming_response.rebuild( cluster_id="cluster_id", project_id=0, region_id=0, @@ -449,15 +449,15 @@ def test_streaming_response_rebuild(self, client: Gcore) -> None: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_rebuild(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - client.cloud.gpu_baremetal_clusters.with_raw_response.rebuild( + client.cloud.gpu_baremetal.clusters.with_raw_response.rebuild( cluster_id="", project_id=0, region_id=0, @@ -466,17 +466,17 @@ def test_path_params_rebuild(self, client: Gcore) -> None: @parametrize def test_method_resize(self, client: Gcore) -> None: - gpu_baremetal_cluster = client.cloud.gpu_baremetal_clusters.resize( + cluster = client.cloud.gpu_baremetal.clusters.resize( cluster_id="cluster_id", project_id=0, region_id=0, instances_count=1, ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize def test_raw_response_resize(self, client: Gcore) -> None: - response = client.cloud.gpu_baremetal_clusters.with_raw_response.resize( + response = client.cloud.gpu_baremetal.clusters.with_raw_response.resize( cluster_id="cluster_id", project_id=0, region_id=0, @@ -485,12 +485,12 @@ def test_raw_response_resize(self, client: Gcore) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize def test_streaming_response_resize(self, client: Gcore) -> None: - with client.cloud.gpu_baremetal_clusters.with_streaming_response.resize( + with client.cloud.gpu_baremetal.clusters.with_streaming_response.resize( cluster_id="cluster_id", project_id=0, region_id=0, @@ -499,15 +499,15 @@ def test_streaming_response_resize(self, client: Gcore) -> None: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_resize(self, client: Gcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - client.cloud.gpu_baremetal_clusters.with_raw_response.resize( + client.cloud.gpu_baremetal.clusters.with_raw_response.resize( cluster_id="", project_id=0, region_id=0, @@ -515,14 +515,14 @@ def test_path_params_resize(self, client: Gcore) -> None: ) -class TestAsyncGPUBaremetalClusters: +class TestAsyncClusters: parametrize = pytest.mark.parametrize( "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) @parametrize async def test_method_create(self, async_client: AsyncGcore) -> None: - gpu_baremetal_cluster = await async_client.cloud.gpu_baremetal_clusters.create( + cluster = await async_client.cloud.gpu_baremetal.clusters.create( project_id=1, region_id=7, flavor="g3-ai-32-192-1500-l40s-48-1", @@ -531,11 +531,11 @@ async def test_method_create(self, async_client: AsyncGcore) -> None: servers_count=3, servers_settings={"interfaces": [{"type": "external"}]}, ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize async def test_method_create_with_all_params(self, async_client: AsyncGcore) -> None: - gpu_baremetal_cluster = await async_client.cloud.gpu_baremetal_clusters.create( + cluster = await async_client.cloud.gpu_baremetal.clusters.create( project_id=1, region_id=7, flavor="g3-ai-32-192-1500-l40s-48-1", @@ -566,11 +566,11 @@ async def test_method_create_with_all_params(self, async_client: AsyncGcore) -> }, tags={"my-tag": "my-tag-value"}, ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize async def test_raw_response_create(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.with_raw_response.create( + response = await async_client.cloud.gpu_baremetal.clusters.with_raw_response.create( project_id=1, region_id=7, flavor="g3-ai-32-192-1500-l40s-48-1", @@ -582,12 +582,12 @@ async def test_raw_response_create(self, async_client: AsyncGcore) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize async def test_streaming_response_create(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.with_streaming_response.create( + async with async_client.cloud.gpu_baremetal.clusters.with_streaming_response.create( project_id=1, region_id=7, flavor="g3-ai-32-192-1500-l40s-48-1", @@ -599,68 +599,68 @@ async def test_streaming_response_create(self, async_client: AsyncGcore) -> None assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_method_list(self, async_client: AsyncGcore) -> None: - gpu_baremetal_cluster = await async_client.cloud.gpu_baremetal_clusters.list( + cluster = await async_client.cloud.gpu_baremetal.clusters.list( project_id=1, region_id=7, ) - assert_matches_type(AsyncOffsetPage[GPUBaremetalCluster], gpu_baremetal_cluster, path=["response"]) + assert_matches_type(AsyncOffsetPage[GPUBaremetalCluster], cluster, path=["response"]) @parametrize async def test_method_list_with_all_params(self, async_client: AsyncGcore) -> None: - gpu_baremetal_cluster = await async_client.cloud.gpu_baremetal_clusters.list( + cluster = await async_client.cloud.gpu_baremetal.clusters.list( project_id=1, region_id=7, limit=10, managed_by=["k8s"], offset=0, ) - assert_matches_type(AsyncOffsetPage[GPUBaremetalCluster], gpu_baremetal_cluster, path=["response"]) + assert_matches_type(AsyncOffsetPage[GPUBaremetalCluster], cluster, path=["response"]) @parametrize async def test_raw_response_list(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.with_raw_response.list( + response = await async_client.cloud.gpu_baremetal.clusters.with_raw_response.list( project_id=1, region_id=7, ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(AsyncOffsetPage[GPUBaremetalCluster], gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(AsyncOffsetPage[GPUBaremetalCluster], cluster, path=["response"]) @parametrize async def test_streaming_response_list(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.with_streaming_response.list( + async with async_client.cloud.gpu_baremetal.clusters.with_streaming_response.list( project_id=1, region_id=7, ) as response: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(AsyncOffsetPage[GPUBaremetalCluster], gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(AsyncOffsetPage[GPUBaremetalCluster], cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_method_delete(self, async_client: AsyncGcore) -> None: - gpu_baremetal_cluster = await async_client.cloud.gpu_baremetal_clusters.delete( + cluster = await async_client.cloud.gpu_baremetal.clusters.delete( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize async def test_method_delete_with_all_params(self, async_client: AsyncGcore) -> None: - gpu_baremetal_cluster = await async_client.cloud.gpu_baremetal_clusters.delete( + cluster = await async_client.cloud.gpu_baremetal.clusters.delete( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -669,11 +669,11 @@ async def test_method_delete_with_all_params(self, async_client: AsyncGcore) -> floating_ip_ids=["e4a01208-d6ac-4304-bf86-3028154b070a"], reserved_fixed_ip_ids=["a29b8e1e-08d3-4cec-91fb-06e81e5f46d5"], ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize async def test_raw_response_delete(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.with_raw_response.delete( + response = await async_client.cloud.gpu_baremetal.clusters.with_raw_response.delete( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -681,12 +681,12 @@ async def test_raw_response_delete(self, async_client: AsyncGcore) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize async def test_streaming_response_delete(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.with_streaming_response.delete( + async with async_client.cloud.gpu_baremetal.clusters.with_streaming_response.delete( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -694,15 +694,15 @@ async def test_streaming_response_delete(self, async_client: AsyncGcore) -> None assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_delete(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.with_raw_response.delete( + await async_client.cloud.gpu_baremetal.clusters.with_raw_response.delete( cluster_id="", project_id=1, region_id=7, @@ -710,18 +710,18 @@ async def test_path_params_delete(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_action(self, async_client: AsyncGcore) -> None: - gpu_baremetal_cluster = await async_client.cloud.gpu_baremetal_clusters.action( + cluster = await async_client.cloud.gpu_baremetal.clusters.action( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, action="update_tags", tags={"foo": "my-tag-value"}, ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize async def test_raw_response_action(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.with_raw_response.action( + response = await async_client.cloud.gpu_baremetal.clusters.with_raw_response.action( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -731,12 +731,12 @@ async def test_raw_response_action(self, async_client: AsyncGcore) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize async def test_streaming_response_action(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.with_streaming_response.action( + async with async_client.cloud.gpu_baremetal.clusters.with_streaming_response.action( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -746,15 +746,15 @@ async def test_streaming_response_action(self, async_client: AsyncGcore) -> None assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_action(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.with_raw_response.action( + await async_client.cloud.gpu_baremetal.clusters.with_raw_response.action( cluster_id="", project_id=1, region_id=7, @@ -764,16 +764,16 @@ async def test_path_params_action(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_get(self, async_client: AsyncGcore) -> None: - gpu_baremetal_cluster = await async_client.cloud.gpu_baremetal_clusters.get( + cluster = await async_client.cloud.gpu_baremetal.clusters.get( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, ) - assert_matches_type(GPUBaremetalCluster, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(GPUBaremetalCluster, cluster, path=["response"]) @parametrize async def test_raw_response_get(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.with_raw_response.get( + response = await async_client.cloud.gpu_baremetal.clusters.with_raw_response.get( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -781,12 +781,12 @@ async def test_raw_response_get(self, async_client: AsyncGcore) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(GPUBaremetalCluster, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(GPUBaremetalCluster, cluster, path=["response"]) @parametrize async def test_streaming_response_get(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.with_streaming_response.get( + async with async_client.cloud.gpu_baremetal.clusters.with_streaming_response.get( cluster_id="1aaaab48-10d0-46d9-80cc-85209284ceb4", project_id=1, region_id=7, @@ -794,15 +794,15 @@ async def test_streaming_response_get(self, async_client: AsyncGcore) -> None: assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(GPUBaremetalCluster, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(GPUBaremetalCluster, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_get(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.with_raw_response.get( + await async_client.cloud.gpu_baremetal.clusters.with_raw_response.get( cluster_id="", project_id=1, region_id=7, @@ -810,16 +810,16 @@ async def test_path_params_get(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_powercycle_all_servers(self, async_client: AsyncGcore) -> None: - gpu_baremetal_cluster = await async_client.cloud.gpu_baremetal_clusters.powercycle_all_servers( + cluster = await async_client.cloud.gpu_baremetal.clusters.powercycle_all_servers( cluster_id="cluster_id", project_id=0, region_id=0, ) - assert_matches_type(GPUBaremetalClusterServerV1List, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(GPUBaremetalClusterServerV1List, cluster, path=["response"]) @parametrize async def test_raw_response_powercycle_all_servers(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.with_raw_response.powercycle_all_servers( + response = await async_client.cloud.gpu_baremetal.clusters.with_raw_response.powercycle_all_servers( cluster_id="cluster_id", project_id=0, region_id=0, @@ -827,12 +827,12 @@ async def test_raw_response_powercycle_all_servers(self, async_client: AsyncGcor assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(GPUBaremetalClusterServerV1List, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(GPUBaremetalClusterServerV1List, cluster, path=["response"]) @parametrize async def test_streaming_response_powercycle_all_servers(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.with_streaming_response.powercycle_all_servers( + async with async_client.cloud.gpu_baremetal.clusters.with_streaming_response.powercycle_all_servers( cluster_id="cluster_id", project_id=0, region_id=0, @@ -840,15 +840,15 @@ async def test_streaming_response_powercycle_all_servers(self, async_client: Asy assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(GPUBaremetalClusterServerV1List, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(GPUBaremetalClusterServerV1List, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_powercycle_all_servers(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.with_raw_response.powercycle_all_servers( + await async_client.cloud.gpu_baremetal.clusters.with_raw_response.powercycle_all_servers( cluster_id="", project_id=0, region_id=0, @@ -856,16 +856,16 @@ async def test_path_params_powercycle_all_servers(self, async_client: AsyncGcore @parametrize async def test_method_reboot_all_servers(self, async_client: AsyncGcore) -> None: - gpu_baremetal_cluster = await async_client.cloud.gpu_baremetal_clusters.reboot_all_servers( + cluster = await async_client.cloud.gpu_baremetal.clusters.reboot_all_servers( cluster_id="cluster_id", project_id=0, region_id=0, ) - assert_matches_type(GPUBaremetalClusterServerV1List, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(GPUBaremetalClusterServerV1List, cluster, path=["response"]) @parametrize async def test_raw_response_reboot_all_servers(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.with_raw_response.reboot_all_servers( + response = await async_client.cloud.gpu_baremetal.clusters.with_raw_response.reboot_all_servers( cluster_id="cluster_id", project_id=0, region_id=0, @@ -873,12 +873,12 @@ async def test_raw_response_reboot_all_servers(self, async_client: AsyncGcore) - assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(GPUBaremetalClusterServerV1List, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(GPUBaremetalClusterServerV1List, cluster, path=["response"]) @parametrize async def test_streaming_response_reboot_all_servers(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.with_streaming_response.reboot_all_servers( + async with async_client.cloud.gpu_baremetal.clusters.with_streaming_response.reboot_all_servers( cluster_id="cluster_id", project_id=0, region_id=0, @@ -886,15 +886,15 @@ async def test_streaming_response_reboot_all_servers(self, async_client: AsyncGc assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(GPUBaremetalClusterServerV1List, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(GPUBaremetalClusterServerV1List, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_reboot_all_servers(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.with_raw_response.reboot_all_servers( + await async_client.cloud.gpu_baremetal.clusters.with_raw_response.reboot_all_servers( cluster_id="", project_id=0, region_id=0, @@ -902,17 +902,17 @@ async def test_path_params_reboot_all_servers(self, async_client: AsyncGcore) -> @parametrize async def test_method_rebuild(self, async_client: AsyncGcore) -> None: - gpu_baremetal_cluster = await async_client.cloud.gpu_baremetal_clusters.rebuild( + cluster = await async_client.cloud.gpu_baremetal.clusters.rebuild( cluster_id="cluster_id", project_id=0, region_id=0, nodes=["string"], ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize async def test_method_rebuild_with_all_params(self, async_client: AsyncGcore) -> None: - gpu_baremetal_cluster = await async_client.cloud.gpu_baremetal_clusters.rebuild( + cluster = await async_client.cloud.gpu_baremetal.clusters.rebuild( cluster_id="cluster_id", project_id=0, region_id=0, @@ -920,11 +920,11 @@ async def test_method_rebuild_with_all_params(self, async_client: AsyncGcore) -> image_id="f01fd9a0-9548-48ba-82dc-a8c8b2d6f2f1", user_data="user_data", ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize async def test_raw_response_rebuild(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.with_raw_response.rebuild( + response = await async_client.cloud.gpu_baremetal.clusters.with_raw_response.rebuild( cluster_id="cluster_id", project_id=0, region_id=0, @@ -933,12 +933,12 @@ async def test_raw_response_rebuild(self, async_client: AsyncGcore) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize async def test_streaming_response_rebuild(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.with_streaming_response.rebuild( + async with async_client.cloud.gpu_baremetal.clusters.with_streaming_response.rebuild( cluster_id="cluster_id", project_id=0, region_id=0, @@ -947,15 +947,15 @@ async def test_streaming_response_rebuild(self, async_client: AsyncGcore) -> Non assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_rebuild(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.with_raw_response.rebuild( + await async_client.cloud.gpu_baremetal.clusters.with_raw_response.rebuild( cluster_id="", project_id=0, region_id=0, @@ -964,17 +964,17 @@ async def test_path_params_rebuild(self, async_client: AsyncGcore) -> None: @parametrize async def test_method_resize(self, async_client: AsyncGcore) -> None: - gpu_baremetal_cluster = await async_client.cloud.gpu_baremetal_clusters.resize( + cluster = await async_client.cloud.gpu_baremetal.clusters.resize( cluster_id="cluster_id", project_id=0, region_id=0, instances_count=1, ) - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize async def test_raw_response_resize(self, async_client: AsyncGcore) -> None: - response = await async_client.cloud.gpu_baremetal_clusters.with_raw_response.resize( + response = await async_client.cloud.gpu_baremetal.clusters.with_raw_response.resize( cluster_id="cluster_id", project_id=0, region_id=0, @@ -983,12 +983,12 @@ async def test_raw_response_resize(self, async_client: AsyncGcore) -> None: assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) @parametrize async def test_streaming_response_resize(self, async_client: AsyncGcore) -> None: - async with async_client.cloud.gpu_baremetal_clusters.with_streaming_response.resize( + async with async_client.cloud.gpu_baremetal.clusters.with_streaming_response.resize( cluster_id="cluster_id", project_id=0, region_id=0, @@ -997,15 +997,15 @@ async def test_streaming_response_resize(self, async_client: AsyncGcore) -> None assert not response.is_closed assert response.http_request.headers.get("X-Stainless-Lang") == "python" - gpu_baremetal_cluster = await response.parse() - assert_matches_type(TaskIDList, gpu_baremetal_cluster, path=["response"]) + cluster = await response.parse() + assert_matches_type(TaskIDList, cluster, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_resize(self, async_client: AsyncGcore) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `cluster_id` but received ''"): - await async_client.cloud.gpu_baremetal_clusters.with_raw_response.resize( + await async_client.cloud.gpu_baremetal.clusters.with_raw_response.resize( cluster_id="", project_id=0, region_id=0,