platform-api-python-client 4.25.0__py3-none-any.whl → 4.28.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (23) hide show
  1. platform_api_python_client/__init__.py +7 -1
  2. platform_api_python_client/api/external_api.py +2063 -485
  3. platform_api_python_client/api_client.py +1 -1
  4. platform_api_python_client/configuration.py +1 -1
  5. platform_api_python_client/models/__init__.py +6 -0
  6. platform_api_python_client/models/create_c_serve_v3_deployment_request.py +1 -8
  7. platform_api_python_client/models/create_compute_deployment_request.py +12 -2
  8. platform_api_python_client/models/create_inference_v3_deployment_request.py +1 -8
  9. platform_api_python_client/models/create_job_deployment_request.py +12 -2
  10. platform_api_python_client/models/get_c_serve_v3_deployment_response.py +1 -8
  11. platform_api_python_client/models/get_compute_deployment_response.py +11 -1
  12. platform_api_python_client/models/get_inference_v3_deployment_response.py +1 -8
  13. platform_api_python_client/models/get_job_deployment_response.py +12 -2
  14. platform_api_python_client/models/hardware_preset_response.py +96 -0
  15. platform_api_python_client/models/list_hardware_preset_response.py +95 -0
  16. platform_api_python_client/models/list_organization_gpu_quota_response.py +95 -0
  17. platform_api_python_client/models/organization_gpu_quota_request.py +88 -0
  18. platform_api_python_client/models/organization_gpu_quota_response.py +91 -0
  19. platform_api_python_client/models/volume_mount.py +92 -0
  20. {platform_api_python_client-4.25.0.dist-info → platform_api_python_client-4.28.0.dist-info}/METADATA +1 -1
  21. {platform_api_python_client-4.25.0.dist-info → platform_api_python_client-4.28.0.dist-info}/RECORD +23 -17
  22. {platform_api_python_client-4.25.0.dist-info → platform_api_python_client-4.28.0.dist-info}/WHEEL +0 -0
  23. {platform_api_python_client-4.25.0.dist-info → platform_api_python_client-4.28.0.dist-info}/top_level.txt +0 -0
@@ -16,7 +16,6 @@ from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
16
16
  from typing import Any, Dict, List, Optional, Tuple, Union
17
17
  from typing_extensions import Annotated
18
18
 
19
- from datetime import date
20
19
  from pydantic import Field, StrictBool, StrictInt, StrictStr, field_validator
21
20
  from typing import Any, Optional
22
21
  from typing_extensions import Annotated
@@ -70,11 +69,15 @@ from platform_api_python_client.models.list_deployment_revisions_response import
70
69
  from platform_api_python_client.models.list_get_cluster_response import ListGetClusterResponse
71
70
  from platform_api_python_client.models.list_get_deployment_response import ListGetDeploymentResponse
72
71
  from platform_api_python_client.models.list_hardware_instance_response import ListHardwareInstanceResponse
72
+ from platform_api_python_client.models.list_hardware_preset_response import ListHardwarePresetResponse
73
+ from platform_api_python_client.models.list_organization_gpu_quota_response import ListOrganizationGpuQuotaResponse
73
74
  from platform_api_python_client.models.list_prebuilt_image_response import ListPrebuiltImageResponse
74
75
  from platform_api_python_client.models.list_service_accounts_response import ListServiceAccountsResponse
75
76
  from platform_api_python_client.models.list_user_vault_items_response import ListUserVaultItemsResponse
76
77
  from platform_api_python_client.models.list_volumes_response import ListVolumesResponse
77
78
  from platform_api_python_client.models.metric import Metric
79
+ from platform_api_python_client.models.organization_gpu_quota_request import OrganizationGpuQuotaRequest
80
+ from platform_api_python_client.models.organization_gpu_quota_response import OrganizationGpuQuotaResponse
78
81
  from platform_api_python_client.models.rollout_strategy_params import RolloutStrategyParams
79
82
  from platform_api_python_client.models.service_account_response import ServiceAccountResponse
80
83
  from platform_api_python_client.models.update_cluster_metadata_request import UpdateClusterMetadataRequest
@@ -3859,6 +3862,285 @@ class EXTERNALApi:
3859
3862
 
3860
3863
 
3861
3864
 
3865
+ @validate_call
3866
+ def delete_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_delete(
3867
+ self,
3868
+ cluster_id: StrictInt,
3869
+ organization_id: StrictInt,
3870
+ _request_timeout: Union[
3871
+ None,
3872
+ Annotated[StrictFloat, Field(gt=0)],
3873
+ Tuple[
3874
+ Annotated[StrictFloat, Field(gt=0)],
3875
+ Annotated[StrictFloat, Field(gt=0)]
3876
+ ]
3877
+ ] = None,
3878
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
3879
+ _content_type: Optional[StrictStr] = None,
3880
+ _headers: Optional[Dict[StrictStr, Any]] = None,
3881
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3882
+ ) -> OrganizationGpuQuotaResponse:
3883
+ """Delete Org Gpu Quota On Cluster
3884
+
3885
+ Set persisted quota to unlimited (-1). Creates a row if none exists. Does not remove the row or the KAI Queue CR.
3886
+
3887
+ :param cluster_id: (required)
3888
+ :type cluster_id: int
3889
+ :param organization_id: (required)
3890
+ :type organization_id: int
3891
+ :param _request_timeout: timeout setting for this request. If one
3892
+ number provided, it will be total request
3893
+ timeout. It can also be a pair (tuple) of
3894
+ (connection, read) timeouts.
3895
+ :type _request_timeout: int, tuple(int, int), optional
3896
+ :param _request_auth: set to override the auth_settings for an a single
3897
+ request; this effectively ignores the
3898
+ authentication in the spec for a single request.
3899
+ :type _request_auth: dict, optional
3900
+ :param _content_type: force content-type for the request.
3901
+ :type _content_type: str, Optional
3902
+ :param _headers: set to override the headers for a single
3903
+ request; this effectively ignores the headers
3904
+ in the spec for a single request.
3905
+ :type _headers: dict, optional
3906
+ :param _host_index: set to override the host_index for a single
3907
+ request; this effectively ignores the host_index
3908
+ in the spec for a single request.
3909
+ :type _host_index: int, optional
3910
+ :return: Returns the result object.
3911
+ """ # noqa: E501
3912
+
3913
+ _param = self._delete_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_delete_serialize(
3914
+ cluster_id=cluster_id,
3915
+ organization_id=organization_id,
3916
+ _request_auth=_request_auth,
3917
+ _content_type=_content_type,
3918
+ _headers=_headers,
3919
+ _host_index=_host_index
3920
+ )
3921
+
3922
+ _response_types_map: Dict[str, Optional[str]] = {
3923
+ '200': "OrganizationGpuQuotaResponse",
3924
+ '422': "HTTPValidationError",
3925
+ }
3926
+ response_data = self.api_client.call_api(
3927
+ *_param,
3928
+ _request_timeout=_request_timeout
3929
+ )
3930
+ response_data.read()
3931
+ return self.api_client.response_deserialize(
3932
+ response_data=response_data,
3933
+ response_types_map=_response_types_map,
3934
+ ).data
3935
+
3936
+
3937
+ @validate_call
3938
+ def delete_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_delete_with_http_info(
3939
+ self,
3940
+ cluster_id: StrictInt,
3941
+ organization_id: StrictInt,
3942
+ _request_timeout: Union[
3943
+ None,
3944
+ Annotated[StrictFloat, Field(gt=0)],
3945
+ Tuple[
3946
+ Annotated[StrictFloat, Field(gt=0)],
3947
+ Annotated[StrictFloat, Field(gt=0)]
3948
+ ]
3949
+ ] = None,
3950
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
3951
+ _content_type: Optional[StrictStr] = None,
3952
+ _headers: Optional[Dict[StrictStr, Any]] = None,
3953
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3954
+ ) -> ApiResponse[OrganizationGpuQuotaResponse]:
3955
+ """Delete Org Gpu Quota On Cluster
3956
+
3957
+ Set persisted quota to unlimited (-1). Creates a row if none exists. Does not remove the row or the KAI Queue CR.
3958
+
3959
+ :param cluster_id: (required)
3960
+ :type cluster_id: int
3961
+ :param organization_id: (required)
3962
+ :type organization_id: int
3963
+ :param _request_timeout: timeout setting for this request. If one
3964
+ number provided, it will be total request
3965
+ timeout. It can also be a pair (tuple) of
3966
+ (connection, read) timeouts.
3967
+ :type _request_timeout: int, tuple(int, int), optional
3968
+ :param _request_auth: set to override the auth_settings for an a single
3969
+ request; this effectively ignores the
3970
+ authentication in the spec for a single request.
3971
+ :type _request_auth: dict, optional
3972
+ :param _content_type: force content-type for the request.
3973
+ :type _content_type: str, Optional
3974
+ :param _headers: set to override the headers for a single
3975
+ request; this effectively ignores the headers
3976
+ in the spec for a single request.
3977
+ :type _headers: dict, optional
3978
+ :param _host_index: set to override the host_index for a single
3979
+ request; this effectively ignores the host_index
3980
+ in the spec for a single request.
3981
+ :type _host_index: int, optional
3982
+ :return: Returns the result object.
3983
+ """ # noqa: E501
3984
+
3985
+ _param = self._delete_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_delete_serialize(
3986
+ cluster_id=cluster_id,
3987
+ organization_id=organization_id,
3988
+ _request_auth=_request_auth,
3989
+ _content_type=_content_type,
3990
+ _headers=_headers,
3991
+ _host_index=_host_index
3992
+ )
3993
+
3994
+ _response_types_map: Dict[str, Optional[str]] = {
3995
+ '200': "OrganizationGpuQuotaResponse",
3996
+ '422': "HTTPValidationError",
3997
+ }
3998
+ response_data = self.api_client.call_api(
3999
+ *_param,
4000
+ _request_timeout=_request_timeout
4001
+ )
4002
+ response_data.read()
4003
+ return self.api_client.response_deserialize(
4004
+ response_data=response_data,
4005
+ response_types_map=_response_types_map,
4006
+ )
4007
+
4008
+
4009
+ @validate_call
4010
+ def delete_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_delete_without_preload_content(
4011
+ self,
4012
+ cluster_id: StrictInt,
4013
+ organization_id: StrictInt,
4014
+ _request_timeout: Union[
4015
+ None,
4016
+ Annotated[StrictFloat, Field(gt=0)],
4017
+ Tuple[
4018
+ Annotated[StrictFloat, Field(gt=0)],
4019
+ Annotated[StrictFloat, Field(gt=0)]
4020
+ ]
4021
+ ] = None,
4022
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
4023
+ _content_type: Optional[StrictStr] = None,
4024
+ _headers: Optional[Dict[StrictStr, Any]] = None,
4025
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4026
+ ) -> RESTResponseType:
4027
+ """Delete Org Gpu Quota On Cluster
4028
+
4029
+ Set persisted quota to unlimited (-1). Creates a row if none exists. Does not remove the row or the KAI Queue CR.
4030
+
4031
+ :param cluster_id: (required)
4032
+ :type cluster_id: int
4033
+ :param organization_id: (required)
4034
+ :type organization_id: int
4035
+ :param _request_timeout: timeout setting for this request. If one
4036
+ number provided, it will be total request
4037
+ timeout. It can also be a pair (tuple) of
4038
+ (connection, read) timeouts.
4039
+ :type _request_timeout: int, tuple(int, int), optional
4040
+ :param _request_auth: set to override the auth_settings for an a single
4041
+ request; this effectively ignores the
4042
+ authentication in the spec for a single request.
4043
+ :type _request_auth: dict, optional
4044
+ :param _content_type: force content-type for the request.
4045
+ :type _content_type: str, Optional
4046
+ :param _headers: set to override the headers for a single
4047
+ request; this effectively ignores the headers
4048
+ in the spec for a single request.
4049
+ :type _headers: dict, optional
4050
+ :param _host_index: set to override the host_index for a single
4051
+ request; this effectively ignores the host_index
4052
+ in the spec for a single request.
4053
+ :type _host_index: int, optional
4054
+ :return: Returns the result object.
4055
+ """ # noqa: E501
4056
+
4057
+ _param = self._delete_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_delete_serialize(
4058
+ cluster_id=cluster_id,
4059
+ organization_id=organization_id,
4060
+ _request_auth=_request_auth,
4061
+ _content_type=_content_type,
4062
+ _headers=_headers,
4063
+ _host_index=_host_index
4064
+ )
4065
+
4066
+ _response_types_map: Dict[str, Optional[str]] = {
4067
+ '200': "OrganizationGpuQuotaResponse",
4068
+ '422': "HTTPValidationError",
4069
+ }
4070
+ response_data = self.api_client.call_api(
4071
+ *_param,
4072
+ _request_timeout=_request_timeout
4073
+ )
4074
+ return response_data.response
4075
+
4076
+
4077
+ def _delete_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_delete_serialize(
4078
+ self,
4079
+ cluster_id,
4080
+ organization_id,
4081
+ _request_auth,
4082
+ _content_type,
4083
+ _headers,
4084
+ _host_index,
4085
+ ) -> RequestSerialized:
4086
+
4087
+ _host = None
4088
+
4089
+ _collection_formats: Dict[str, str] = {
4090
+ }
4091
+
4092
+ _path_params: Dict[str, str] = {}
4093
+ _query_params: List[Tuple[str, str]] = []
4094
+ _header_params: Dict[str, Optional[str]] = _headers or {}
4095
+ _form_params: List[Tuple[str, str]] = []
4096
+ _files: Dict[
4097
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
4098
+ ] = {}
4099
+ _body_params: Optional[bytes] = None
4100
+
4101
+ # process the path parameters
4102
+ if cluster_id is not None:
4103
+ _path_params['cluster_id'] = cluster_id
4104
+ if organization_id is not None:
4105
+ _path_params['organization_id'] = organization_id
4106
+ # process the query parameters
4107
+ # process the header parameters
4108
+ # process the form parameters
4109
+ # process the body parameter
4110
+
4111
+
4112
+ # set the HTTP header `Accept`
4113
+ if 'Accept' not in _header_params:
4114
+ _header_params['Accept'] = self.api_client.select_header_accept(
4115
+ [
4116
+ 'application/json'
4117
+ ]
4118
+ )
4119
+
4120
+
4121
+ # authentication setting
4122
+ _auth_settings: List[str] = [
4123
+ 'HTTPBearer'
4124
+ ]
4125
+
4126
+ return self.api_client.param_serialize(
4127
+ method='DELETE',
4128
+ resource_path='/clusters/{cluster_id}/organizations/{organization_id}/gpu-quota',
4129
+ path_params=_path_params,
4130
+ query_params=_query_params,
4131
+ header_params=_header_params,
4132
+ body=_body_params,
4133
+ post_params=_form_params,
4134
+ files=_files,
4135
+ auth_settings=_auth_settings,
4136
+ collection_formats=_collection_formats,
4137
+ _host=_host,
4138
+ _request_auth=_request_auth
4139
+ )
4140
+
4141
+
4142
+
4143
+
3862
4144
  @validate_call
3863
4145
  def delete_service_account_service_accounts_workos_id_delete(
3864
4146
  self,
@@ -6447,7 +6729,6 @@ class EXTERNALApi:
6447
6729
 
6448
6730
  # authentication setting
6449
6731
  _auth_settings: List[str] = [
6450
- 'HTTPBearer'
6451
6732
  ]
6452
6733
 
6453
6734
  return self.api_client.param_serialize(
@@ -7271,14 +7552,9 @@ class EXTERNALApi:
7271
7552
 
7272
7553
 
7273
7554
  @validate_call
7274
- def get_deployment_logs_deployments_logs_deployment_id_get(
7555
+ def get_current_org_gpu_quota_organizations_gpu_quota_get(
7275
7556
  self,
7276
- deployment_id: StrictInt,
7277
- start_time: StrictInt,
7278
- end_time: StrictInt,
7279
- next_page_token: Optional[StrictStr] = None,
7280
- start_from_head: Optional[StrictBool] = None,
7281
- line_count: Optional[StrictInt] = None,
7557
+ cluster_id: Optional[StrictInt] = None,
7282
7558
  _request_timeout: Union[
7283
7559
  None,
7284
7560
  Annotated[StrictFloat, Field(gt=0)],
@@ -7291,8 +7567,279 @@ class EXTERNALApi:
7291
7567
  _content_type: Optional[StrictStr] = None,
7292
7568
  _headers: Optional[Dict[StrictStr, Any]] = None,
7293
7569
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7294
- ) -> GetDeploymentLogResponse:
7295
- """Get Deployment Logs
7570
+ ) -> ListOrganizationGpuQuotaResponse:
7571
+ """Get Current Org Gpu Quota
7572
+
7573
+ Return persisted GPU quotas for the caller's organization. Usage fields come later. ``cluster_id`` filters to that cluster when it is visible. Unknown or invisible cluster IDs return an empty list rather than 404 so this member endpoint does not leak whether a cluster exists.
7574
+
7575
+ :param cluster_id:
7576
+ :type cluster_id: int
7577
+ :param _request_timeout: timeout setting for this request. If one
7578
+ number provided, it will be total request
7579
+ timeout. It can also be a pair (tuple) of
7580
+ (connection, read) timeouts.
7581
+ :type _request_timeout: int, tuple(int, int), optional
7582
+ :param _request_auth: set to override the auth_settings for an a single
7583
+ request; this effectively ignores the
7584
+ authentication in the spec for a single request.
7585
+ :type _request_auth: dict, optional
7586
+ :param _content_type: force content-type for the request.
7587
+ :type _content_type: str, Optional
7588
+ :param _headers: set to override the headers for a single
7589
+ request; this effectively ignores the headers
7590
+ in the spec for a single request.
7591
+ :type _headers: dict, optional
7592
+ :param _host_index: set to override the host_index for a single
7593
+ request; this effectively ignores the host_index
7594
+ in the spec for a single request.
7595
+ :type _host_index: int, optional
7596
+ :return: Returns the result object.
7597
+ """ # noqa: E501
7598
+
7599
+ _param = self._get_current_org_gpu_quota_organizations_gpu_quota_get_serialize(
7600
+ cluster_id=cluster_id,
7601
+ _request_auth=_request_auth,
7602
+ _content_type=_content_type,
7603
+ _headers=_headers,
7604
+ _host_index=_host_index
7605
+ )
7606
+
7607
+ _response_types_map: Dict[str, Optional[str]] = {
7608
+ '200': "ListOrganizationGpuQuotaResponse",
7609
+ '422': "HTTPValidationError",
7610
+ }
7611
+ response_data = self.api_client.call_api(
7612
+ *_param,
7613
+ _request_timeout=_request_timeout
7614
+ )
7615
+ response_data.read()
7616
+ return self.api_client.response_deserialize(
7617
+ response_data=response_data,
7618
+ response_types_map=_response_types_map,
7619
+ ).data
7620
+
7621
+
7622
+ @validate_call
7623
+ def get_current_org_gpu_quota_organizations_gpu_quota_get_with_http_info(
7624
+ self,
7625
+ cluster_id: Optional[StrictInt] = None,
7626
+ _request_timeout: Union[
7627
+ None,
7628
+ Annotated[StrictFloat, Field(gt=0)],
7629
+ Tuple[
7630
+ Annotated[StrictFloat, Field(gt=0)],
7631
+ Annotated[StrictFloat, Field(gt=0)]
7632
+ ]
7633
+ ] = None,
7634
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
7635
+ _content_type: Optional[StrictStr] = None,
7636
+ _headers: Optional[Dict[StrictStr, Any]] = None,
7637
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7638
+ ) -> ApiResponse[ListOrganizationGpuQuotaResponse]:
7639
+ """Get Current Org Gpu Quota
7640
+
7641
+ Return persisted GPU quotas for the caller's organization. Usage fields come later. ``cluster_id`` filters to that cluster when it is visible. Unknown or invisible cluster IDs return an empty list rather than 404 so this member endpoint does not leak whether a cluster exists.
7642
+
7643
+ :param cluster_id:
7644
+ :type cluster_id: int
7645
+ :param _request_timeout: timeout setting for this request. If one
7646
+ number provided, it will be total request
7647
+ timeout. It can also be a pair (tuple) of
7648
+ (connection, read) timeouts.
7649
+ :type _request_timeout: int, tuple(int, int), optional
7650
+ :param _request_auth: set to override the auth_settings for an a single
7651
+ request; this effectively ignores the
7652
+ authentication in the spec for a single request.
7653
+ :type _request_auth: dict, optional
7654
+ :param _content_type: force content-type for the request.
7655
+ :type _content_type: str, Optional
7656
+ :param _headers: set to override the headers for a single
7657
+ request; this effectively ignores the headers
7658
+ in the spec for a single request.
7659
+ :type _headers: dict, optional
7660
+ :param _host_index: set to override the host_index for a single
7661
+ request; this effectively ignores the host_index
7662
+ in the spec for a single request.
7663
+ :type _host_index: int, optional
7664
+ :return: Returns the result object.
7665
+ """ # noqa: E501
7666
+
7667
+ _param = self._get_current_org_gpu_quota_organizations_gpu_quota_get_serialize(
7668
+ cluster_id=cluster_id,
7669
+ _request_auth=_request_auth,
7670
+ _content_type=_content_type,
7671
+ _headers=_headers,
7672
+ _host_index=_host_index
7673
+ )
7674
+
7675
+ _response_types_map: Dict[str, Optional[str]] = {
7676
+ '200': "ListOrganizationGpuQuotaResponse",
7677
+ '422': "HTTPValidationError",
7678
+ }
7679
+ response_data = self.api_client.call_api(
7680
+ *_param,
7681
+ _request_timeout=_request_timeout
7682
+ )
7683
+ response_data.read()
7684
+ return self.api_client.response_deserialize(
7685
+ response_data=response_data,
7686
+ response_types_map=_response_types_map,
7687
+ )
7688
+
7689
+
7690
+ @validate_call
7691
+ def get_current_org_gpu_quota_organizations_gpu_quota_get_without_preload_content(
7692
+ self,
7693
+ cluster_id: Optional[StrictInt] = None,
7694
+ _request_timeout: Union[
7695
+ None,
7696
+ Annotated[StrictFloat, Field(gt=0)],
7697
+ Tuple[
7698
+ Annotated[StrictFloat, Field(gt=0)],
7699
+ Annotated[StrictFloat, Field(gt=0)]
7700
+ ]
7701
+ ] = None,
7702
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
7703
+ _content_type: Optional[StrictStr] = None,
7704
+ _headers: Optional[Dict[StrictStr, Any]] = None,
7705
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7706
+ ) -> RESTResponseType:
7707
+ """Get Current Org Gpu Quota
7708
+
7709
+ Return persisted GPU quotas for the caller's organization. Usage fields come later. ``cluster_id`` filters to that cluster when it is visible. Unknown or invisible cluster IDs return an empty list rather than 404 so this member endpoint does not leak whether a cluster exists.
7710
+
7711
+ :param cluster_id:
7712
+ :type cluster_id: int
7713
+ :param _request_timeout: timeout setting for this request. If one
7714
+ number provided, it will be total request
7715
+ timeout. It can also be a pair (tuple) of
7716
+ (connection, read) timeouts.
7717
+ :type _request_timeout: int, tuple(int, int), optional
7718
+ :param _request_auth: set to override the auth_settings for an a single
7719
+ request; this effectively ignores the
7720
+ authentication in the spec for a single request.
7721
+ :type _request_auth: dict, optional
7722
+ :param _content_type: force content-type for the request.
7723
+ :type _content_type: str, Optional
7724
+ :param _headers: set to override the headers for a single
7725
+ request; this effectively ignores the headers
7726
+ in the spec for a single request.
7727
+ :type _headers: dict, optional
7728
+ :param _host_index: set to override the host_index for a single
7729
+ request; this effectively ignores the host_index
7730
+ in the spec for a single request.
7731
+ :type _host_index: int, optional
7732
+ :return: Returns the result object.
7733
+ """ # noqa: E501
7734
+
7735
+ _param = self._get_current_org_gpu_quota_organizations_gpu_quota_get_serialize(
7736
+ cluster_id=cluster_id,
7737
+ _request_auth=_request_auth,
7738
+ _content_type=_content_type,
7739
+ _headers=_headers,
7740
+ _host_index=_host_index
7741
+ )
7742
+
7743
+ _response_types_map: Dict[str, Optional[str]] = {
7744
+ '200': "ListOrganizationGpuQuotaResponse",
7745
+ '422': "HTTPValidationError",
7746
+ }
7747
+ response_data = self.api_client.call_api(
7748
+ *_param,
7749
+ _request_timeout=_request_timeout
7750
+ )
7751
+ return response_data.response
7752
+
7753
+
7754
+ def _get_current_org_gpu_quota_organizations_gpu_quota_get_serialize(
7755
+ self,
7756
+ cluster_id,
7757
+ _request_auth,
7758
+ _content_type,
7759
+ _headers,
7760
+ _host_index,
7761
+ ) -> RequestSerialized:
7762
+
7763
+ _host = None
7764
+
7765
+ _collection_formats: Dict[str, str] = {
7766
+ }
7767
+
7768
+ _path_params: Dict[str, str] = {}
7769
+ _query_params: List[Tuple[str, str]] = []
7770
+ _header_params: Dict[str, Optional[str]] = _headers or {}
7771
+ _form_params: List[Tuple[str, str]] = []
7772
+ _files: Dict[
7773
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
7774
+ ] = {}
7775
+ _body_params: Optional[bytes] = None
7776
+
7777
+ # process the path parameters
7778
+ # process the query parameters
7779
+ if cluster_id is not None:
7780
+
7781
+ _query_params.append(('cluster_id', cluster_id))
7782
+
7783
+ # process the header parameters
7784
+ # process the form parameters
7785
+ # process the body parameter
7786
+
7787
+
7788
+ # set the HTTP header `Accept`
7789
+ if 'Accept' not in _header_params:
7790
+ _header_params['Accept'] = self.api_client.select_header_accept(
7791
+ [
7792
+ 'application/json'
7793
+ ]
7794
+ )
7795
+
7796
+
7797
+ # authentication setting
7798
+ _auth_settings: List[str] = [
7799
+ 'HTTPBearer'
7800
+ ]
7801
+
7802
+ return self.api_client.param_serialize(
7803
+ method='GET',
7804
+ resource_path='/organizations/gpu-quota',
7805
+ path_params=_path_params,
7806
+ query_params=_query_params,
7807
+ header_params=_header_params,
7808
+ body=_body_params,
7809
+ post_params=_form_params,
7810
+ files=_files,
7811
+ auth_settings=_auth_settings,
7812
+ collection_formats=_collection_formats,
7813
+ _host=_host,
7814
+ _request_auth=_request_auth
7815
+ )
7816
+
7817
+
7818
+
7819
+
7820
+ @validate_call
7821
+ def get_deployment_logs_deployments_logs_deployment_id_get(
7822
+ self,
7823
+ deployment_id: StrictInt,
7824
+ start_time: StrictInt,
7825
+ end_time: StrictInt,
7826
+ next_page_token: Optional[StrictStr] = None,
7827
+ start_from_head: Optional[StrictBool] = None,
7828
+ line_count: Optional[StrictInt] = None,
7829
+ _request_timeout: Union[
7830
+ None,
7831
+ Annotated[StrictFloat, Field(gt=0)],
7832
+ Tuple[
7833
+ Annotated[StrictFloat, Field(gt=0)],
7834
+ Annotated[StrictFloat, Field(gt=0)]
7835
+ ]
7836
+ ] = None,
7837
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
7838
+ _content_type: Optional[StrictStr] = None,
7839
+ _headers: Optional[Dict[StrictStr, Any]] = None,
7840
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7841
+ ) -> GetDeploymentLogResponse:
7842
+ """Get Deployment Logs
7296
7843
 
7297
7844
 
7298
7845
  :param deployment_id: (required)
@@ -10507,9 +11054,8 @@ class EXTERNALApi:
10507
11054
 
10508
11055
 
10509
11056
  @validate_call
10510
- def get_inference_deployment_deployments_inference_deployment_id_get(
11057
+ def get_hardware_presets_hardware_instances_presets_get(
10511
11058
  self,
10512
- deployment_id: StrictInt,
10513
11059
  _request_timeout: Union[
10514
11060
  None,
10515
11061
  Annotated[StrictFloat, Field(gt=0)],
@@ -10522,12 +11068,10 @@ class EXTERNALApi:
10522
11068
  _content_type: Optional[StrictStr] = None,
10523
11069
  _headers: Optional[Dict[StrictStr, Any]] = None,
10524
11070
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10525
- ) -> GetInferenceDeploymentResponse:
10526
- """Get Inference Deployment
11071
+ ) -> ListHardwarePresetResponse:
11072
+ """Get Hardware Presets
10527
11073
 
10528
11074
 
10529
- :param deployment_id: (required)
10530
- :type deployment_id: int
10531
11075
  :param _request_timeout: timeout setting for this request. If one
10532
11076
  number provided, it will be total request
10533
11077
  timeout. It can also be a pair (tuple) of
@@ -10550,8 +11094,7 @@ class EXTERNALApi:
10550
11094
  :return: Returns the result object.
10551
11095
  """ # noqa: E501
10552
11096
 
10553
- _param = self._get_inference_deployment_deployments_inference_deployment_id_get_serialize(
10554
- deployment_id=deployment_id,
11097
+ _param = self._get_hardware_presets_hardware_instances_presets_get_serialize(
10555
11098
  _request_auth=_request_auth,
10556
11099
  _content_type=_content_type,
10557
11100
  _headers=_headers,
@@ -10559,8 +11102,7 @@ class EXTERNALApi:
10559
11102
  )
10560
11103
 
10561
11104
  _response_types_map: Dict[str, Optional[str]] = {
10562
- '200': "GetInferenceDeploymentResponse",
10563
- '422': "HTTPValidationError",
11105
+ '200': "ListHardwarePresetResponse",
10564
11106
  }
10565
11107
  response_data = self.api_client.call_api(
10566
11108
  *_param,
@@ -10574,9 +11116,8 @@ class EXTERNALApi:
10574
11116
 
10575
11117
 
10576
11118
  @validate_call
10577
- def get_inference_deployment_deployments_inference_deployment_id_get_with_http_info(
11119
+ def get_hardware_presets_hardware_instances_presets_get_with_http_info(
10578
11120
  self,
10579
- deployment_id: StrictInt,
10580
11121
  _request_timeout: Union[
10581
11122
  None,
10582
11123
  Annotated[StrictFloat, Field(gt=0)],
@@ -10589,12 +11130,10 @@ class EXTERNALApi:
10589
11130
  _content_type: Optional[StrictStr] = None,
10590
11131
  _headers: Optional[Dict[StrictStr, Any]] = None,
10591
11132
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10592
- ) -> ApiResponse[GetInferenceDeploymentResponse]:
10593
- """Get Inference Deployment
11133
+ ) -> ApiResponse[ListHardwarePresetResponse]:
11134
+ """Get Hardware Presets
10594
11135
 
10595
11136
 
10596
- :param deployment_id: (required)
10597
- :type deployment_id: int
10598
11137
  :param _request_timeout: timeout setting for this request. If one
10599
11138
  number provided, it will be total request
10600
11139
  timeout. It can also be a pair (tuple) of
@@ -10617,8 +11156,7 @@ class EXTERNALApi:
10617
11156
  :return: Returns the result object.
10618
11157
  """ # noqa: E501
10619
11158
 
10620
- _param = self._get_inference_deployment_deployments_inference_deployment_id_get_serialize(
10621
- deployment_id=deployment_id,
11159
+ _param = self._get_hardware_presets_hardware_instances_presets_get_serialize(
10622
11160
  _request_auth=_request_auth,
10623
11161
  _content_type=_content_type,
10624
11162
  _headers=_headers,
@@ -10626,8 +11164,7 @@ class EXTERNALApi:
10626
11164
  )
10627
11165
 
10628
11166
  _response_types_map: Dict[str, Optional[str]] = {
10629
- '200': "GetInferenceDeploymentResponse",
10630
- '422': "HTTPValidationError",
11167
+ '200': "ListHardwarePresetResponse",
10631
11168
  }
10632
11169
  response_data = self.api_client.call_api(
10633
11170
  *_param,
@@ -10641,9 +11178,8 @@ class EXTERNALApi:
10641
11178
 
10642
11179
 
10643
11180
  @validate_call
10644
- def get_inference_deployment_deployments_inference_deployment_id_get_without_preload_content(
11181
+ def get_hardware_presets_hardware_instances_presets_get_without_preload_content(
10645
11182
  self,
10646
- deployment_id: StrictInt,
10647
11183
  _request_timeout: Union[
10648
11184
  None,
10649
11185
  Annotated[StrictFloat, Field(gt=0)],
@@ -10657,11 +11193,9 @@ class EXTERNALApi:
10657
11193
  _headers: Optional[Dict[StrictStr, Any]] = None,
10658
11194
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10659
11195
  ) -> RESTResponseType:
10660
- """Get Inference Deployment
11196
+ """Get Hardware Presets
10661
11197
 
10662
11198
 
10663
- :param deployment_id: (required)
10664
- :type deployment_id: int
10665
11199
  :param _request_timeout: timeout setting for this request. If one
10666
11200
  number provided, it will be total request
10667
11201
  timeout. It can also be a pair (tuple) of
@@ -10684,8 +11218,7 @@ class EXTERNALApi:
10684
11218
  :return: Returns the result object.
10685
11219
  """ # noqa: E501
10686
11220
 
10687
- _param = self._get_inference_deployment_deployments_inference_deployment_id_get_serialize(
10688
- deployment_id=deployment_id,
11221
+ _param = self._get_hardware_presets_hardware_instances_presets_get_serialize(
10689
11222
  _request_auth=_request_auth,
10690
11223
  _content_type=_content_type,
10691
11224
  _headers=_headers,
@@ -10693,8 +11226,7 @@ class EXTERNALApi:
10693
11226
  )
10694
11227
 
10695
11228
  _response_types_map: Dict[str, Optional[str]] = {
10696
- '200': "GetInferenceDeploymentResponse",
10697
- '422': "HTTPValidationError",
11229
+ '200': "ListHardwarePresetResponse",
10698
11230
  }
10699
11231
  response_data = self.api_client.call_api(
10700
11232
  *_param,
@@ -10703,9 +11235,8 @@ class EXTERNALApi:
10703
11235
  return response_data.response
10704
11236
 
10705
11237
 
10706
- def _get_inference_deployment_deployments_inference_deployment_id_get_serialize(
11238
+ def _get_hardware_presets_hardware_instances_presets_get_serialize(
10707
11239
  self,
10708
- deployment_id,
10709
11240
  _request_auth,
10710
11241
  _content_type,
10711
11242
  _headers,
@@ -10727,8 +11258,6 @@ class EXTERNALApi:
10727
11258
  _body_params: Optional[bytes] = None
10728
11259
 
10729
11260
  # process the path parameters
10730
- if deployment_id is not None:
10731
- _path_params['deployment_id'] = deployment_id
10732
11261
  # process the query parameters
10733
11262
  # process the header parameters
10734
11263
  # process the form parameters
@@ -10751,7 +11280,7 @@ class EXTERNALApi:
10751
11280
 
10752
11281
  return self.api_client.param_serialize(
10753
11282
  method='GET',
10754
- resource_path='/deployments/inference/{deployment_id}',
11283
+ resource_path='/hardware-instances/presets',
10755
11284
  path_params=_path_params,
10756
11285
  query_params=_query_params,
10757
11286
  header_params=_header_params,
@@ -10768,7 +11297,7 @@ class EXTERNALApi:
10768
11297
 
10769
11298
 
10770
11299
  @validate_call
10771
- def get_inference_v3_deployment_deployments_inference_v3_deployment_id_get(
11300
+ def get_inference_deployment_deployments_inference_deployment_id_get(
10772
11301
  self,
10773
11302
  deployment_id: StrictInt,
10774
11303
  _request_timeout: Union[
@@ -10783,8 +11312,8 @@ class EXTERNALApi:
10783
11312
  _content_type: Optional[StrictStr] = None,
10784
11313
  _headers: Optional[Dict[StrictStr, Any]] = None,
10785
11314
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10786
- ) -> GetInferenceV3DeploymentResponse:
10787
- """Get Inference V3 Deployment
11315
+ ) -> GetInferenceDeploymentResponse:
11316
+ """Get Inference Deployment
10788
11317
 
10789
11318
 
10790
11319
  :param deployment_id: (required)
@@ -10811,7 +11340,7 @@ class EXTERNALApi:
10811
11340
  :return: Returns the result object.
10812
11341
  """ # noqa: E501
10813
11342
 
10814
- _param = self._get_inference_v3_deployment_deployments_inference_v3_deployment_id_get_serialize(
11343
+ _param = self._get_inference_deployment_deployments_inference_deployment_id_get_serialize(
10815
11344
  deployment_id=deployment_id,
10816
11345
  _request_auth=_request_auth,
10817
11346
  _content_type=_content_type,
@@ -10820,7 +11349,7 @@ class EXTERNALApi:
10820
11349
  )
10821
11350
 
10822
11351
  _response_types_map: Dict[str, Optional[str]] = {
10823
- '200': "GetInferenceV3DeploymentResponse",
11352
+ '200': "GetInferenceDeploymentResponse",
10824
11353
  '422': "HTTPValidationError",
10825
11354
  }
10826
11355
  response_data = self.api_client.call_api(
@@ -10835,7 +11364,7 @@ class EXTERNALApi:
10835
11364
 
10836
11365
 
10837
11366
  @validate_call
10838
- def get_inference_v3_deployment_deployments_inference_v3_deployment_id_get_with_http_info(
11367
+ def get_inference_deployment_deployments_inference_deployment_id_get_with_http_info(
10839
11368
  self,
10840
11369
  deployment_id: StrictInt,
10841
11370
  _request_timeout: Union[
@@ -10850,8 +11379,8 @@ class EXTERNALApi:
10850
11379
  _content_type: Optional[StrictStr] = None,
10851
11380
  _headers: Optional[Dict[StrictStr, Any]] = None,
10852
11381
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10853
- ) -> ApiResponse[GetInferenceV3DeploymentResponse]:
10854
- """Get Inference V3 Deployment
11382
+ ) -> ApiResponse[GetInferenceDeploymentResponse]:
11383
+ """Get Inference Deployment
10855
11384
 
10856
11385
 
10857
11386
  :param deployment_id: (required)
@@ -10878,7 +11407,7 @@ class EXTERNALApi:
10878
11407
  :return: Returns the result object.
10879
11408
  """ # noqa: E501
10880
11409
 
10881
- _param = self._get_inference_v3_deployment_deployments_inference_v3_deployment_id_get_serialize(
11410
+ _param = self._get_inference_deployment_deployments_inference_deployment_id_get_serialize(
10882
11411
  deployment_id=deployment_id,
10883
11412
  _request_auth=_request_auth,
10884
11413
  _content_type=_content_type,
@@ -10887,7 +11416,7 @@ class EXTERNALApi:
10887
11416
  )
10888
11417
 
10889
11418
  _response_types_map: Dict[str, Optional[str]] = {
10890
- '200': "GetInferenceV3DeploymentResponse",
11419
+ '200': "GetInferenceDeploymentResponse",
10891
11420
  '422': "HTTPValidationError",
10892
11421
  }
10893
11422
  response_data = self.api_client.call_api(
@@ -10902,7 +11431,7 @@ class EXTERNALApi:
10902
11431
 
10903
11432
 
10904
11433
  @validate_call
10905
- def get_inference_v3_deployment_deployments_inference_v3_deployment_id_get_without_preload_content(
11434
+ def get_inference_deployment_deployments_inference_deployment_id_get_without_preload_content(
10906
11435
  self,
10907
11436
  deployment_id: StrictInt,
10908
11437
  _request_timeout: Union[
@@ -10918,7 +11447,7 @@ class EXTERNALApi:
10918
11447
  _headers: Optional[Dict[StrictStr, Any]] = None,
10919
11448
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10920
11449
  ) -> RESTResponseType:
10921
- """Get Inference V3 Deployment
11450
+ """Get Inference Deployment
10922
11451
 
10923
11452
 
10924
11453
  :param deployment_id: (required)
@@ -10945,7 +11474,7 @@ class EXTERNALApi:
10945
11474
  :return: Returns the result object.
10946
11475
  """ # noqa: E501
10947
11476
 
10948
- _param = self._get_inference_v3_deployment_deployments_inference_v3_deployment_id_get_serialize(
11477
+ _param = self._get_inference_deployment_deployments_inference_deployment_id_get_serialize(
10949
11478
  deployment_id=deployment_id,
10950
11479
  _request_auth=_request_auth,
10951
11480
  _content_type=_content_type,
@@ -10954,7 +11483,7 @@ class EXTERNALApi:
10954
11483
  )
10955
11484
 
10956
11485
  _response_types_map: Dict[str, Optional[str]] = {
10957
- '200': "GetInferenceV3DeploymentResponse",
11486
+ '200': "GetInferenceDeploymentResponse",
10958
11487
  '422': "HTTPValidationError",
10959
11488
  }
10960
11489
  response_data = self.api_client.call_api(
@@ -10964,7 +11493,7 @@ class EXTERNALApi:
10964
11493
  return response_data.response
10965
11494
 
10966
11495
 
10967
- def _get_inference_v3_deployment_deployments_inference_v3_deployment_id_get_serialize(
11496
+ def _get_inference_deployment_deployments_inference_deployment_id_get_serialize(
10968
11497
  self,
10969
11498
  deployment_id,
10970
11499
  _request_auth,
@@ -11012,7 +11541,7 @@ class EXTERNALApi:
11012
11541
 
11013
11542
  return self.api_client.param_serialize(
11014
11543
  method='GET',
11015
- resource_path='/deployments/inference_v3/{deployment_id}',
11544
+ resource_path='/deployments/inference/{deployment_id}',
11016
11545
  path_params=_path_params,
11017
11546
  query_params=_query_params,
11018
11547
  header_params=_header_params,
@@ -11029,7 +11558,7 @@ class EXTERNALApi:
11029
11558
 
11030
11559
 
11031
11560
  @validate_call
11032
- def get_job_deployment_deployments_job_deployment_id_get(
11561
+ def get_inference_v3_deployment_deployments_inference_v3_deployment_id_get(
11033
11562
  self,
11034
11563
  deployment_id: StrictInt,
11035
11564
  _request_timeout: Union[
@@ -11044,8 +11573,8 @@ class EXTERNALApi:
11044
11573
  _content_type: Optional[StrictStr] = None,
11045
11574
  _headers: Optional[Dict[StrictStr, Any]] = None,
11046
11575
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11047
- ) -> GetJobDeploymentResponse:
11048
- """Get Job Deployment
11576
+ ) -> GetInferenceV3DeploymentResponse:
11577
+ """Get Inference V3 Deployment
11049
11578
 
11050
11579
 
11051
11580
  :param deployment_id: (required)
@@ -11072,7 +11601,7 @@ class EXTERNALApi:
11072
11601
  :return: Returns the result object.
11073
11602
  """ # noqa: E501
11074
11603
 
11075
- _param = self._get_job_deployment_deployments_job_deployment_id_get_serialize(
11604
+ _param = self._get_inference_v3_deployment_deployments_inference_v3_deployment_id_get_serialize(
11076
11605
  deployment_id=deployment_id,
11077
11606
  _request_auth=_request_auth,
11078
11607
  _content_type=_content_type,
@@ -11081,7 +11610,7 @@ class EXTERNALApi:
11081
11610
  )
11082
11611
 
11083
11612
  _response_types_map: Dict[str, Optional[str]] = {
11084
- '200': "GetJobDeploymentResponse",
11613
+ '200': "GetInferenceV3DeploymentResponse",
11085
11614
  '422': "HTTPValidationError",
11086
11615
  }
11087
11616
  response_data = self.api_client.call_api(
@@ -11096,7 +11625,7 @@ class EXTERNALApi:
11096
11625
 
11097
11626
 
11098
11627
  @validate_call
11099
- def get_job_deployment_deployments_job_deployment_id_get_with_http_info(
11628
+ def get_inference_v3_deployment_deployments_inference_v3_deployment_id_get_with_http_info(
11100
11629
  self,
11101
11630
  deployment_id: StrictInt,
11102
11631
  _request_timeout: Union[
@@ -11111,8 +11640,8 @@ class EXTERNALApi:
11111
11640
  _content_type: Optional[StrictStr] = None,
11112
11641
  _headers: Optional[Dict[StrictStr, Any]] = None,
11113
11642
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11114
- ) -> ApiResponse[GetJobDeploymentResponse]:
11115
- """Get Job Deployment
11643
+ ) -> ApiResponse[GetInferenceV3DeploymentResponse]:
11644
+ """Get Inference V3 Deployment
11116
11645
 
11117
11646
 
11118
11647
  :param deployment_id: (required)
@@ -11139,7 +11668,7 @@ class EXTERNALApi:
11139
11668
  :return: Returns the result object.
11140
11669
  """ # noqa: E501
11141
11670
 
11142
- _param = self._get_job_deployment_deployments_job_deployment_id_get_serialize(
11671
+ _param = self._get_inference_v3_deployment_deployments_inference_v3_deployment_id_get_serialize(
11143
11672
  deployment_id=deployment_id,
11144
11673
  _request_auth=_request_auth,
11145
11674
  _content_type=_content_type,
@@ -11148,7 +11677,7 @@ class EXTERNALApi:
11148
11677
  )
11149
11678
 
11150
11679
  _response_types_map: Dict[str, Optional[str]] = {
11151
- '200': "GetJobDeploymentResponse",
11680
+ '200': "GetInferenceV3DeploymentResponse",
11152
11681
  '422': "HTTPValidationError",
11153
11682
  }
11154
11683
  response_data = self.api_client.call_api(
@@ -11163,7 +11692,7 @@ class EXTERNALApi:
11163
11692
 
11164
11693
 
11165
11694
  @validate_call
11166
- def get_job_deployment_deployments_job_deployment_id_get_without_preload_content(
11695
+ def get_inference_v3_deployment_deployments_inference_v3_deployment_id_get_without_preload_content(
11167
11696
  self,
11168
11697
  deployment_id: StrictInt,
11169
11698
  _request_timeout: Union[
@@ -11179,7 +11708,7 @@ class EXTERNALApi:
11179
11708
  _headers: Optional[Dict[StrictStr, Any]] = None,
11180
11709
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11181
11710
  ) -> RESTResponseType:
11182
- """Get Job Deployment
11711
+ """Get Inference V3 Deployment
11183
11712
 
11184
11713
 
11185
11714
  :param deployment_id: (required)
@@ -11206,7 +11735,7 @@ class EXTERNALApi:
11206
11735
  :return: Returns the result object.
11207
11736
  """ # noqa: E501
11208
11737
 
11209
- _param = self._get_job_deployment_deployments_job_deployment_id_get_serialize(
11738
+ _param = self._get_inference_v3_deployment_deployments_inference_v3_deployment_id_get_serialize(
11210
11739
  deployment_id=deployment_id,
11211
11740
  _request_auth=_request_auth,
11212
11741
  _content_type=_content_type,
@@ -11215,7 +11744,7 @@ class EXTERNALApi:
11215
11744
  )
11216
11745
 
11217
11746
  _response_types_map: Dict[str, Optional[str]] = {
11218
- '200': "GetJobDeploymentResponse",
11747
+ '200': "GetInferenceV3DeploymentResponse",
11219
11748
  '422': "HTTPValidationError",
11220
11749
  }
11221
11750
  response_data = self.api_client.call_api(
@@ -11225,7 +11754,7 @@ class EXTERNALApi:
11225
11754
  return response_data.response
11226
11755
 
11227
11756
 
11228
- def _get_job_deployment_deployments_job_deployment_id_get_serialize(
11757
+ def _get_inference_v3_deployment_deployments_inference_v3_deployment_id_get_serialize(
11229
11758
  self,
11230
11759
  deployment_id,
11231
11760
  _request_auth,
@@ -11273,7 +11802,7 @@ class EXTERNALApi:
11273
11802
 
11274
11803
  return self.api_client.param_serialize(
11275
11804
  method='GET',
11276
- resource_path='/deployments/job/{deployment_id}',
11805
+ resource_path='/deployments/inference_v3/{deployment_id}',
11277
11806
  path_params=_path_params,
11278
11807
  query_params=_query_params,
11279
11808
  header_params=_header_params,
@@ -11290,9 +11819,9 @@ class EXTERNALApi:
11290
11819
 
11291
11820
 
11292
11821
  @validate_call
11293
- def get_prebuilt_images_prebuilt_images_get(
11822
+ def get_job_deployment_deployments_job_deployment_id_get(
11294
11823
  self,
11295
- type: Optional[DeploymentType] = None,
11824
+ deployment_id: StrictInt,
11296
11825
  _request_timeout: Union[
11297
11826
  None,
11298
11827
  Annotated[StrictFloat, Field(gt=0)],
@@ -11305,12 +11834,12 @@ class EXTERNALApi:
11305
11834
  _content_type: Optional[StrictStr] = None,
11306
11835
  _headers: Optional[Dict[StrictStr, Any]] = None,
11307
11836
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11308
- ) -> ListPrebuiltImageResponse:
11309
- """Get Prebuilt Images
11837
+ ) -> GetJobDeploymentResponse:
11838
+ """Get Job Deployment
11310
11839
 
11311
11840
 
11312
- :param type:
11313
- :type type: DeploymentType
11841
+ :param deployment_id: (required)
11842
+ :type deployment_id: int
11314
11843
  :param _request_timeout: timeout setting for this request. If one
11315
11844
  number provided, it will be total request
11316
11845
  timeout. It can also be a pair (tuple) of
@@ -11333,8 +11862,8 @@ class EXTERNALApi:
11333
11862
  :return: Returns the result object.
11334
11863
  """ # noqa: E501
11335
11864
 
11336
- _param = self._get_prebuilt_images_prebuilt_images_get_serialize(
11337
- type=type,
11865
+ _param = self._get_job_deployment_deployments_job_deployment_id_get_serialize(
11866
+ deployment_id=deployment_id,
11338
11867
  _request_auth=_request_auth,
11339
11868
  _content_type=_content_type,
11340
11869
  _headers=_headers,
@@ -11342,7 +11871,7 @@ class EXTERNALApi:
11342
11871
  )
11343
11872
 
11344
11873
  _response_types_map: Dict[str, Optional[str]] = {
11345
- '200': "ListPrebuiltImageResponse",
11874
+ '200': "GetJobDeploymentResponse",
11346
11875
  '422': "HTTPValidationError",
11347
11876
  }
11348
11877
  response_data = self.api_client.call_api(
@@ -11357,9 +11886,9 @@ class EXTERNALApi:
11357
11886
 
11358
11887
 
11359
11888
  @validate_call
11360
- def get_prebuilt_images_prebuilt_images_get_with_http_info(
11889
+ def get_job_deployment_deployments_job_deployment_id_get_with_http_info(
11361
11890
  self,
11362
- type: Optional[DeploymentType] = None,
11891
+ deployment_id: StrictInt,
11363
11892
  _request_timeout: Union[
11364
11893
  None,
11365
11894
  Annotated[StrictFloat, Field(gt=0)],
@@ -11372,12 +11901,12 @@ class EXTERNALApi:
11372
11901
  _content_type: Optional[StrictStr] = None,
11373
11902
  _headers: Optional[Dict[StrictStr, Any]] = None,
11374
11903
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11375
- ) -> ApiResponse[ListPrebuiltImageResponse]:
11376
- """Get Prebuilt Images
11904
+ ) -> ApiResponse[GetJobDeploymentResponse]:
11905
+ """Get Job Deployment
11377
11906
 
11378
11907
 
11379
- :param type:
11380
- :type type: DeploymentType
11908
+ :param deployment_id: (required)
11909
+ :type deployment_id: int
11381
11910
  :param _request_timeout: timeout setting for this request. If one
11382
11911
  number provided, it will be total request
11383
11912
  timeout. It can also be a pair (tuple) of
@@ -11400,8 +11929,8 @@ class EXTERNALApi:
11400
11929
  :return: Returns the result object.
11401
11930
  """ # noqa: E501
11402
11931
 
11403
- _param = self._get_prebuilt_images_prebuilt_images_get_serialize(
11404
- type=type,
11932
+ _param = self._get_job_deployment_deployments_job_deployment_id_get_serialize(
11933
+ deployment_id=deployment_id,
11405
11934
  _request_auth=_request_auth,
11406
11935
  _content_type=_content_type,
11407
11936
  _headers=_headers,
@@ -11409,7 +11938,7 @@ class EXTERNALApi:
11409
11938
  )
11410
11939
 
11411
11940
  _response_types_map: Dict[str, Optional[str]] = {
11412
- '200': "ListPrebuiltImageResponse",
11941
+ '200': "GetJobDeploymentResponse",
11413
11942
  '422': "HTTPValidationError",
11414
11943
  }
11415
11944
  response_data = self.api_client.call_api(
@@ -11424,9 +11953,9 @@ class EXTERNALApi:
11424
11953
 
11425
11954
 
11426
11955
  @validate_call
11427
- def get_prebuilt_images_prebuilt_images_get_without_preload_content(
11956
+ def get_job_deployment_deployments_job_deployment_id_get_without_preload_content(
11428
11957
  self,
11429
- type: Optional[DeploymentType] = None,
11958
+ deployment_id: StrictInt,
11430
11959
  _request_timeout: Union[
11431
11960
  None,
11432
11961
  Annotated[StrictFloat, Field(gt=0)],
@@ -11440,11 +11969,11 @@ class EXTERNALApi:
11440
11969
  _headers: Optional[Dict[StrictStr, Any]] = None,
11441
11970
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11442
11971
  ) -> RESTResponseType:
11443
- """Get Prebuilt Images
11972
+ """Get Job Deployment
11444
11973
 
11445
11974
 
11446
- :param type:
11447
- :type type: DeploymentType
11975
+ :param deployment_id: (required)
11976
+ :type deployment_id: int
11448
11977
  :param _request_timeout: timeout setting for this request. If one
11449
11978
  number provided, it will be total request
11450
11979
  timeout. It can also be a pair (tuple) of
@@ -11467,8 +11996,8 @@ class EXTERNALApi:
11467
11996
  :return: Returns the result object.
11468
11997
  """ # noqa: E501
11469
11998
 
11470
- _param = self._get_prebuilt_images_prebuilt_images_get_serialize(
11471
- type=type,
11999
+ _param = self._get_job_deployment_deployments_job_deployment_id_get_serialize(
12000
+ deployment_id=deployment_id,
11472
12001
  _request_auth=_request_auth,
11473
12002
  _content_type=_content_type,
11474
12003
  _headers=_headers,
@@ -11476,7 +12005,7 @@ class EXTERNALApi:
11476
12005
  )
11477
12006
 
11478
12007
  _response_types_map: Dict[str, Optional[str]] = {
11479
- '200': "ListPrebuiltImageResponse",
12008
+ '200': "GetJobDeploymentResponse",
11480
12009
  '422': "HTTPValidationError",
11481
12010
  }
11482
12011
  response_data = self.api_client.call_api(
@@ -11486,9 +12015,9 @@ class EXTERNALApi:
11486
12015
  return response_data.response
11487
12016
 
11488
12017
 
11489
- def _get_prebuilt_images_prebuilt_images_get_serialize(
12018
+ def _get_job_deployment_deployments_job_deployment_id_get_serialize(
11490
12019
  self,
11491
- type,
12020
+ deployment_id,
11492
12021
  _request_auth,
11493
12022
  _content_type,
11494
12023
  _headers,
@@ -11510,11 +12039,9 @@ class EXTERNALApi:
11510
12039
  _body_params: Optional[bytes] = None
11511
12040
 
11512
12041
  # process the path parameters
12042
+ if deployment_id is not None:
12043
+ _path_params['deployment_id'] = deployment_id
11513
12044
  # process the query parameters
11514
- if type is not None:
11515
-
11516
- _query_params.append(('type', type.value))
11517
-
11518
12045
  # process the header parameters
11519
12046
  # process the form parameters
11520
12047
  # process the body parameter
@@ -11536,7 +12063,7 @@ class EXTERNALApi:
11536
12063
 
11537
12064
  return self.api_client.param_serialize(
11538
12065
  method='GET',
11539
- resource_path='/prebuilt-images',
12066
+ resource_path='/deployments/job/{deployment_id}',
11540
12067
  path_params=_path_params,
11541
12068
  query_params=_query_params,
11542
12069
  header_params=_header_params,
@@ -11553,10 +12080,10 @@ class EXTERNALApi:
11553
12080
 
11554
12081
 
11555
12082
  @validate_call
11556
- def get_usage_daily_bills_get(
12083
+ def get_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_get(
11557
12084
  self,
11558
- start_date: date,
11559
- end_date: date,
12085
+ cluster_id: StrictInt,
12086
+ organization_id: StrictInt,
11560
12087
  _request_timeout: Union[
11561
12088
  None,
11562
12089
  Annotated[StrictFloat, Field(gt=0)],
@@ -11569,14 +12096,14 @@ class EXTERNALApi:
11569
12096
  _content_type: Optional[StrictStr] = None,
11570
12097
  _headers: Optional[Dict[StrictStr, Any]] = None,
11571
12098
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11572
- ) -> ListDailyBillResponse:
11573
- """(Deprecated) Get Usage
12099
+ ) -> OrganizationGpuQuotaResponse:
12100
+ """Get Org Gpu Quota On Cluster
11574
12101
 
11575
12102
 
11576
- :param start_date: (required)
11577
- :type start_date: date
11578
- :param end_date: (required)
11579
- :type end_date: date
12103
+ :param cluster_id: (required)
12104
+ :type cluster_id: int
12105
+ :param organization_id: (required)
12106
+ :type organization_id: int
11580
12107
  :param _request_timeout: timeout setting for this request. If one
11581
12108
  number provided, it will be total request
11582
12109
  timeout. It can also be a pair (tuple) of
@@ -11598,11 +12125,10 @@ class EXTERNALApi:
11598
12125
  :type _host_index: int, optional
11599
12126
  :return: Returns the result object.
11600
12127
  """ # noqa: E501
11601
- warnings.warn("GET /daily_bills is deprecated.", DeprecationWarning)
11602
12128
 
11603
- _param = self._get_usage_daily_bills_get_serialize(
11604
- start_date=start_date,
11605
- end_date=end_date,
12129
+ _param = self._get_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_get_serialize(
12130
+ cluster_id=cluster_id,
12131
+ organization_id=organization_id,
11606
12132
  _request_auth=_request_auth,
11607
12133
  _content_type=_content_type,
11608
12134
  _headers=_headers,
@@ -11610,7 +12136,7 @@ class EXTERNALApi:
11610
12136
  )
11611
12137
 
11612
12138
  _response_types_map: Dict[str, Optional[str]] = {
11613
- '200': "ListDailyBillResponse",
12139
+ '200': "OrganizationGpuQuotaResponse",
11614
12140
  '422': "HTTPValidationError",
11615
12141
  }
11616
12142
  response_data = self.api_client.call_api(
@@ -11625,10 +12151,10 @@ class EXTERNALApi:
11625
12151
 
11626
12152
 
11627
12153
  @validate_call
11628
- def get_usage_daily_bills_get_with_http_info(
12154
+ def get_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_get_with_http_info(
11629
12155
  self,
11630
- start_date: date,
11631
- end_date: date,
12156
+ cluster_id: StrictInt,
12157
+ organization_id: StrictInt,
11632
12158
  _request_timeout: Union[
11633
12159
  None,
11634
12160
  Annotated[StrictFloat, Field(gt=0)],
@@ -11641,14 +12167,14 @@ class EXTERNALApi:
11641
12167
  _content_type: Optional[StrictStr] = None,
11642
12168
  _headers: Optional[Dict[StrictStr, Any]] = None,
11643
12169
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11644
- ) -> ApiResponse[ListDailyBillResponse]:
11645
- """(Deprecated) Get Usage
12170
+ ) -> ApiResponse[OrganizationGpuQuotaResponse]:
12171
+ """Get Org Gpu Quota On Cluster
11646
12172
 
11647
12173
 
11648
- :param start_date: (required)
11649
- :type start_date: date
11650
- :param end_date: (required)
11651
- :type end_date: date
12174
+ :param cluster_id: (required)
12175
+ :type cluster_id: int
12176
+ :param organization_id: (required)
12177
+ :type organization_id: int
11652
12178
  :param _request_timeout: timeout setting for this request. If one
11653
12179
  number provided, it will be total request
11654
12180
  timeout. It can also be a pair (tuple) of
@@ -11670,11 +12196,10 @@ class EXTERNALApi:
11670
12196
  :type _host_index: int, optional
11671
12197
  :return: Returns the result object.
11672
12198
  """ # noqa: E501
11673
- warnings.warn("GET /daily_bills is deprecated.", DeprecationWarning)
11674
12199
 
11675
- _param = self._get_usage_daily_bills_get_serialize(
11676
- start_date=start_date,
11677
- end_date=end_date,
12200
+ _param = self._get_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_get_serialize(
12201
+ cluster_id=cluster_id,
12202
+ organization_id=organization_id,
11678
12203
  _request_auth=_request_auth,
11679
12204
  _content_type=_content_type,
11680
12205
  _headers=_headers,
@@ -11682,7 +12207,7 @@ class EXTERNALApi:
11682
12207
  )
11683
12208
 
11684
12209
  _response_types_map: Dict[str, Optional[str]] = {
11685
- '200': "ListDailyBillResponse",
12210
+ '200': "OrganizationGpuQuotaResponse",
11686
12211
  '422': "HTTPValidationError",
11687
12212
  }
11688
12213
  response_data = self.api_client.call_api(
@@ -11697,10 +12222,10 @@ class EXTERNALApi:
11697
12222
 
11698
12223
 
11699
12224
  @validate_call
11700
- def get_usage_daily_bills_get_without_preload_content(
12225
+ def get_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_get_without_preload_content(
11701
12226
  self,
11702
- start_date: date,
11703
- end_date: date,
12227
+ cluster_id: StrictInt,
12228
+ organization_id: StrictInt,
11704
12229
  _request_timeout: Union[
11705
12230
  None,
11706
12231
  Annotated[StrictFloat, Field(gt=0)],
@@ -11714,13 +12239,13 @@ class EXTERNALApi:
11714
12239
  _headers: Optional[Dict[StrictStr, Any]] = None,
11715
12240
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11716
12241
  ) -> RESTResponseType:
11717
- """(Deprecated) Get Usage
12242
+ """Get Org Gpu Quota On Cluster
11718
12243
 
11719
12244
 
11720
- :param start_date: (required)
11721
- :type start_date: date
11722
- :param end_date: (required)
11723
- :type end_date: date
12245
+ :param cluster_id: (required)
12246
+ :type cluster_id: int
12247
+ :param organization_id: (required)
12248
+ :type organization_id: int
11724
12249
  :param _request_timeout: timeout setting for this request. If one
11725
12250
  number provided, it will be total request
11726
12251
  timeout. It can also be a pair (tuple) of
@@ -11742,11 +12267,10 @@ class EXTERNALApi:
11742
12267
  :type _host_index: int, optional
11743
12268
  :return: Returns the result object.
11744
12269
  """ # noqa: E501
11745
- warnings.warn("GET /daily_bills is deprecated.", DeprecationWarning)
11746
12270
 
11747
- _param = self._get_usage_daily_bills_get_serialize(
11748
- start_date=start_date,
11749
- end_date=end_date,
12271
+ _param = self._get_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_get_serialize(
12272
+ cluster_id=cluster_id,
12273
+ organization_id=organization_id,
11750
12274
  _request_auth=_request_auth,
11751
12275
  _content_type=_content_type,
11752
12276
  _headers=_headers,
@@ -11754,7 +12278,7 @@ class EXTERNALApi:
11754
12278
  )
11755
12279
 
11756
12280
  _response_types_map: Dict[str, Optional[str]] = {
11757
- '200': "ListDailyBillResponse",
12281
+ '200': "OrganizationGpuQuotaResponse",
11758
12282
  '422': "HTTPValidationError",
11759
12283
  }
11760
12284
  response_data = self.api_client.call_api(
@@ -11764,10 +12288,10 @@ class EXTERNALApi:
11764
12288
  return response_data.response
11765
12289
 
11766
12290
 
11767
- def _get_usage_daily_bills_get_serialize(
12291
+ def _get_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_get_serialize(
11768
12292
  self,
11769
- start_date,
11770
- end_date,
12293
+ cluster_id,
12294
+ organization_id,
11771
12295
  _request_auth,
11772
12296
  _content_type,
11773
12297
  _headers,
@@ -11789,33 +12313,11 @@ class EXTERNALApi:
11789
12313
  _body_params: Optional[bytes] = None
11790
12314
 
11791
12315
  # process the path parameters
12316
+ if cluster_id is not None:
12317
+ _path_params['cluster_id'] = cluster_id
12318
+ if organization_id is not None:
12319
+ _path_params['organization_id'] = organization_id
11792
12320
  # process the query parameters
11793
- if start_date is not None:
11794
- if isinstance(start_date, date):
11795
- _query_params.append(
11796
- (
11797
- 'start_date',
11798
- start_date.strftime(
11799
- self.api_client.configuration.date_format
11800
- )
11801
- )
11802
- )
11803
- else:
11804
- _query_params.append(('start_date', start_date))
11805
-
11806
- if end_date is not None:
11807
- if isinstance(end_date, date):
11808
- _query_params.append(
11809
- (
11810
- 'end_date',
11811
- end_date.strftime(
11812
- self.api_client.configuration.date_format
11813
- )
11814
- )
11815
- )
11816
- else:
11817
- _query_params.append(('end_date', end_date))
11818
-
11819
12321
  # process the header parameters
11820
12322
  # process the form parameters
11821
12323
  # process the body parameter
@@ -11837,7 +12339,7 @@ class EXTERNALApi:
11837
12339
 
11838
12340
  return self.api_client.param_serialize(
11839
12341
  method='GET',
11840
- resource_path='/daily_bills',
12342
+ resource_path='/clusters/{cluster_id}/organizations/{organization_id}/gpu-quota',
11841
12343
  path_params=_path_params,
11842
12344
  query_params=_query_params,
11843
12345
  header_params=_header_params,
@@ -11854,13 +12356,9 @@ class EXTERNALApi:
11854
12356
 
11855
12357
 
11856
12358
  @validate_call
11857
- def get_usage_deployments_usage_deployment_id_get(
12359
+ def get_prebuilt_images_prebuilt_images_get(
11858
12360
  self,
11859
- deployment_id: StrictInt,
11860
- metric: Metric,
11861
- start_time_in_seconds: StrictInt,
11862
- end_time_in_seconds: StrictInt,
11863
- step: Optional[StrictInt] = None,
12361
+ type: Optional[DeploymentType] = None,
11864
12362
  _request_timeout: Union[
11865
12363
  None,
11866
12364
  Annotated[StrictFloat, Field(gt=0)],
@@ -11873,20 +12371,12 @@ class EXTERNALApi:
11873
12371
  _content_type: Optional[StrictStr] = None,
11874
12372
  _headers: Optional[Dict[StrictStr, Any]] = None,
11875
12373
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11876
- ) -> GetDeploymentUsageResponse:
11877
- """Get Usage
12374
+ ) -> ListPrebuiltImageResponse:
12375
+ """Get Prebuilt Images
11878
12376
 
11879
12377
 
11880
- :param deployment_id: (required)
11881
- :type deployment_id: int
11882
- :param metric: (required)
11883
- :type metric: Metric
11884
- :param start_time_in_seconds: (required)
11885
- :type start_time_in_seconds: int
11886
- :param end_time_in_seconds: (required)
11887
- :type end_time_in_seconds: int
11888
- :param step:
11889
- :type step: int
12378
+ :param type:
12379
+ :type type: DeploymentType
11890
12380
  :param _request_timeout: timeout setting for this request. If one
11891
12381
  number provided, it will be total request
11892
12382
  timeout. It can also be a pair (tuple) of
@@ -11909,12 +12399,8 @@ class EXTERNALApi:
11909
12399
  :return: Returns the result object.
11910
12400
  """ # noqa: E501
11911
12401
 
11912
- _param = self._get_usage_deployments_usage_deployment_id_get_serialize(
11913
- deployment_id=deployment_id,
11914
- metric=metric,
11915
- start_time_in_seconds=start_time_in_seconds,
11916
- end_time_in_seconds=end_time_in_seconds,
11917
- step=step,
12402
+ _param = self._get_prebuilt_images_prebuilt_images_get_serialize(
12403
+ type=type,
11918
12404
  _request_auth=_request_auth,
11919
12405
  _content_type=_content_type,
11920
12406
  _headers=_headers,
@@ -11922,7 +12408,7 @@ class EXTERNALApi:
11922
12408
  )
11923
12409
 
11924
12410
  _response_types_map: Dict[str, Optional[str]] = {
11925
- '200': "GetDeploymentUsageResponse",
12411
+ '200': "ListPrebuiltImageResponse",
11926
12412
  '422': "HTTPValidationError",
11927
12413
  }
11928
12414
  response_data = self.api_client.call_api(
@@ -11937,13 +12423,9 @@ class EXTERNALApi:
11937
12423
 
11938
12424
 
11939
12425
  @validate_call
11940
- def get_usage_deployments_usage_deployment_id_get_with_http_info(
12426
+ def get_prebuilt_images_prebuilt_images_get_with_http_info(
11941
12427
  self,
11942
- deployment_id: StrictInt,
11943
- metric: Metric,
11944
- start_time_in_seconds: StrictInt,
11945
- end_time_in_seconds: StrictInt,
11946
- step: Optional[StrictInt] = None,
12428
+ type: Optional[DeploymentType] = None,
11947
12429
  _request_timeout: Union[
11948
12430
  None,
11949
12431
  Annotated[StrictFloat, Field(gt=0)],
@@ -11956,21 +12438,1116 @@ class EXTERNALApi:
11956
12438
  _content_type: Optional[StrictStr] = None,
11957
12439
  _headers: Optional[Dict[StrictStr, Any]] = None,
11958
12440
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11959
- ) -> ApiResponse[GetDeploymentUsageResponse]:
11960
- """Get Usage
12441
+ ) -> ApiResponse[ListPrebuiltImageResponse]:
12442
+ """Get Prebuilt Images
11961
12443
 
11962
12444
 
11963
- :param deployment_id: (required)
11964
- :type deployment_id: int
11965
- :param metric: (required)
11966
- :type metric: Metric
11967
- :param start_time_in_seconds: (required)
11968
- :type start_time_in_seconds: int
11969
- :param end_time_in_seconds: (required)
11970
- :type end_time_in_seconds: int
11971
- :param step:
11972
- :type step: int
11973
- :param _request_timeout: timeout setting for this request. If one
12445
+ :param type:
12446
+ :type type: DeploymentType
12447
+ :param _request_timeout: timeout setting for this request. If one
12448
+ number provided, it will be total request
12449
+ timeout. It can also be a pair (tuple) of
12450
+ (connection, read) timeouts.
12451
+ :type _request_timeout: int, tuple(int, int), optional
12452
+ :param _request_auth: set to override the auth_settings for an a single
12453
+ request; this effectively ignores the
12454
+ authentication in the spec for a single request.
12455
+ :type _request_auth: dict, optional
12456
+ :param _content_type: force content-type for the request.
12457
+ :type _content_type: str, Optional
12458
+ :param _headers: set to override the headers for a single
12459
+ request; this effectively ignores the headers
12460
+ in the spec for a single request.
12461
+ :type _headers: dict, optional
12462
+ :param _host_index: set to override the host_index for a single
12463
+ request; this effectively ignores the host_index
12464
+ in the spec for a single request.
12465
+ :type _host_index: int, optional
12466
+ :return: Returns the result object.
12467
+ """ # noqa: E501
12468
+
12469
+ _param = self._get_prebuilt_images_prebuilt_images_get_serialize(
12470
+ type=type,
12471
+ _request_auth=_request_auth,
12472
+ _content_type=_content_type,
12473
+ _headers=_headers,
12474
+ _host_index=_host_index
12475
+ )
12476
+
12477
+ _response_types_map: Dict[str, Optional[str]] = {
12478
+ '200': "ListPrebuiltImageResponse",
12479
+ '422': "HTTPValidationError",
12480
+ }
12481
+ response_data = self.api_client.call_api(
12482
+ *_param,
12483
+ _request_timeout=_request_timeout
12484
+ )
12485
+ response_data.read()
12486
+ return self.api_client.response_deserialize(
12487
+ response_data=response_data,
12488
+ response_types_map=_response_types_map,
12489
+ )
12490
+
12491
+
12492
+ @validate_call
12493
+ def get_prebuilt_images_prebuilt_images_get_without_preload_content(
12494
+ self,
12495
+ type: Optional[DeploymentType] = None,
12496
+ _request_timeout: Union[
12497
+ None,
12498
+ Annotated[StrictFloat, Field(gt=0)],
12499
+ Tuple[
12500
+ Annotated[StrictFloat, Field(gt=0)],
12501
+ Annotated[StrictFloat, Field(gt=0)]
12502
+ ]
12503
+ ] = None,
12504
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
12505
+ _content_type: Optional[StrictStr] = None,
12506
+ _headers: Optional[Dict[StrictStr, Any]] = None,
12507
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12508
+ ) -> RESTResponseType:
12509
+ """Get Prebuilt Images
12510
+
12511
+
12512
+ :param type:
12513
+ :type type: DeploymentType
12514
+ :param _request_timeout: timeout setting for this request. If one
12515
+ number provided, it will be total request
12516
+ timeout. It can also be a pair (tuple) of
12517
+ (connection, read) timeouts.
12518
+ :type _request_timeout: int, tuple(int, int), optional
12519
+ :param _request_auth: set to override the auth_settings for an a single
12520
+ request; this effectively ignores the
12521
+ authentication in the spec for a single request.
12522
+ :type _request_auth: dict, optional
12523
+ :param _content_type: force content-type for the request.
12524
+ :type _content_type: str, Optional
12525
+ :param _headers: set to override the headers for a single
12526
+ request; this effectively ignores the headers
12527
+ in the spec for a single request.
12528
+ :type _headers: dict, optional
12529
+ :param _host_index: set to override the host_index for a single
12530
+ request; this effectively ignores the host_index
12531
+ in the spec for a single request.
12532
+ :type _host_index: int, optional
12533
+ :return: Returns the result object.
12534
+ """ # noqa: E501
12535
+
12536
+ _param = self._get_prebuilt_images_prebuilt_images_get_serialize(
12537
+ type=type,
12538
+ _request_auth=_request_auth,
12539
+ _content_type=_content_type,
12540
+ _headers=_headers,
12541
+ _host_index=_host_index
12542
+ )
12543
+
12544
+ _response_types_map: Dict[str, Optional[str]] = {
12545
+ '200': "ListPrebuiltImageResponse",
12546
+ '422': "HTTPValidationError",
12547
+ }
12548
+ response_data = self.api_client.call_api(
12549
+ *_param,
12550
+ _request_timeout=_request_timeout
12551
+ )
12552
+ return response_data.response
12553
+
12554
+
12555
+ def _get_prebuilt_images_prebuilt_images_get_serialize(
12556
+ self,
12557
+ type,
12558
+ _request_auth,
12559
+ _content_type,
12560
+ _headers,
12561
+ _host_index,
12562
+ ) -> RequestSerialized:
12563
+
12564
+ _host = None
12565
+
12566
+ _collection_formats: Dict[str, str] = {
12567
+ }
12568
+
12569
+ _path_params: Dict[str, str] = {}
12570
+ _query_params: List[Tuple[str, str]] = []
12571
+ _header_params: Dict[str, Optional[str]] = _headers or {}
12572
+ _form_params: List[Tuple[str, str]] = []
12573
+ _files: Dict[
12574
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
12575
+ ] = {}
12576
+ _body_params: Optional[bytes] = None
12577
+
12578
+ # process the path parameters
12579
+ # process the query parameters
12580
+ if type is not None:
12581
+
12582
+ _query_params.append(('type', type.value))
12583
+
12584
+ # process the header parameters
12585
+ # process the form parameters
12586
+ # process the body parameter
12587
+
12588
+
12589
+ # set the HTTP header `Accept`
12590
+ if 'Accept' not in _header_params:
12591
+ _header_params['Accept'] = self.api_client.select_header_accept(
12592
+ [
12593
+ 'application/json'
12594
+ ]
12595
+ )
12596
+
12597
+
12598
+ # authentication setting
12599
+ _auth_settings: List[str] = [
12600
+ 'HTTPBearer'
12601
+ ]
12602
+
12603
+ return self.api_client.param_serialize(
12604
+ method='GET',
12605
+ resource_path='/prebuilt-images',
12606
+ path_params=_path_params,
12607
+ query_params=_query_params,
12608
+ header_params=_header_params,
12609
+ body=_body_params,
12610
+ post_params=_form_params,
12611
+ files=_files,
12612
+ auth_settings=_auth_settings,
12613
+ collection_formats=_collection_formats,
12614
+ _host=_host,
12615
+ _request_auth=_request_auth
12616
+ )
12617
+
12618
+
12619
+
12620
+
12621
+ @validate_call
12622
+ def get_usage_daily_bills_get(
12623
+ self,
12624
+ _request_timeout: Union[
12625
+ None,
12626
+ Annotated[StrictFloat, Field(gt=0)],
12627
+ Tuple[
12628
+ Annotated[StrictFloat, Field(gt=0)],
12629
+ Annotated[StrictFloat, Field(gt=0)]
12630
+ ]
12631
+ ] = None,
12632
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
12633
+ _content_type: Optional[StrictStr] = None,
12634
+ _headers: Optional[Dict[StrictStr, Any]] = None,
12635
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12636
+ ) -> ListDailyBillResponse:
12637
+ """(Deprecated) Get Usage
12638
+
12639
+
12640
+ :param _request_timeout: timeout setting for this request. If one
12641
+ number provided, it will be total request
12642
+ timeout. It can also be a pair (tuple) of
12643
+ (connection, read) timeouts.
12644
+ :type _request_timeout: int, tuple(int, int), optional
12645
+ :param _request_auth: set to override the auth_settings for an a single
12646
+ request; this effectively ignores the
12647
+ authentication in the spec for a single request.
12648
+ :type _request_auth: dict, optional
12649
+ :param _content_type: force content-type for the request.
12650
+ :type _content_type: str, Optional
12651
+ :param _headers: set to override the headers for a single
12652
+ request; this effectively ignores the headers
12653
+ in the spec for a single request.
12654
+ :type _headers: dict, optional
12655
+ :param _host_index: set to override the host_index for a single
12656
+ request; this effectively ignores the host_index
12657
+ in the spec for a single request.
12658
+ :type _host_index: int, optional
12659
+ :return: Returns the result object.
12660
+ """ # noqa: E501
12661
+ warnings.warn("GET /daily_bills is deprecated.", DeprecationWarning)
12662
+
12663
+ _param = self._get_usage_daily_bills_get_serialize(
12664
+ _request_auth=_request_auth,
12665
+ _content_type=_content_type,
12666
+ _headers=_headers,
12667
+ _host_index=_host_index
12668
+ )
12669
+
12670
+ _response_types_map: Dict[str, Optional[str]] = {
12671
+ '200': "ListDailyBillResponse",
12672
+ }
12673
+ response_data = self.api_client.call_api(
12674
+ *_param,
12675
+ _request_timeout=_request_timeout
12676
+ )
12677
+ response_data.read()
12678
+ return self.api_client.response_deserialize(
12679
+ response_data=response_data,
12680
+ response_types_map=_response_types_map,
12681
+ ).data
12682
+
12683
+
12684
+ @validate_call
12685
+ def get_usage_daily_bills_get_with_http_info(
12686
+ self,
12687
+ _request_timeout: Union[
12688
+ None,
12689
+ Annotated[StrictFloat, Field(gt=0)],
12690
+ Tuple[
12691
+ Annotated[StrictFloat, Field(gt=0)],
12692
+ Annotated[StrictFloat, Field(gt=0)]
12693
+ ]
12694
+ ] = None,
12695
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
12696
+ _content_type: Optional[StrictStr] = None,
12697
+ _headers: Optional[Dict[StrictStr, Any]] = None,
12698
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12699
+ ) -> ApiResponse[ListDailyBillResponse]:
12700
+ """(Deprecated) Get Usage
12701
+
12702
+
12703
+ :param _request_timeout: timeout setting for this request. If one
12704
+ number provided, it will be total request
12705
+ timeout. It can also be a pair (tuple) of
12706
+ (connection, read) timeouts.
12707
+ :type _request_timeout: int, tuple(int, int), optional
12708
+ :param _request_auth: set to override the auth_settings for an a single
12709
+ request; this effectively ignores the
12710
+ authentication in the spec for a single request.
12711
+ :type _request_auth: dict, optional
12712
+ :param _content_type: force content-type for the request.
12713
+ :type _content_type: str, Optional
12714
+ :param _headers: set to override the headers for a single
12715
+ request; this effectively ignores the headers
12716
+ in the spec for a single request.
12717
+ :type _headers: dict, optional
12718
+ :param _host_index: set to override the host_index for a single
12719
+ request; this effectively ignores the host_index
12720
+ in the spec for a single request.
12721
+ :type _host_index: int, optional
12722
+ :return: Returns the result object.
12723
+ """ # noqa: E501
12724
+ warnings.warn("GET /daily_bills is deprecated.", DeprecationWarning)
12725
+
12726
+ _param = self._get_usage_daily_bills_get_serialize(
12727
+ _request_auth=_request_auth,
12728
+ _content_type=_content_type,
12729
+ _headers=_headers,
12730
+ _host_index=_host_index
12731
+ )
12732
+
12733
+ _response_types_map: Dict[str, Optional[str]] = {
12734
+ '200': "ListDailyBillResponse",
12735
+ }
12736
+ response_data = self.api_client.call_api(
12737
+ *_param,
12738
+ _request_timeout=_request_timeout
12739
+ )
12740
+ response_data.read()
12741
+ return self.api_client.response_deserialize(
12742
+ response_data=response_data,
12743
+ response_types_map=_response_types_map,
12744
+ )
12745
+
12746
+
12747
+ @validate_call
12748
+ def get_usage_daily_bills_get_without_preload_content(
12749
+ self,
12750
+ _request_timeout: Union[
12751
+ None,
12752
+ Annotated[StrictFloat, Field(gt=0)],
12753
+ Tuple[
12754
+ Annotated[StrictFloat, Field(gt=0)],
12755
+ Annotated[StrictFloat, Field(gt=0)]
12756
+ ]
12757
+ ] = None,
12758
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
12759
+ _content_type: Optional[StrictStr] = None,
12760
+ _headers: Optional[Dict[StrictStr, Any]] = None,
12761
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12762
+ ) -> RESTResponseType:
12763
+ """(Deprecated) Get Usage
12764
+
12765
+
12766
+ :param _request_timeout: timeout setting for this request. If one
12767
+ number provided, it will be total request
12768
+ timeout. It can also be a pair (tuple) of
12769
+ (connection, read) timeouts.
12770
+ :type _request_timeout: int, tuple(int, int), optional
12771
+ :param _request_auth: set to override the auth_settings for an a single
12772
+ request; this effectively ignores the
12773
+ authentication in the spec for a single request.
12774
+ :type _request_auth: dict, optional
12775
+ :param _content_type: force content-type for the request.
12776
+ :type _content_type: str, Optional
12777
+ :param _headers: set to override the headers for a single
12778
+ request; this effectively ignores the headers
12779
+ in the spec for a single request.
12780
+ :type _headers: dict, optional
12781
+ :param _host_index: set to override the host_index for a single
12782
+ request; this effectively ignores the host_index
12783
+ in the spec for a single request.
12784
+ :type _host_index: int, optional
12785
+ :return: Returns the result object.
12786
+ """ # noqa: E501
12787
+ warnings.warn("GET /daily_bills is deprecated.", DeprecationWarning)
12788
+
12789
+ _param = self._get_usage_daily_bills_get_serialize(
12790
+ _request_auth=_request_auth,
12791
+ _content_type=_content_type,
12792
+ _headers=_headers,
12793
+ _host_index=_host_index
12794
+ )
12795
+
12796
+ _response_types_map: Dict[str, Optional[str]] = {
12797
+ '200': "ListDailyBillResponse",
12798
+ }
12799
+ response_data = self.api_client.call_api(
12800
+ *_param,
12801
+ _request_timeout=_request_timeout
12802
+ )
12803
+ return response_data.response
12804
+
12805
+
12806
+ def _get_usage_daily_bills_get_serialize(
12807
+ self,
12808
+ _request_auth,
12809
+ _content_type,
12810
+ _headers,
12811
+ _host_index,
12812
+ ) -> RequestSerialized:
12813
+
12814
+ _host = None
12815
+
12816
+ _collection_formats: Dict[str, str] = {
12817
+ }
12818
+
12819
+ _path_params: Dict[str, str] = {}
12820
+ _query_params: List[Tuple[str, str]] = []
12821
+ _header_params: Dict[str, Optional[str]] = _headers or {}
12822
+ _form_params: List[Tuple[str, str]] = []
12823
+ _files: Dict[
12824
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
12825
+ ] = {}
12826
+ _body_params: Optional[bytes] = None
12827
+
12828
+ # process the path parameters
12829
+ # process the query parameters
12830
+ # process the header parameters
12831
+ # process the form parameters
12832
+ # process the body parameter
12833
+
12834
+
12835
+ # set the HTTP header `Accept`
12836
+ if 'Accept' not in _header_params:
12837
+ _header_params['Accept'] = self.api_client.select_header_accept(
12838
+ [
12839
+ 'application/json'
12840
+ ]
12841
+ )
12842
+
12843
+
12844
+ # authentication setting
12845
+ _auth_settings: List[str] = [
12846
+ ]
12847
+
12848
+ return self.api_client.param_serialize(
12849
+ method='GET',
12850
+ resource_path='/daily_bills',
12851
+ path_params=_path_params,
12852
+ query_params=_query_params,
12853
+ header_params=_header_params,
12854
+ body=_body_params,
12855
+ post_params=_form_params,
12856
+ files=_files,
12857
+ auth_settings=_auth_settings,
12858
+ collection_formats=_collection_formats,
12859
+ _host=_host,
12860
+ _request_auth=_request_auth
12861
+ )
12862
+
12863
+
12864
+
12865
+
12866
+ @validate_call
12867
+ def get_usage_deployments_usage_deployment_id_get(
12868
+ self,
12869
+ deployment_id: StrictInt,
12870
+ metric: Metric,
12871
+ start_time_in_seconds: StrictInt,
12872
+ end_time_in_seconds: StrictInt,
12873
+ step: Optional[StrictInt] = None,
12874
+ _request_timeout: Union[
12875
+ None,
12876
+ Annotated[StrictFloat, Field(gt=0)],
12877
+ Tuple[
12878
+ Annotated[StrictFloat, Field(gt=0)],
12879
+ Annotated[StrictFloat, Field(gt=0)]
12880
+ ]
12881
+ ] = None,
12882
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
12883
+ _content_type: Optional[StrictStr] = None,
12884
+ _headers: Optional[Dict[StrictStr, Any]] = None,
12885
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12886
+ ) -> GetDeploymentUsageResponse:
12887
+ """Get Usage
12888
+
12889
+
12890
+ :param deployment_id: (required)
12891
+ :type deployment_id: int
12892
+ :param metric: (required)
12893
+ :type metric: Metric
12894
+ :param start_time_in_seconds: (required)
12895
+ :type start_time_in_seconds: int
12896
+ :param end_time_in_seconds: (required)
12897
+ :type end_time_in_seconds: int
12898
+ :param step:
12899
+ :type step: int
12900
+ :param _request_timeout: timeout setting for this request. If one
12901
+ number provided, it will be total request
12902
+ timeout. It can also be a pair (tuple) of
12903
+ (connection, read) timeouts.
12904
+ :type _request_timeout: int, tuple(int, int), optional
12905
+ :param _request_auth: set to override the auth_settings for an a single
12906
+ request; this effectively ignores the
12907
+ authentication in the spec for a single request.
12908
+ :type _request_auth: dict, optional
12909
+ :param _content_type: force content-type for the request.
12910
+ :type _content_type: str, Optional
12911
+ :param _headers: set to override the headers for a single
12912
+ request; this effectively ignores the headers
12913
+ in the spec for a single request.
12914
+ :type _headers: dict, optional
12915
+ :param _host_index: set to override the host_index for a single
12916
+ request; this effectively ignores the host_index
12917
+ in the spec for a single request.
12918
+ :type _host_index: int, optional
12919
+ :return: Returns the result object.
12920
+ """ # noqa: E501
12921
+
12922
+ _param = self._get_usage_deployments_usage_deployment_id_get_serialize(
12923
+ deployment_id=deployment_id,
12924
+ metric=metric,
12925
+ start_time_in_seconds=start_time_in_seconds,
12926
+ end_time_in_seconds=end_time_in_seconds,
12927
+ step=step,
12928
+ _request_auth=_request_auth,
12929
+ _content_type=_content_type,
12930
+ _headers=_headers,
12931
+ _host_index=_host_index
12932
+ )
12933
+
12934
+ _response_types_map: Dict[str, Optional[str]] = {
12935
+ '200': "GetDeploymentUsageResponse",
12936
+ '422': "HTTPValidationError",
12937
+ }
12938
+ response_data = self.api_client.call_api(
12939
+ *_param,
12940
+ _request_timeout=_request_timeout
12941
+ )
12942
+ response_data.read()
12943
+ return self.api_client.response_deserialize(
12944
+ response_data=response_data,
12945
+ response_types_map=_response_types_map,
12946
+ ).data
12947
+
12948
+
12949
+ @validate_call
12950
+ def get_usage_deployments_usage_deployment_id_get_with_http_info(
12951
+ self,
12952
+ deployment_id: StrictInt,
12953
+ metric: Metric,
12954
+ start_time_in_seconds: StrictInt,
12955
+ end_time_in_seconds: StrictInt,
12956
+ step: Optional[StrictInt] = None,
12957
+ _request_timeout: Union[
12958
+ None,
12959
+ Annotated[StrictFloat, Field(gt=0)],
12960
+ Tuple[
12961
+ Annotated[StrictFloat, Field(gt=0)],
12962
+ Annotated[StrictFloat, Field(gt=0)]
12963
+ ]
12964
+ ] = None,
12965
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
12966
+ _content_type: Optional[StrictStr] = None,
12967
+ _headers: Optional[Dict[StrictStr, Any]] = None,
12968
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12969
+ ) -> ApiResponse[GetDeploymentUsageResponse]:
12970
+ """Get Usage
12971
+
12972
+
12973
+ :param deployment_id: (required)
12974
+ :type deployment_id: int
12975
+ :param metric: (required)
12976
+ :type metric: Metric
12977
+ :param start_time_in_seconds: (required)
12978
+ :type start_time_in_seconds: int
12979
+ :param end_time_in_seconds: (required)
12980
+ :type end_time_in_seconds: int
12981
+ :param step:
12982
+ :type step: int
12983
+ :param _request_timeout: timeout setting for this request. If one
12984
+ number provided, it will be total request
12985
+ timeout. It can also be a pair (tuple) of
12986
+ (connection, read) timeouts.
12987
+ :type _request_timeout: int, tuple(int, int), optional
12988
+ :param _request_auth: set to override the auth_settings for an a single
12989
+ request; this effectively ignores the
12990
+ authentication in the spec for a single request.
12991
+ :type _request_auth: dict, optional
12992
+ :param _content_type: force content-type for the request.
12993
+ :type _content_type: str, Optional
12994
+ :param _headers: set to override the headers for a single
12995
+ request; this effectively ignores the headers
12996
+ in the spec for a single request.
12997
+ :type _headers: dict, optional
12998
+ :param _host_index: set to override the host_index for a single
12999
+ request; this effectively ignores the host_index
13000
+ in the spec for a single request.
13001
+ :type _host_index: int, optional
13002
+ :return: Returns the result object.
13003
+ """ # noqa: E501
13004
+
13005
+ _param = self._get_usage_deployments_usage_deployment_id_get_serialize(
13006
+ deployment_id=deployment_id,
13007
+ metric=metric,
13008
+ start_time_in_seconds=start_time_in_seconds,
13009
+ end_time_in_seconds=end_time_in_seconds,
13010
+ step=step,
13011
+ _request_auth=_request_auth,
13012
+ _content_type=_content_type,
13013
+ _headers=_headers,
13014
+ _host_index=_host_index
13015
+ )
13016
+
13017
+ _response_types_map: Dict[str, Optional[str]] = {
13018
+ '200': "GetDeploymentUsageResponse",
13019
+ '422': "HTTPValidationError",
13020
+ }
13021
+ response_data = self.api_client.call_api(
13022
+ *_param,
13023
+ _request_timeout=_request_timeout
13024
+ )
13025
+ response_data.read()
13026
+ return self.api_client.response_deserialize(
13027
+ response_data=response_data,
13028
+ response_types_map=_response_types_map,
13029
+ )
13030
+
13031
+
13032
+ @validate_call
13033
+ def get_usage_deployments_usage_deployment_id_get_without_preload_content(
13034
+ self,
13035
+ deployment_id: StrictInt,
13036
+ metric: Metric,
13037
+ start_time_in_seconds: StrictInt,
13038
+ end_time_in_seconds: StrictInt,
13039
+ step: Optional[StrictInt] = None,
13040
+ _request_timeout: Union[
13041
+ None,
13042
+ Annotated[StrictFloat, Field(gt=0)],
13043
+ Tuple[
13044
+ Annotated[StrictFloat, Field(gt=0)],
13045
+ Annotated[StrictFloat, Field(gt=0)]
13046
+ ]
13047
+ ] = None,
13048
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
13049
+ _content_type: Optional[StrictStr] = None,
13050
+ _headers: Optional[Dict[StrictStr, Any]] = None,
13051
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13052
+ ) -> RESTResponseType:
13053
+ """Get Usage
13054
+
13055
+
13056
+ :param deployment_id: (required)
13057
+ :type deployment_id: int
13058
+ :param metric: (required)
13059
+ :type metric: Metric
13060
+ :param start_time_in_seconds: (required)
13061
+ :type start_time_in_seconds: int
13062
+ :param end_time_in_seconds: (required)
13063
+ :type end_time_in_seconds: int
13064
+ :param step:
13065
+ :type step: int
13066
+ :param _request_timeout: timeout setting for this request. If one
13067
+ number provided, it will be total request
13068
+ timeout. It can also be a pair (tuple) of
13069
+ (connection, read) timeouts.
13070
+ :type _request_timeout: int, tuple(int, int), optional
13071
+ :param _request_auth: set to override the auth_settings for an a single
13072
+ request; this effectively ignores the
13073
+ authentication in the spec for a single request.
13074
+ :type _request_auth: dict, optional
13075
+ :param _content_type: force content-type for the request.
13076
+ :type _content_type: str, Optional
13077
+ :param _headers: set to override the headers for a single
13078
+ request; this effectively ignores the headers
13079
+ in the spec for a single request.
13080
+ :type _headers: dict, optional
13081
+ :param _host_index: set to override the host_index for a single
13082
+ request; this effectively ignores the host_index
13083
+ in the spec for a single request.
13084
+ :type _host_index: int, optional
13085
+ :return: Returns the result object.
13086
+ """ # noqa: E501
13087
+
13088
+ _param = self._get_usage_deployments_usage_deployment_id_get_serialize(
13089
+ deployment_id=deployment_id,
13090
+ metric=metric,
13091
+ start_time_in_seconds=start_time_in_seconds,
13092
+ end_time_in_seconds=end_time_in_seconds,
13093
+ step=step,
13094
+ _request_auth=_request_auth,
13095
+ _content_type=_content_type,
13096
+ _headers=_headers,
13097
+ _host_index=_host_index
13098
+ )
13099
+
13100
+ _response_types_map: Dict[str, Optional[str]] = {
13101
+ '200': "GetDeploymentUsageResponse",
13102
+ '422': "HTTPValidationError",
13103
+ }
13104
+ response_data = self.api_client.call_api(
13105
+ *_param,
13106
+ _request_timeout=_request_timeout
13107
+ )
13108
+ return response_data.response
13109
+
13110
+
13111
+ def _get_usage_deployments_usage_deployment_id_get_serialize(
13112
+ self,
13113
+ deployment_id,
13114
+ metric,
13115
+ start_time_in_seconds,
13116
+ end_time_in_seconds,
13117
+ step,
13118
+ _request_auth,
13119
+ _content_type,
13120
+ _headers,
13121
+ _host_index,
13122
+ ) -> RequestSerialized:
13123
+
13124
+ _host = None
13125
+
13126
+ _collection_formats: Dict[str, str] = {
13127
+ }
13128
+
13129
+ _path_params: Dict[str, str] = {}
13130
+ _query_params: List[Tuple[str, str]] = []
13131
+ _header_params: Dict[str, Optional[str]] = _headers or {}
13132
+ _form_params: List[Tuple[str, str]] = []
13133
+ _files: Dict[
13134
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
13135
+ ] = {}
13136
+ _body_params: Optional[bytes] = None
13137
+
13138
+ # process the path parameters
13139
+ if deployment_id is not None:
13140
+ _path_params['deployment_id'] = deployment_id
13141
+ # process the query parameters
13142
+ if metric is not None:
13143
+
13144
+ _query_params.append(('metric', metric.value))
13145
+
13146
+ if start_time_in_seconds is not None:
13147
+
13148
+ _query_params.append(('start_time_in_seconds', start_time_in_seconds))
13149
+
13150
+ if end_time_in_seconds is not None:
13151
+
13152
+ _query_params.append(('end_time_in_seconds', end_time_in_seconds))
13153
+
13154
+ if step is not None:
13155
+
13156
+ _query_params.append(('step', step))
13157
+
13158
+ # process the header parameters
13159
+ # process the form parameters
13160
+ # process the body parameter
13161
+
13162
+
13163
+ # set the HTTP header `Accept`
13164
+ if 'Accept' not in _header_params:
13165
+ _header_params['Accept'] = self.api_client.select_header_accept(
13166
+ [
13167
+ 'application/json'
13168
+ ]
13169
+ )
13170
+
13171
+
13172
+ # authentication setting
13173
+ _auth_settings: List[str] = [
13174
+ 'HTTPBearer'
13175
+ ]
13176
+
13177
+ return self.api_client.param_serialize(
13178
+ method='GET',
13179
+ resource_path='/deployments/usage/{deployment_id}',
13180
+ path_params=_path_params,
13181
+ query_params=_query_params,
13182
+ header_params=_header_params,
13183
+ body=_body_params,
13184
+ post_params=_form_params,
13185
+ files=_files,
13186
+ auth_settings=_auth_settings,
13187
+ collection_formats=_collection_formats,
13188
+ _host=_host,
13189
+ _request_auth=_request_auth
13190
+ )
13191
+
13192
+
13193
+
13194
+
13195
+ @validate_call
13196
+ def get_user_vault_item_by_id_endpoint_user_vault_secret_id_get(
13197
+ self,
13198
+ secret_id: Annotated[int, Field(strict=True, ge=1)],
13199
+ _request_timeout: Union[
13200
+ None,
13201
+ Annotated[StrictFloat, Field(gt=0)],
13202
+ Tuple[
13203
+ Annotated[StrictFloat, Field(gt=0)],
13204
+ Annotated[StrictFloat, Field(gt=0)]
13205
+ ]
13206
+ ] = None,
13207
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
13208
+ _content_type: Optional[StrictStr] = None,
13209
+ _headers: Optional[Dict[StrictStr, Any]] = None,
13210
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13211
+ ) -> UserVaultItem:
13212
+ """Get User Vault Item By Id Endpoint
13213
+
13214
+ Resolve a single secret's value. This is the only endpoint that returns a vault value, so it is the single place where read access to secret material is authorized and auditable.
13215
+
13216
+ :param secret_id: (required)
13217
+ :type secret_id: int
13218
+ :param _request_timeout: timeout setting for this request. If one
13219
+ number provided, it will be total request
13220
+ timeout. It can also be a pair (tuple) of
13221
+ (connection, read) timeouts.
13222
+ :type _request_timeout: int, tuple(int, int), optional
13223
+ :param _request_auth: set to override the auth_settings for an a single
13224
+ request; this effectively ignores the
13225
+ authentication in the spec for a single request.
13226
+ :type _request_auth: dict, optional
13227
+ :param _content_type: force content-type for the request.
13228
+ :type _content_type: str, Optional
13229
+ :param _headers: set to override the headers for a single
13230
+ request; this effectively ignores the headers
13231
+ in the spec for a single request.
13232
+ :type _headers: dict, optional
13233
+ :param _host_index: set to override the host_index for a single
13234
+ request; this effectively ignores the host_index
13235
+ in the spec for a single request.
13236
+ :type _host_index: int, optional
13237
+ :return: Returns the result object.
13238
+ """ # noqa: E501
13239
+
13240
+ _param = self._get_user_vault_item_by_id_endpoint_user_vault_secret_id_get_serialize(
13241
+ secret_id=secret_id,
13242
+ _request_auth=_request_auth,
13243
+ _content_type=_content_type,
13244
+ _headers=_headers,
13245
+ _host_index=_host_index
13246
+ )
13247
+
13248
+ _response_types_map: Dict[str, Optional[str]] = {
13249
+ '200': "UserVaultItem",
13250
+ '422': "HTTPValidationError",
13251
+ }
13252
+ response_data = self.api_client.call_api(
13253
+ *_param,
13254
+ _request_timeout=_request_timeout
13255
+ )
13256
+ response_data.read()
13257
+ return self.api_client.response_deserialize(
13258
+ response_data=response_data,
13259
+ response_types_map=_response_types_map,
13260
+ ).data
13261
+
13262
+
13263
+ @validate_call
13264
+ def get_user_vault_item_by_id_endpoint_user_vault_secret_id_get_with_http_info(
13265
+ self,
13266
+ secret_id: Annotated[int, Field(strict=True, ge=1)],
13267
+ _request_timeout: Union[
13268
+ None,
13269
+ Annotated[StrictFloat, Field(gt=0)],
13270
+ Tuple[
13271
+ Annotated[StrictFloat, Field(gt=0)],
13272
+ Annotated[StrictFloat, Field(gt=0)]
13273
+ ]
13274
+ ] = None,
13275
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
13276
+ _content_type: Optional[StrictStr] = None,
13277
+ _headers: Optional[Dict[StrictStr, Any]] = None,
13278
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13279
+ ) -> ApiResponse[UserVaultItem]:
13280
+ """Get User Vault Item By Id Endpoint
13281
+
13282
+ Resolve a single secret's value. This is the only endpoint that returns a vault value, so it is the single place where read access to secret material is authorized and auditable.
13283
+
13284
+ :param secret_id: (required)
13285
+ :type secret_id: int
13286
+ :param _request_timeout: timeout setting for this request. If one
13287
+ number provided, it will be total request
13288
+ timeout. It can also be a pair (tuple) of
13289
+ (connection, read) timeouts.
13290
+ :type _request_timeout: int, tuple(int, int), optional
13291
+ :param _request_auth: set to override the auth_settings for an a single
13292
+ request; this effectively ignores the
13293
+ authentication in the spec for a single request.
13294
+ :type _request_auth: dict, optional
13295
+ :param _content_type: force content-type for the request.
13296
+ :type _content_type: str, Optional
13297
+ :param _headers: set to override the headers for a single
13298
+ request; this effectively ignores the headers
13299
+ in the spec for a single request.
13300
+ :type _headers: dict, optional
13301
+ :param _host_index: set to override the host_index for a single
13302
+ request; this effectively ignores the host_index
13303
+ in the spec for a single request.
13304
+ :type _host_index: int, optional
13305
+ :return: Returns the result object.
13306
+ """ # noqa: E501
13307
+
13308
+ _param = self._get_user_vault_item_by_id_endpoint_user_vault_secret_id_get_serialize(
13309
+ secret_id=secret_id,
13310
+ _request_auth=_request_auth,
13311
+ _content_type=_content_type,
13312
+ _headers=_headers,
13313
+ _host_index=_host_index
13314
+ )
13315
+
13316
+ _response_types_map: Dict[str, Optional[str]] = {
13317
+ '200': "UserVaultItem",
13318
+ '422': "HTTPValidationError",
13319
+ }
13320
+ response_data = self.api_client.call_api(
13321
+ *_param,
13322
+ _request_timeout=_request_timeout
13323
+ )
13324
+ response_data.read()
13325
+ return self.api_client.response_deserialize(
13326
+ response_data=response_data,
13327
+ response_types_map=_response_types_map,
13328
+ )
13329
+
13330
+
13331
+ @validate_call
13332
+ def get_user_vault_item_by_id_endpoint_user_vault_secret_id_get_without_preload_content(
13333
+ self,
13334
+ secret_id: Annotated[int, Field(strict=True, ge=1)],
13335
+ _request_timeout: Union[
13336
+ None,
13337
+ Annotated[StrictFloat, Field(gt=0)],
13338
+ Tuple[
13339
+ Annotated[StrictFloat, Field(gt=0)],
13340
+ Annotated[StrictFloat, Field(gt=0)]
13341
+ ]
13342
+ ] = None,
13343
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
13344
+ _content_type: Optional[StrictStr] = None,
13345
+ _headers: Optional[Dict[StrictStr, Any]] = None,
13346
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13347
+ ) -> RESTResponseType:
13348
+ """Get User Vault Item By Id Endpoint
13349
+
13350
+ Resolve a single secret's value. This is the only endpoint that returns a vault value, so it is the single place where read access to secret material is authorized and auditable.
13351
+
13352
+ :param secret_id: (required)
13353
+ :type secret_id: int
13354
+ :param _request_timeout: timeout setting for this request. If one
13355
+ number provided, it will be total request
13356
+ timeout. It can also be a pair (tuple) of
13357
+ (connection, read) timeouts.
13358
+ :type _request_timeout: int, tuple(int, int), optional
13359
+ :param _request_auth: set to override the auth_settings for an a single
13360
+ request; this effectively ignores the
13361
+ authentication in the spec for a single request.
13362
+ :type _request_auth: dict, optional
13363
+ :param _content_type: force content-type for the request.
13364
+ :type _content_type: str, Optional
13365
+ :param _headers: set to override the headers for a single
13366
+ request; this effectively ignores the headers
13367
+ in the spec for a single request.
13368
+ :type _headers: dict, optional
13369
+ :param _host_index: set to override the host_index for a single
13370
+ request; this effectively ignores the host_index
13371
+ in the spec for a single request.
13372
+ :type _host_index: int, optional
13373
+ :return: Returns the result object.
13374
+ """ # noqa: E501
13375
+
13376
+ _param = self._get_user_vault_item_by_id_endpoint_user_vault_secret_id_get_serialize(
13377
+ secret_id=secret_id,
13378
+ _request_auth=_request_auth,
13379
+ _content_type=_content_type,
13380
+ _headers=_headers,
13381
+ _host_index=_host_index
13382
+ )
13383
+
13384
+ _response_types_map: Dict[str, Optional[str]] = {
13385
+ '200': "UserVaultItem",
13386
+ '422': "HTTPValidationError",
13387
+ }
13388
+ response_data = self.api_client.call_api(
13389
+ *_param,
13390
+ _request_timeout=_request_timeout
13391
+ )
13392
+ return response_data.response
13393
+
13394
+
13395
+ def _get_user_vault_item_by_id_endpoint_user_vault_secret_id_get_serialize(
13396
+ self,
13397
+ secret_id,
13398
+ _request_auth,
13399
+ _content_type,
13400
+ _headers,
13401
+ _host_index,
13402
+ ) -> RequestSerialized:
13403
+
13404
+ _host = None
13405
+
13406
+ _collection_formats: Dict[str, str] = {
13407
+ }
13408
+
13409
+ _path_params: Dict[str, str] = {}
13410
+ _query_params: List[Tuple[str, str]] = []
13411
+ _header_params: Dict[str, Optional[str]] = _headers or {}
13412
+ _form_params: List[Tuple[str, str]] = []
13413
+ _files: Dict[
13414
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
13415
+ ] = {}
13416
+ _body_params: Optional[bytes] = None
13417
+
13418
+ # process the path parameters
13419
+ if secret_id is not None:
13420
+ _path_params['secret_id'] = secret_id
13421
+ # process the query parameters
13422
+ # process the header parameters
13423
+ # process the form parameters
13424
+ # process the body parameter
13425
+
13426
+
13427
+ # set the HTTP header `Accept`
13428
+ if 'Accept' not in _header_params:
13429
+ _header_params['Accept'] = self.api_client.select_header_accept(
13430
+ [
13431
+ 'application/json'
13432
+ ]
13433
+ )
13434
+
13435
+
13436
+ # authentication setting
13437
+ _auth_settings: List[str] = [
13438
+ 'HTTPBearer'
13439
+ ]
13440
+
13441
+ return self.api_client.param_serialize(
13442
+ method='GET',
13443
+ resource_path='/user_vault/{secret_id}',
13444
+ path_params=_path_params,
13445
+ query_params=_query_params,
13446
+ header_params=_header_params,
13447
+ body=_body_params,
13448
+ post_params=_form_params,
13449
+ files=_files,
13450
+ auth_settings=_auth_settings,
13451
+ collection_formats=_collection_formats,
13452
+ _host=_host,
13453
+ _request_auth=_request_auth
13454
+ )
13455
+
13456
+
13457
+
13458
+
13459
+ @validate_call
13460
+ def get_volume_endpoint_volumes_volume_id_get(
13461
+ self,
13462
+ volume_id: StrictInt,
13463
+ _request_timeout: Union[
13464
+ None,
13465
+ Annotated[StrictFloat, Field(gt=0)],
13466
+ Tuple[
13467
+ Annotated[StrictFloat, Field(gt=0)],
13468
+ Annotated[StrictFloat, Field(gt=0)]
13469
+ ]
13470
+ ] = None,
13471
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
13472
+ _content_type: Optional[StrictStr] = None,
13473
+ _headers: Optional[Dict[StrictStr, Any]] = None,
13474
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13475
+ ) -> GetVolumeResponse:
13476
+ """Get Volume Endpoint
13477
+
13478
+ Retrieve a single volume by id.
13479
+
13480
+ :param volume_id: (required)
13481
+ :type volume_id: int
13482
+ :param _request_timeout: timeout setting for this request. If one
13483
+ number provided, it will be total request
13484
+ timeout. It can also be a pair (tuple) of
13485
+ (connection, read) timeouts.
13486
+ :type _request_timeout: int, tuple(int, int), optional
13487
+ :param _request_auth: set to override the auth_settings for an a single
13488
+ request; this effectively ignores the
13489
+ authentication in the spec for a single request.
13490
+ :type _request_auth: dict, optional
13491
+ :param _content_type: force content-type for the request.
13492
+ :type _content_type: str, Optional
13493
+ :param _headers: set to override the headers for a single
13494
+ request; this effectively ignores the headers
13495
+ in the spec for a single request.
13496
+ :type _headers: dict, optional
13497
+ :param _host_index: set to override the host_index for a single
13498
+ request; this effectively ignores the host_index
13499
+ in the spec for a single request.
13500
+ :type _host_index: int, optional
13501
+ :return: Returns the result object.
13502
+ """ # noqa: E501
13503
+
13504
+ _param = self._get_volume_endpoint_volumes_volume_id_get_serialize(
13505
+ volume_id=volume_id,
13506
+ _request_auth=_request_auth,
13507
+ _content_type=_content_type,
13508
+ _headers=_headers,
13509
+ _host_index=_host_index
13510
+ )
13511
+
13512
+ _response_types_map: Dict[str, Optional[str]] = {
13513
+ '200': "GetVolumeResponse",
13514
+ '422': "HTTPValidationError",
13515
+ }
13516
+ response_data = self.api_client.call_api(
13517
+ *_param,
13518
+ _request_timeout=_request_timeout
13519
+ )
13520
+ response_data.read()
13521
+ return self.api_client.response_deserialize(
13522
+ response_data=response_data,
13523
+ response_types_map=_response_types_map,
13524
+ ).data
13525
+
13526
+
13527
+ @validate_call
13528
+ def get_volume_endpoint_volumes_volume_id_get_with_http_info(
13529
+ self,
13530
+ volume_id: StrictInt,
13531
+ _request_timeout: Union[
13532
+ None,
13533
+ Annotated[StrictFloat, Field(gt=0)],
13534
+ Tuple[
13535
+ Annotated[StrictFloat, Field(gt=0)],
13536
+ Annotated[StrictFloat, Field(gt=0)]
13537
+ ]
13538
+ ] = None,
13539
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
13540
+ _content_type: Optional[StrictStr] = None,
13541
+ _headers: Optional[Dict[StrictStr, Any]] = None,
13542
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13543
+ ) -> ApiResponse[GetVolumeResponse]:
13544
+ """Get Volume Endpoint
13545
+
13546
+ Retrieve a single volume by id.
13547
+
13548
+ :param volume_id: (required)
13549
+ :type volume_id: int
13550
+ :param _request_timeout: timeout setting for this request. If one
11974
13551
  number provided, it will be total request
11975
13552
  timeout. It can also be a pair (tuple) of
11976
13553
  (connection, read) timeouts.
@@ -11992,12 +13569,8 @@ class EXTERNALApi:
11992
13569
  :return: Returns the result object.
11993
13570
  """ # noqa: E501
11994
13571
 
11995
- _param = self._get_usage_deployments_usage_deployment_id_get_serialize(
11996
- deployment_id=deployment_id,
11997
- metric=metric,
11998
- start_time_in_seconds=start_time_in_seconds,
11999
- end_time_in_seconds=end_time_in_seconds,
12000
- step=step,
13572
+ _param = self._get_volume_endpoint_volumes_volume_id_get_serialize(
13573
+ volume_id=volume_id,
12001
13574
  _request_auth=_request_auth,
12002
13575
  _content_type=_content_type,
12003
13576
  _headers=_headers,
@@ -12005,7 +13578,7 @@ class EXTERNALApi:
12005
13578
  )
12006
13579
 
12007
13580
  _response_types_map: Dict[str, Optional[str]] = {
12008
- '200': "GetDeploymentUsageResponse",
13581
+ '200': "GetVolumeResponse",
12009
13582
  '422': "HTTPValidationError",
12010
13583
  }
12011
13584
  response_data = self.api_client.call_api(
@@ -12020,13 +13593,9 @@ class EXTERNALApi:
12020
13593
 
12021
13594
 
12022
13595
  @validate_call
12023
- def get_usage_deployments_usage_deployment_id_get_without_preload_content(
13596
+ def get_volume_endpoint_volumes_volume_id_get_without_preload_content(
12024
13597
  self,
12025
- deployment_id: StrictInt,
12026
- metric: Metric,
12027
- start_time_in_seconds: StrictInt,
12028
- end_time_in_seconds: StrictInt,
12029
- step: Optional[StrictInt] = None,
13598
+ volume_id: StrictInt,
12030
13599
  _request_timeout: Union[
12031
13600
  None,
12032
13601
  Annotated[StrictFloat, Field(gt=0)],
@@ -12040,19 +13609,12 @@ class EXTERNALApi:
12040
13609
  _headers: Optional[Dict[StrictStr, Any]] = None,
12041
13610
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12042
13611
  ) -> RESTResponseType:
12043
- """Get Usage
13612
+ """Get Volume Endpoint
12044
13613
 
13614
+ Retrieve a single volume by id.
12045
13615
 
12046
- :param deployment_id: (required)
12047
- :type deployment_id: int
12048
- :param metric: (required)
12049
- :type metric: Metric
12050
- :param start_time_in_seconds: (required)
12051
- :type start_time_in_seconds: int
12052
- :param end_time_in_seconds: (required)
12053
- :type end_time_in_seconds: int
12054
- :param step:
12055
- :type step: int
13616
+ :param volume_id: (required)
13617
+ :type volume_id: int
12056
13618
  :param _request_timeout: timeout setting for this request. If one
12057
13619
  number provided, it will be total request
12058
13620
  timeout. It can also be a pair (tuple) of
@@ -12075,12 +13637,8 @@ class EXTERNALApi:
12075
13637
  :return: Returns the result object.
12076
13638
  """ # noqa: E501
12077
13639
 
12078
- _param = self._get_usage_deployments_usage_deployment_id_get_serialize(
12079
- deployment_id=deployment_id,
12080
- metric=metric,
12081
- start_time_in_seconds=start_time_in_seconds,
12082
- end_time_in_seconds=end_time_in_seconds,
12083
- step=step,
13640
+ _param = self._get_volume_endpoint_volumes_volume_id_get_serialize(
13641
+ volume_id=volume_id,
12084
13642
  _request_auth=_request_auth,
12085
13643
  _content_type=_content_type,
12086
13644
  _headers=_headers,
@@ -12088,7 +13646,7 @@ class EXTERNALApi:
12088
13646
  )
12089
13647
 
12090
13648
  _response_types_map: Dict[str, Optional[str]] = {
12091
- '200': "GetDeploymentUsageResponse",
13649
+ '200': "GetVolumeResponse",
12092
13650
  '422': "HTTPValidationError",
12093
13651
  }
12094
13652
  response_data = self.api_client.call_api(
@@ -12098,13 +13656,9 @@ class EXTERNALApi:
12098
13656
  return response_data.response
12099
13657
 
12100
13658
 
12101
- def _get_usage_deployments_usage_deployment_id_get_serialize(
13659
+ def _get_volume_endpoint_volumes_volume_id_get_serialize(
12102
13660
  self,
12103
- deployment_id,
12104
- metric,
12105
- start_time_in_seconds,
12106
- end_time_in_seconds,
12107
- step,
13661
+ volume_id,
12108
13662
  _request_auth,
12109
13663
  _content_type,
12110
13664
  _headers,
@@ -12126,25 +13680,9 @@ class EXTERNALApi:
12126
13680
  _body_params: Optional[bytes] = None
12127
13681
 
12128
13682
  # process the path parameters
12129
- if deployment_id is not None:
12130
- _path_params['deployment_id'] = deployment_id
13683
+ if volume_id is not None:
13684
+ _path_params['volume_id'] = volume_id
12131
13685
  # process the query parameters
12132
- if metric is not None:
12133
-
12134
- _query_params.append(('metric', metric.value))
12135
-
12136
- if start_time_in_seconds is not None:
12137
-
12138
- _query_params.append(('start_time_in_seconds', start_time_in_seconds))
12139
-
12140
- if end_time_in_seconds is not None:
12141
-
12142
- _query_params.append(('end_time_in_seconds', end_time_in_seconds))
12143
-
12144
- if step is not None:
12145
-
12146
- _query_params.append(('step', step))
12147
-
12148
13686
  # process the header parameters
12149
13687
  # process the form parameters
12150
13688
  # process the body parameter
@@ -12166,7 +13704,7 @@ class EXTERNALApi:
12166
13704
 
12167
13705
  return self.api_client.param_serialize(
12168
13706
  method='GET',
12169
- resource_path='/deployments/usage/{deployment_id}',
13707
+ resource_path='/volumes/{volume_id}',
12170
13708
  path_params=_path_params,
12171
13709
  query_params=_query_params,
12172
13710
  header_params=_header_params,
@@ -12183,9 +13721,9 @@ class EXTERNALApi:
12183
13721
 
12184
13722
 
12185
13723
  @validate_call
12186
- def get_user_vault_item_by_id_endpoint_user_vault_secret_id_get(
13724
+ def get_volume_status_endpoint_volumes_status_volume_id_get(
12187
13725
  self,
12188
- secret_id: Annotated[int, Field(strict=True, ge=1)],
13726
+ volume_id: StrictInt,
12189
13727
  _request_timeout: Union[
12190
13728
  None,
12191
13729
  Annotated[StrictFloat, Field(gt=0)],
@@ -12198,13 +13736,13 @@ class EXTERNALApi:
12198
13736
  _content_type: Optional[StrictStr] = None,
12199
13737
  _headers: Optional[Dict[StrictStr, Any]] = None,
12200
13738
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12201
- ) -> UserVaultItem:
12202
- """Get User Vault Item By Id Endpoint
13739
+ ) -> VolumeStatusResponse:
13740
+ """Get Volume Status Endpoint
12203
13741
 
12204
- Resolve a single secret's value. This is the only endpoint that returns a vault value, so it is the single place where read access to secret material is authorized and auditable.
13742
+ Live volume status: status is the stored intent, service_status is computed from the volume app's health and PVC phase.
12205
13743
 
12206
- :param secret_id: (required)
12207
- :type secret_id: int
13744
+ :param volume_id: (required)
13745
+ :type volume_id: int
12208
13746
  :param _request_timeout: timeout setting for this request. If one
12209
13747
  number provided, it will be total request
12210
13748
  timeout. It can also be a pair (tuple) of
@@ -12227,8 +13765,8 @@ class EXTERNALApi:
12227
13765
  :return: Returns the result object.
12228
13766
  """ # noqa: E501
12229
13767
 
12230
- _param = self._get_user_vault_item_by_id_endpoint_user_vault_secret_id_get_serialize(
12231
- secret_id=secret_id,
13768
+ _param = self._get_volume_status_endpoint_volumes_status_volume_id_get_serialize(
13769
+ volume_id=volume_id,
12232
13770
  _request_auth=_request_auth,
12233
13771
  _content_type=_content_type,
12234
13772
  _headers=_headers,
@@ -12236,7 +13774,7 @@ class EXTERNALApi:
12236
13774
  )
12237
13775
 
12238
13776
  _response_types_map: Dict[str, Optional[str]] = {
12239
- '200': "UserVaultItem",
13777
+ '200': "VolumeStatusResponse",
12240
13778
  '422': "HTTPValidationError",
12241
13779
  }
12242
13780
  response_data = self.api_client.call_api(
@@ -12251,9 +13789,9 @@ class EXTERNALApi:
12251
13789
 
12252
13790
 
12253
13791
  @validate_call
12254
- def get_user_vault_item_by_id_endpoint_user_vault_secret_id_get_with_http_info(
13792
+ def get_volume_status_endpoint_volumes_status_volume_id_get_with_http_info(
12255
13793
  self,
12256
- secret_id: Annotated[int, Field(strict=True, ge=1)],
13794
+ volume_id: StrictInt,
12257
13795
  _request_timeout: Union[
12258
13796
  None,
12259
13797
  Annotated[StrictFloat, Field(gt=0)],
@@ -12266,13 +13804,13 @@ class EXTERNALApi:
12266
13804
  _content_type: Optional[StrictStr] = None,
12267
13805
  _headers: Optional[Dict[StrictStr, Any]] = None,
12268
13806
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12269
- ) -> ApiResponse[UserVaultItem]:
12270
- """Get User Vault Item By Id Endpoint
13807
+ ) -> ApiResponse[VolumeStatusResponse]:
13808
+ """Get Volume Status Endpoint
12271
13809
 
12272
- Resolve a single secret's value. This is the only endpoint that returns a vault value, so it is the single place where read access to secret material is authorized and auditable.
13810
+ Live volume status: status is the stored intent, service_status is computed from the volume app's health and PVC phase.
12273
13811
 
12274
- :param secret_id: (required)
12275
- :type secret_id: int
13812
+ :param volume_id: (required)
13813
+ :type volume_id: int
12276
13814
  :param _request_timeout: timeout setting for this request. If one
12277
13815
  number provided, it will be total request
12278
13816
  timeout. It can also be a pair (tuple) of
@@ -12295,8 +13833,8 @@ class EXTERNALApi:
12295
13833
  :return: Returns the result object.
12296
13834
  """ # noqa: E501
12297
13835
 
12298
- _param = self._get_user_vault_item_by_id_endpoint_user_vault_secret_id_get_serialize(
12299
- secret_id=secret_id,
13836
+ _param = self._get_volume_status_endpoint_volumes_status_volume_id_get_serialize(
13837
+ volume_id=volume_id,
12300
13838
  _request_auth=_request_auth,
12301
13839
  _content_type=_content_type,
12302
13840
  _headers=_headers,
@@ -12304,7 +13842,7 @@ class EXTERNALApi:
12304
13842
  )
12305
13843
 
12306
13844
  _response_types_map: Dict[str, Optional[str]] = {
12307
- '200': "UserVaultItem",
13845
+ '200': "VolumeStatusResponse",
12308
13846
  '422': "HTTPValidationError",
12309
13847
  }
12310
13848
  response_data = self.api_client.call_api(
@@ -12319,9 +13857,9 @@ class EXTERNALApi:
12319
13857
 
12320
13858
 
12321
13859
  @validate_call
12322
- def get_user_vault_item_by_id_endpoint_user_vault_secret_id_get_without_preload_content(
13860
+ def get_volume_status_endpoint_volumes_status_volume_id_get_without_preload_content(
12323
13861
  self,
12324
- secret_id: Annotated[int, Field(strict=True, ge=1)],
13862
+ volume_id: StrictInt,
12325
13863
  _request_timeout: Union[
12326
13864
  None,
12327
13865
  Annotated[StrictFloat, Field(gt=0)],
@@ -12335,12 +13873,12 @@ class EXTERNALApi:
12335
13873
  _headers: Optional[Dict[StrictStr, Any]] = None,
12336
13874
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12337
13875
  ) -> RESTResponseType:
12338
- """Get User Vault Item By Id Endpoint
13876
+ """Get Volume Status Endpoint
12339
13877
 
12340
- Resolve a single secret's value. This is the only endpoint that returns a vault value, so it is the single place where read access to secret material is authorized and auditable.
13878
+ Live volume status: status is the stored intent, service_status is computed from the volume app's health and PVC phase.
12341
13879
 
12342
- :param secret_id: (required)
12343
- :type secret_id: int
13880
+ :param volume_id: (required)
13881
+ :type volume_id: int
12344
13882
  :param _request_timeout: timeout setting for this request. If one
12345
13883
  number provided, it will be total request
12346
13884
  timeout. It can also be a pair (tuple) of
@@ -12363,8 +13901,8 @@ class EXTERNALApi:
12363
13901
  :return: Returns the result object.
12364
13902
  """ # noqa: E501
12365
13903
 
12366
- _param = self._get_user_vault_item_by_id_endpoint_user_vault_secret_id_get_serialize(
12367
- secret_id=secret_id,
13904
+ _param = self._get_volume_status_endpoint_volumes_status_volume_id_get_serialize(
13905
+ volume_id=volume_id,
12368
13906
  _request_auth=_request_auth,
12369
13907
  _content_type=_content_type,
12370
13908
  _headers=_headers,
@@ -12372,7 +13910,7 @@ class EXTERNALApi:
12372
13910
  )
12373
13911
 
12374
13912
  _response_types_map: Dict[str, Optional[str]] = {
12375
- '200': "UserVaultItem",
13913
+ '200': "VolumeStatusResponse",
12376
13914
  '422': "HTTPValidationError",
12377
13915
  }
12378
13916
  response_data = self.api_client.call_api(
@@ -12382,9 +13920,9 @@ class EXTERNALApi:
12382
13920
  return response_data.response
12383
13921
 
12384
13922
 
12385
- def _get_user_vault_item_by_id_endpoint_user_vault_secret_id_get_serialize(
13923
+ def _get_volume_status_endpoint_volumes_status_volume_id_get_serialize(
12386
13924
  self,
12387
- secret_id,
13925
+ volume_id,
12388
13926
  _request_auth,
12389
13927
  _content_type,
12390
13928
  _headers,
@@ -12406,8 +13944,8 @@ class EXTERNALApi:
12406
13944
  _body_params: Optional[bytes] = None
12407
13945
 
12408
13946
  # process the path parameters
12409
- if secret_id is not None:
12410
- _path_params['secret_id'] = secret_id
13947
+ if volume_id is not None:
13948
+ _path_params['volume_id'] = volume_id
12411
13949
  # process the query parameters
12412
13950
  # process the header parameters
12413
13951
  # process the form parameters
@@ -12430,7 +13968,7 @@ class EXTERNALApi:
12430
13968
 
12431
13969
  return self.api_client.param_serialize(
12432
13970
  method='GET',
12433
- resource_path='/user_vault/{secret_id}',
13971
+ resource_path='/volumes/status/{volume_id}',
12434
13972
  path_params=_path_params,
12435
13973
  query_params=_query_params,
12436
13974
  header_params=_header_params,
@@ -12447,9 +13985,9 @@ class EXTERNALApi:
12447
13985
 
12448
13986
 
12449
13987
  @validate_call
12450
- def get_volume_endpoint_volumes_volume_id_get(
13988
+ def invite_user_organizations_invite_post(
12451
13989
  self,
12452
- volume_id: StrictInt,
13990
+ invite_user_request: InviteUserRequest,
12453
13991
  _request_timeout: Union[
12454
13992
  None,
12455
13993
  Annotated[StrictFloat, Field(gt=0)],
@@ -12462,13 +14000,12 @@ class EXTERNALApi:
12462
14000
  _content_type: Optional[StrictStr] = None,
12463
14001
  _headers: Optional[Dict[StrictStr, Any]] = None,
12464
14002
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12465
- ) -> GetVolumeResponse:
12466
- """Get Volume Endpoint
14003
+ ) -> object:
14004
+ """Invite User
12467
14005
 
12468
- Retrieve a single volume by id.
12469
14006
 
12470
- :param volume_id: (required)
12471
- :type volume_id: int
14007
+ :param invite_user_request: (required)
14008
+ :type invite_user_request: InviteUserRequest
12472
14009
  :param _request_timeout: timeout setting for this request. If one
12473
14010
  number provided, it will be total request
12474
14011
  timeout. It can also be a pair (tuple) of
@@ -12491,8 +14028,8 @@ class EXTERNALApi:
12491
14028
  :return: Returns the result object.
12492
14029
  """ # noqa: E501
12493
14030
 
12494
- _param = self._get_volume_endpoint_volumes_volume_id_get_serialize(
12495
- volume_id=volume_id,
14031
+ _param = self._invite_user_organizations_invite_post_serialize(
14032
+ invite_user_request=invite_user_request,
12496
14033
  _request_auth=_request_auth,
12497
14034
  _content_type=_content_type,
12498
14035
  _headers=_headers,
@@ -12500,7 +14037,7 @@ class EXTERNALApi:
12500
14037
  )
12501
14038
 
12502
14039
  _response_types_map: Dict[str, Optional[str]] = {
12503
- '200': "GetVolumeResponse",
14040
+ '200': "object",
12504
14041
  '422': "HTTPValidationError",
12505
14042
  }
12506
14043
  response_data = self.api_client.call_api(
@@ -12515,9 +14052,9 @@ class EXTERNALApi:
12515
14052
 
12516
14053
 
12517
14054
  @validate_call
12518
- def get_volume_endpoint_volumes_volume_id_get_with_http_info(
14055
+ def invite_user_organizations_invite_post_with_http_info(
12519
14056
  self,
12520
- volume_id: StrictInt,
14057
+ invite_user_request: InviteUserRequest,
12521
14058
  _request_timeout: Union[
12522
14059
  None,
12523
14060
  Annotated[StrictFloat, Field(gt=0)],
@@ -12530,13 +14067,12 @@ class EXTERNALApi:
12530
14067
  _content_type: Optional[StrictStr] = None,
12531
14068
  _headers: Optional[Dict[StrictStr, Any]] = None,
12532
14069
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12533
- ) -> ApiResponse[GetVolumeResponse]:
12534
- """Get Volume Endpoint
14070
+ ) -> ApiResponse[object]:
14071
+ """Invite User
12535
14072
 
12536
- Retrieve a single volume by id.
12537
14073
 
12538
- :param volume_id: (required)
12539
- :type volume_id: int
14074
+ :param invite_user_request: (required)
14075
+ :type invite_user_request: InviteUserRequest
12540
14076
  :param _request_timeout: timeout setting for this request. If one
12541
14077
  number provided, it will be total request
12542
14078
  timeout. It can also be a pair (tuple) of
@@ -12559,8 +14095,8 @@ class EXTERNALApi:
12559
14095
  :return: Returns the result object.
12560
14096
  """ # noqa: E501
12561
14097
 
12562
- _param = self._get_volume_endpoint_volumes_volume_id_get_serialize(
12563
- volume_id=volume_id,
14098
+ _param = self._invite_user_organizations_invite_post_serialize(
14099
+ invite_user_request=invite_user_request,
12564
14100
  _request_auth=_request_auth,
12565
14101
  _content_type=_content_type,
12566
14102
  _headers=_headers,
@@ -12568,7 +14104,7 @@ class EXTERNALApi:
12568
14104
  )
12569
14105
 
12570
14106
  _response_types_map: Dict[str, Optional[str]] = {
12571
- '200': "GetVolumeResponse",
14107
+ '200': "object",
12572
14108
  '422': "HTTPValidationError",
12573
14109
  }
12574
14110
  response_data = self.api_client.call_api(
@@ -12583,9 +14119,9 @@ class EXTERNALApi:
12583
14119
 
12584
14120
 
12585
14121
  @validate_call
12586
- def get_volume_endpoint_volumes_volume_id_get_without_preload_content(
14122
+ def invite_user_organizations_invite_post_without_preload_content(
12587
14123
  self,
12588
- volume_id: StrictInt,
14124
+ invite_user_request: InviteUserRequest,
12589
14125
  _request_timeout: Union[
12590
14126
  None,
12591
14127
  Annotated[StrictFloat, Field(gt=0)],
@@ -12599,12 +14135,11 @@ class EXTERNALApi:
12599
14135
  _headers: Optional[Dict[StrictStr, Any]] = None,
12600
14136
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12601
14137
  ) -> RESTResponseType:
12602
- """Get Volume Endpoint
14138
+ """Invite User
12603
14139
 
12604
- Retrieve a single volume by id.
12605
14140
 
12606
- :param volume_id: (required)
12607
- :type volume_id: int
14141
+ :param invite_user_request: (required)
14142
+ :type invite_user_request: InviteUserRequest
12608
14143
  :param _request_timeout: timeout setting for this request. If one
12609
14144
  number provided, it will be total request
12610
14145
  timeout. It can also be a pair (tuple) of
@@ -12627,8 +14162,8 @@ class EXTERNALApi:
12627
14162
  :return: Returns the result object.
12628
14163
  """ # noqa: E501
12629
14164
 
12630
- _param = self._get_volume_endpoint_volumes_volume_id_get_serialize(
12631
- volume_id=volume_id,
14165
+ _param = self._invite_user_organizations_invite_post_serialize(
14166
+ invite_user_request=invite_user_request,
12632
14167
  _request_auth=_request_auth,
12633
14168
  _content_type=_content_type,
12634
14169
  _headers=_headers,
@@ -12636,7 +14171,7 @@ class EXTERNALApi:
12636
14171
  )
12637
14172
 
12638
14173
  _response_types_map: Dict[str, Optional[str]] = {
12639
- '200': "GetVolumeResponse",
14174
+ '200': "object",
12640
14175
  '422': "HTTPValidationError",
12641
14176
  }
12642
14177
  response_data = self.api_client.call_api(
@@ -12646,9 +14181,9 @@ class EXTERNALApi:
12646
14181
  return response_data.response
12647
14182
 
12648
14183
 
12649
- def _get_volume_endpoint_volumes_volume_id_get_serialize(
14184
+ def _invite_user_organizations_invite_post_serialize(
12650
14185
  self,
12651
- volume_id,
14186
+ invite_user_request,
12652
14187
  _request_auth,
12653
14188
  _content_type,
12654
14189
  _headers,
@@ -12670,12 +14205,12 @@ class EXTERNALApi:
12670
14205
  _body_params: Optional[bytes] = None
12671
14206
 
12672
14207
  # process the path parameters
12673
- if volume_id is not None:
12674
- _path_params['volume_id'] = volume_id
12675
14208
  # process the query parameters
12676
14209
  # process the header parameters
12677
14210
  # process the form parameters
12678
14211
  # process the body parameter
14212
+ if invite_user_request is not None:
14213
+ _body_params = invite_user_request
12679
14214
 
12680
14215
 
12681
14216
  # set the HTTP header `Accept`
@@ -12686,6 +14221,19 @@ class EXTERNALApi:
12686
14221
  ]
12687
14222
  )
12688
14223
 
14224
+ # set the HTTP header `Content-Type`
14225
+ if _content_type:
14226
+ _header_params['Content-Type'] = _content_type
14227
+ else:
14228
+ _default_content_type = (
14229
+ self.api_client.select_header_content_type(
14230
+ [
14231
+ 'application/json'
14232
+ ]
14233
+ )
14234
+ )
14235
+ if _default_content_type is not None:
14236
+ _header_params['Content-Type'] = _default_content_type
12689
14237
 
12690
14238
  # authentication setting
12691
14239
  _auth_settings: List[str] = [
@@ -12693,8 +14241,8 @@ class EXTERNALApi:
12693
14241
  ]
12694
14242
 
12695
14243
  return self.api_client.param_serialize(
12696
- method='GET',
12697
- resource_path='/volumes/{volume_id}',
14244
+ method='POST',
14245
+ resource_path='/organizations/invite',
12698
14246
  path_params=_path_params,
12699
14247
  query_params=_query_params,
12700
14248
  header_params=_header_params,
@@ -12711,9 +14259,9 @@ class EXTERNALApi:
12711
14259
 
12712
14260
 
12713
14261
  @validate_call
12714
- def get_volume_status_endpoint_volumes_status_volume_id_get(
14262
+ def list_cluster_capacity_capacity_get(
12715
14263
  self,
12716
- volume_id: StrictInt,
14264
+ cluster_id: Optional[StrictInt] = None,
12717
14265
  _request_timeout: Union[
12718
14266
  None,
12719
14267
  Annotated[StrictFloat, Field(gt=0)],
@@ -12726,13 +14274,13 @@ class EXTERNALApi:
12726
14274
  _content_type: Optional[StrictStr] = None,
12727
14275
  _headers: Optional[Dict[StrictStr, Any]] = None,
12728
14276
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12729
- ) -> VolumeStatusResponse:
12730
- """Get Volume Status Endpoint
14277
+ ) -> ListClusterCapacityResponse:
14278
+ """List Cluster Capacity
12731
14279
 
12732
- Live volume status: status is the stored intent, service_status is computed from the volume app's health and PVC phase.
14280
+ Return GPU capacity breakdown for accessible clusters. When *cluster_id* is supplied only that cluster is included (if accessible). Clusters whose Prometheus data is unavailable are omitted from the results rather than failing the entire request.
12733
14281
 
12734
- :param volume_id: (required)
12735
- :type volume_id: int
14282
+ :param cluster_id:
14283
+ :type cluster_id: int
12736
14284
  :param _request_timeout: timeout setting for this request. If one
12737
14285
  number provided, it will be total request
12738
14286
  timeout. It can also be a pair (tuple) of
@@ -12755,8 +14303,8 @@ class EXTERNALApi:
12755
14303
  :return: Returns the result object.
12756
14304
  """ # noqa: E501
12757
14305
 
12758
- _param = self._get_volume_status_endpoint_volumes_status_volume_id_get_serialize(
12759
- volume_id=volume_id,
14306
+ _param = self._list_cluster_capacity_capacity_get_serialize(
14307
+ cluster_id=cluster_id,
12760
14308
  _request_auth=_request_auth,
12761
14309
  _content_type=_content_type,
12762
14310
  _headers=_headers,
@@ -12764,7 +14312,7 @@ class EXTERNALApi:
12764
14312
  )
12765
14313
 
12766
14314
  _response_types_map: Dict[str, Optional[str]] = {
12767
- '200': "VolumeStatusResponse",
14315
+ '200': "ListClusterCapacityResponse",
12768
14316
  '422': "HTTPValidationError",
12769
14317
  }
12770
14318
  response_data = self.api_client.call_api(
@@ -12779,9 +14327,9 @@ class EXTERNALApi:
12779
14327
 
12780
14328
 
12781
14329
  @validate_call
12782
- def get_volume_status_endpoint_volumes_status_volume_id_get_with_http_info(
14330
+ def list_cluster_capacity_capacity_get_with_http_info(
12783
14331
  self,
12784
- volume_id: StrictInt,
14332
+ cluster_id: Optional[StrictInt] = None,
12785
14333
  _request_timeout: Union[
12786
14334
  None,
12787
14335
  Annotated[StrictFloat, Field(gt=0)],
@@ -12794,13 +14342,13 @@ class EXTERNALApi:
12794
14342
  _content_type: Optional[StrictStr] = None,
12795
14343
  _headers: Optional[Dict[StrictStr, Any]] = None,
12796
14344
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12797
- ) -> ApiResponse[VolumeStatusResponse]:
12798
- """Get Volume Status Endpoint
14345
+ ) -> ApiResponse[ListClusterCapacityResponse]:
14346
+ """List Cluster Capacity
12799
14347
 
12800
- Live volume status: status is the stored intent, service_status is computed from the volume app's health and PVC phase.
14348
+ Return GPU capacity breakdown for accessible clusters. When *cluster_id* is supplied only that cluster is included (if accessible). Clusters whose Prometheus data is unavailable are omitted from the results rather than failing the entire request.
12801
14349
 
12802
- :param volume_id: (required)
12803
- :type volume_id: int
14350
+ :param cluster_id:
14351
+ :type cluster_id: int
12804
14352
  :param _request_timeout: timeout setting for this request. If one
12805
14353
  number provided, it will be total request
12806
14354
  timeout. It can also be a pair (tuple) of
@@ -12823,8 +14371,8 @@ class EXTERNALApi:
12823
14371
  :return: Returns the result object.
12824
14372
  """ # noqa: E501
12825
14373
 
12826
- _param = self._get_volume_status_endpoint_volumes_status_volume_id_get_serialize(
12827
- volume_id=volume_id,
14374
+ _param = self._list_cluster_capacity_capacity_get_serialize(
14375
+ cluster_id=cluster_id,
12828
14376
  _request_auth=_request_auth,
12829
14377
  _content_type=_content_type,
12830
14378
  _headers=_headers,
@@ -12832,7 +14380,7 @@ class EXTERNALApi:
12832
14380
  )
12833
14381
 
12834
14382
  _response_types_map: Dict[str, Optional[str]] = {
12835
- '200': "VolumeStatusResponse",
14383
+ '200': "ListClusterCapacityResponse",
12836
14384
  '422': "HTTPValidationError",
12837
14385
  }
12838
14386
  response_data = self.api_client.call_api(
@@ -12847,9 +14395,9 @@ class EXTERNALApi:
12847
14395
 
12848
14396
 
12849
14397
  @validate_call
12850
- def get_volume_status_endpoint_volumes_status_volume_id_get_without_preload_content(
14398
+ def list_cluster_capacity_capacity_get_without_preload_content(
12851
14399
  self,
12852
- volume_id: StrictInt,
14400
+ cluster_id: Optional[StrictInt] = None,
12853
14401
  _request_timeout: Union[
12854
14402
  None,
12855
14403
  Annotated[StrictFloat, Field(gt=0)],
@@ -12863,12 +14411,12 @@ class EXTERNALApi:
12863
14411
  _headers: Optional[Dict[StrictStr, Any]] = None,
12864
14412
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12865
14413
  ) -> RESTResponseType:
12866
- """Get Volume Status Endpoint
14414
+ """List Cluster Capacity
12867
14415
 
12868
- Live volume status: status is the stored intent, service_status is computed from the volume app's health and PVC phase.
14416
+ Return GPU capacity breakdown for accessible clusters. When *cluster_id* is supplied only that cluster is included (if accessible). Clusters whose Prometheus data is unavailable are omitted from the results rather than failing the entire request.
12869
14417
 
12870
- :param volume_id: (required)
12871
- :type volume_id: int
14418
+ :param cluster_id:
14419
+ :type cluster_id: int
12872
14420
  :param _request_timeout: timeout setting for this request. If one
12873
14421
  number provided, it will be total request
12874
14422
  timeout. It can also be a pair (tuple) of
@@ -12891,8 +14439,8 @@ class EXTERNALApi:
12891
14439
  :return: Returns the result object.
12892
14440
  """ # noqa: E501
12893
14441
 
12894
- _param = self._get_volume_status_endpoint_volumes_status_volume_id_get_serialize(
12895
- volume_id=volume_id,
14442
+ _param = self._list_cluster_capacity_capacity_get_serialize(
14443
+ cluster_id=cluster_id,
12896
14444
  _request_auth=_request_auth,
12897
14445
  _content_type=_content_type,
12898
14446
  _headers=_headers,
@@ -12900,7 +14448,7 @@ class EXTERNALApi:
12900
14448
  )
12901
14449
 
12902
14450
  _response_types_map: Dict[str, Optional[str]] = {
12903
- '200': "VolumeStatusResponse",
14451
+ '200': "ListClusterCapacityResponse",
12904
14452
  '422': "HTTPValidationError",
12905
14453
  }
12906
14454
  response_data = self.api_client.call_api(
@@ -12910,9 +14458,9 @@ class EXTERNALApi:
12910
14458
  return response_data.response
12911
14459
 
12912
14460
 
12913
- def _get_volume_status_endpoint_volumes_status_volume_id_get_serialize(
14461
+ def _list_cluster_capacity_capacity_get_serialize(
12914
14462
  self,
12915
- volume_id,
14463
+ cluster_id,
12916
14464
  _request_auth,
12917
14465
  _content_type,
12918
14466
  _headers,
@@ -12934,9 +14482,11 @@ class EXTERNALApi:
12934
14482
  _body_params: Optional[bytes] = None
12935
14483
 
12936
14484
  # process the path parameters
12937
- if volume_id is not None:
12938
- _path_params['volume_id'] = volume_id
12939
14485
  # process the query parameters
14486
+ if cluster_id is not None:
14487
+
14488
+ _query_params.append(('cluster_id', cluster_id))
14489
+
12940
14490
  # process the header parameters
12941
14491
  # process the form parameters
12942
14492
  # process the body parameter
@@ -12958,7 +14508,7 @@ class EXTERNALApi:
12958
14508
 
12959
14509
  return self.api_client.param_serialize(
12960
14510
  method='GET',
12961
- resource_path='/volumes/status/{volume_id}',
14511
+ resource_path='/capacity',
12962
14512
  path_params=_path_params,
12963
14513
  query_params=_query_params,
12964
14514
  header_params=_header_params,
@@ -12975,9 +14525,9 @@ class EXTERNALApi:
12975
14525
 
12976
14526
 
12977
14527
  @validate_call
12978
- def invite_user_organizations_invite_post(
14528
+ def list_cluster_org_gpu_quotas_clusters_cluster_id_gpu_quota_organizations_get(
12979
14529
  self,
12980
- invite_user_request: InviteUserRequest,
14530
+ cluster_id: StrictInt,
12981
14531
  _request_timeout: Union[
12982
14532
  None,
12983
14533
  Annotated[StrictFloat, Field(gt=0)],
@@ -12990,12 +14540,12 @@ class EXTERNALApi:
12990
14540
  _content_type: Optional[StrictStr] = None,
12991
14541
  _headers: Optional[Dict[StrictStr, Any]] = None,
12992
14542
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12993
- ) -> object:
12994
- """Invite User
14543
+ ) -> ListOrganizationGpuQuotaResponse:
14544
+ """List Cluster Org Gpu Quotas
12995
14545
 
12996
14546
 
12997
- :param invite_user_request: (required)
12998
- :type invite_user_request: InviteUserRequest
14547
+ :param cluster_id: (required)
14548
+ :type cluster_id: int
12999
14549
  :param _request_timeout: timeout setting for this request. If one
13000
14550
  number provided, it will be total request
13001
14551
  timeout. It can also be a pair (tuple) of
@@ -13018,8 +14568,8 @@ class EXTERNALApi:
13018
14568
  :return: Returns the result object.
13019
14569
  """ # noqa: E501
13020
14570
 
13021
- _param = self._invite_user_organizations_invite_post_serialize(
13022
- invite_user_request=invite_user_request,
14571
+ _param = self._list_cluster_org_gpu_quotas_clusters_cluster_id_gpu_quota_organizations_get_serialize(
14572
+ cluster_id=cluster_id,
13023
14573
  _request_auth=_request_auth,
13024
14574
  _content_type=_content_type,
13025
14575
  _headers=_headers,
@@ -13027,7 +14577,7 @@ class EXTERNALApi:
13027
14577
  )
13028
14578
 
13029
14579
  _response_types_map: Dict[str, Optional[str]] = {
13030
- '200': "object",
14580
+ '200': "ListOrganizationGpuQuotaResponse",
13031
14581
  '422': "HTTPValidationError",
13032
14582
  }
13033
14583
  response_data = self.api_client.call_api(
@@ -13042,9 +14592,9 @@ class EXTERNALApi:
13042
14592
 
13043
14593
 
13044
14594
  @validate_call
13045
- def invite_user_organizations_invite_post_with_http_info(
14595
+ def list_cluster_org_gpu_quotas_clusters_cluster_id_gpu_quota_organizations_get_with_http_info(
13046
14596
  self,
13047
- invite_user_request: InviteUserRequest,
14597
+ cluster_id: StrictInt,
13048
14598
  _request_timeout: Union[
13049
14599
  None,
13050
14600
  Annotated[StrictFloat, Field(gt=0)],
@@ -13057,12 +14607,12 @@ class EXTERNALApi:
13057
14607
  _content_type: Optional[StrictStr] = None,
13058
14608
  _headers: Optional[Dict[StrictStr, Any]] = None,
13059
14609
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13060
- ) -> ApiResponse[object]:
13061
- """Invite User
14610
+ ) -> ApiResponse[ListOrganizationGpuQuotaResponse]:
14611
+ """List Cluster Org Gpu Quotas
13062
14612
 
13063
14613
 
13064
- :param invite_user_request: (required)
13065
- :type invite_user_request: InviteUserRequest
14614
+ :param cluster_id: (required)
14615
+ :type cluster_id: int
13066
14616
  :param _request_timeout: timeout setting for this request. If one
13067
14617
  number provided, it will be total request
13068
14618
  timeout. It can also be a pair (tuple) of
@@ -13085,8 +14635,8 @@ class EXTERNALApi:
13085
14635
  :return: Returns the result object.
13086
14636
  """ # noqa: E501
13087
14637
 
13088
- _param = self._invite_user_organizations_invite_post_serialize(
13089
- invite_user_request=invite_user_request,
14638
+ _param = self._list_cluster_org_gpu_quotas_clusters_cluster_id_gpu_quota_organizations_get_serialize(
14639
+ cluster_id=cluster_id,
13090
14640
  _request_auth=_request_auth,
13091
14641
  _content_type=_content_type,
13092
14642
  _headers=_headers,
@@ -13094,7 +14644,7 @@ class EXTERNALApi:
13094
14644
  )
13095
14645
 
13096
14646
  _response_types_map: Dict[str, Optional[str]] = {
13097
- '200': "object",
14647
+ '200': "ListOrganizationGpuQuotaResponse",
13098
14648
  '422': "HTTPValidationError",
13099
14649
  }
13100
14650
  response_data = self.api_client.call_api(
@@ -13109,9 +14659,9 @@ class EXTERNALApi:
13109
14659
 
13110
14660
 
13111
14661
  @validate_call
13112
- def invite_user_organizations_invite_post_without_preload_content(
14662
+ def list_cluster_org_gpu_quotas_clusters_cluster_id_gpu_quota_organizations_get_without_preload_content(
13113
14663
  self,
13114
- invite_user_request: InviteUserRequest,
14664
+ cluster_id: StrictInt,
13115
14665
  _request_timeout: Union[
13116
14666
  None,
13117
14667
  Annotated[StrictFloat, Field(gt=0)],
@@ -13125,11 +14675,11 @@ class EXTERNALApi:
13125
14675
  _headers: Optional[Dict[StrictStr, Any]] = None,
13126
14676
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13127
14677
  ) -> RESTResponseType:
13128
- """Invite User
14678
+ """List Cluster Org Gpu Quotas
13129
14679
 
13130
14680
 
13131
- :param invite_user_request: (required)
13132
- :type invite_user_request: InviteUserRequest
14681
+ :param cluster_id: (required)
14682
+ :type cluster_id: int
13133
14683
  :param _request_timeout: timeout setting for this request. If one
13134
14684
  number provided, it will be total request
13135
14685
  timeout. It can also be a pair (tuple) of
@@ -13152,8 +14702,8 @@ class EXTERNALApi:
13152
14702
  :return: Returns the result object.
13153
14703
  """ # noqa: E501
13154
14704
 
13155
- _param = self._invite_user_organizations_invite_post_serialize(
13156
- invite_user_request=invite_user_request,
14705
+ _param = self._list_cluster_org_gpu_quotas_clusters_cluster_id_gpu_quota_organizations_get_serialize(
14706
+ cluster_id=cluster_id,
13157
14707
  _request_auth=_request_auth,
13158
14708
  _content_type=_content_type,
13159
14709
  _headers=_headers,
@@ -13161,7 +14711,7 @@ class EXTERNALApi:
13161
14711
  )
13162
14712
 
13163
14713
  _response_types_map: Dict[str, Optional[str]] = {
13164
- '200': "object",
14714
+ '200': "ListOrganizationGpuQuotaResponse",
13165
14715
  '422': "HTTPValidationError",
13166
14716
  }
13167
14717
  response_data = self.api_client.call_api(
@@ -13171,9 +14721,9 @@ class EXTERNALApi:
13171
14721
  return response_data.response
13172
14722
 
13173
14723
 
13174
- def _invite_user_organizations_invite_post_serialize(
14724
+ def _list_cluster_org_gpu_quotas_clusters_cluster_id_gpu_quota_organizations_get_serialize(
13175
14725
  self,
13176
- invite_user_request,
14726
+ cluster_id,
13177
14727
  _request_auth,
13178
14728
  _content_type,
13179
14729
  _headers,
@@ -13195,12 +14745,12 @@ class EXTERNALApi:
13195
14745
  _body_params: Optional[bytes] = None
13196
14746
 
13197
14747
  # process the path parameters
14748
+ if cluster_id is not None:
14749
+ _path_params['cluster_id'] = cluster_id
13198
14750
  # process the query parameters
13199
14751
  # process the header parameters
13200
14752
  # process the form parameters
13201
14753
  # process the body parameter
13202
- if invite_user_request is not None:
13203
- _body_params = invite_user_request
13204
14754
 
13205
14755
 
13206
14756
  # set the HTTP header `Accept`
@@ -13211,19 +14761,6 @@ class EXTERNALApi:
13211
14761
  ]
13212
14762
  )
13213
14763
 
13214
- # set the HTTP header `Content-Type`
13215
- if _content_type:
13216
- _header_params['Content-Type'] = _content_type
13217
- else:
13218
- _default_content_type = (
13219
- self.api_client.select_header_content_type(
13220
- [
13221
- 'application/json'
13222
- ]
13223
- )
13224
- )
13225
- if _default_content_type is not None:
13226
- _header_params['Content-Type'] = _default_content_type
13227
14764
 
13228
14765
  # authentication setting
13229
14766
  _auth_settings: List[str] = [
@@ -13231,8 +14768,8 @@ class EXTERNALApi:
13231
14768
  ]
13232
14769
 
13233
14770
  return self.api_client.param_serialize(
13234
- method='POST',
13235
- resource_path='/organizations/invite',
14771
+ method='GET',
14772
+ resource_path='/clusters/{cluster_id}/gpu-quota/organizations',
13236
14773
  path_params=_path_params,
13237
14774
  query_params=_query_params,
13238
14775
  header_params=_header_params,
@@ -13249,9 +14786,8 @@ class EXTERNALApi:
13249
14786
 
13250
14787
 
13251
14788
  @validate_call
13252
- def list_cluster_capacity_capacity_get(
14789
+ def list_service_accounts_service_accounts_get(
13253
14790
  self,
13254
- cluster_id: Optional[StrictInt] = None,
13255
14791
  _request_timeout: Union[
13256
14792
  None,
13257
14793
  Annotated[StrictFloat, Field(gt=0)],
@@ -13264,13 +14800,10 @@ class EXTERNALApi:
13264
14800
  _content_type: Optional[StrictStr] = None,
13265
14801
  _headers: Optional[Dict[StrictStr, Any]] = None,
13266
14802
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13267
- ) -> ListClusterCapacityResponse:
13268
- """List Cluster Capacity
14803
+ ) -> ListServiceAccountsResponse:
14804
+ """List Service Accounts
13269
14805
 
13270
- Return GPU capacity breakdown for accessible clusters. When *cluster_id* is supplied only that cluster is included (if accessible). Clusters whose Prometheus data is unavailable are omitted from the results rather than failing the entire request.
13271
14806
 
13272
- :param cluster_id:
13273
- :type cluster_id: int
13274
14807
  :param _request_timeout: timeout setting for this request. If one
13275
14808
  number provided, it will be total request
13276
14809
  timeout. It can also be a pair (tuple) of
@@ -13293,8 +14826,7 @@ class EXTERNALApi:
13293
14826
  :return: Returns the result object.
13294
14827
  """ # noqa: E501
13295
14828
 
13296
- _param = self._list_cluster_capacity_capacity_get_serialize(
13297
- cluster_id=cluster_id,
14829
+ _param = self._list_service_accounts_service_accounts_get_serialize(
13298
14830
  _request_auth=_request_auth,
13299
14831
  _content_type=_content_type,
13300
14832
  _headers=_headers,
@@ -13302,8 +14834,7 @@ class EXTERNALApi:
13302
14834
  )
13303
14835
 
13304
14836
  _response_types_map: Dict[str, Optional[str]] = {
13305
- '200': "ListClusterCapacityResponse",
13306
- '422': "HTTPValidationError",
14837
+ '200': "ListServiceAccountsResponse",
13307
14838
  }
13308
14839
  response_data = self.api_client.call_api(
13309
14840
  *_param,
@@ -13317,9 +14848,8 @@ class EXTERNALApi:
13317
14848
 
13318
14849
 
13319
14850
  @validate_call
13320
- def list_cluster_capacity_capacity_get_with_http_info(
14851
+ def list_service_accounts_service_accounts_get_with_http_info(
13321
14852
  self,
13322
- cluster_id: Optional[StrictInt] = None,
13323
14853
  _request_timeout: Union[
13324
14854
  None,
13325
14855
  Annotated[StrictFloat, Field(gt=0)],
@@ -13332,13 +14862,10 @@ class EXTERNALApi:
13332
14862
  _content_type: Optional[StrictStr] = None,
13333
14863
  _headers: Optional[Dict[StrictStr, Any]] = None,
13334
14864
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13335
- ) -> ApiResponse[ListClusterCapacityResponse]:
13336
- """List Cluster Capacity
14865
+ ) -> ApiResponse[ListServiceAccountsResponse]:
14866
+ """List Service Accounts
13337
14867
 
13338
- Return GPU capacity breakdown for accessible clusters. When *cluster_id* is supplied only that cluster is included (if accessible). Clusters whose Prometheus data is unavailable are omitted from the results rather than failing the entire request.
13339
14868
 
13340
- :param cluster_id:
13341
- :type cluster_id: int
13342
14869
  :param _request_timeout: timeout setting for this request. If one
13343
14870
  number provided, it will be total request
13344
14871
  timeout. It can also be a pair (tuple) of
@@ -13361,8 +14888,7 @@ class EXTERNALApi:
13361
14888
  :return: Returns the result object.
13362
14889
  """ # noqa: E501
13363
14890
 
13364
- _param = self._list_cluster_capacity_capacity_get_serialize(
13365
- cluster_id=cluster_id,
14891
+ _param = self._list_service_accounts_service_accounts_get_serialize(
13366
14892
  _request_auth=_request_auth,
13367
14893
  _content_type=_content_type,
13368
14894
  _headers=_headers,
@@ -13370,8 +14896,7 @@ class EXTERNALApi:
13370
14896
  )
13371
14897
 
13372
14898
  _response_types_map: Dict[str, Optional[str]] = {
13373
- '200': "ListClusterCapacityResponse",
13374
- '422': "HTTPValidationError",
14899
+ '200': "ListServiceAccountsResponse",
13375
14900
  }
13376
14901
  response_data = self.api_client.call_api(
13377
14902
  *_param,
@@ -13385,9 +14910,8 @@ class EXTERNALApi:
13385
14910
 
13386
14911
 
13387
14912
  @validate_call
13388
- def list_cluster_capacity_capacity_get_without_preload_content(
14913
+ def list_service_accounts_service_accounts_get_without_preload_content(
13389
14914
  self,
13390
- cluster_id: Optional[StrictInt] = None,
13391
14915
  _request_timeout: Union[
13392
14916
  None,
13393
14917
  Annotated[StrictFloat, Field(gt=0)],
@@ -13401,12 +14925,9 @@ class EXTERNALApi:
13401
14925
  _headers: Optional[Dict[StrictStr, Any]] = None,
13402
14926
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13403
14927
  ) -> RESTResponseType:
13404
- """List Cluster Capacity
14928
+ """List Service Accounts
13405
14929
 
13406
- Return GPU capacity breakdown for accessible clusters. When *cluster_id* is supplied only that cluster is included (if accessible). Clusters whose Prometheus data is unavailable are omitted from the results rather than failing the entire request.
13407
14930
 
13408
- :param cluster_id:
13409
- :type cluster_id: int
13410
14931
  :param _request_timeout: timeout setting for this request. If one
13411
14932
  number provided, it will be total request
13412
14933
  timeout. It can also be a pair (tuple) of
@@ -13429,8 +14950,7 @@ class EXTERNALApi:
13429
14950
  :return: Returns the result object.
13430
14951
  """ # noqa: E501
13431
14952
 
13432
- _param = self._list_cluster_capacity_capacity_get_serialize(
13433
- cluster_id=cluster_id,
14953
+ _param = self._list_service_accounts_service_accounts_get_serialize(
13434
14954
  _request_auth=_request_auth,
13435
14955
  _content_type=_content_type,
13436
14956
  _headers=_headers,
@@ -13438,8 +14958,7 @@ class EXTERNALApi:
13438
14958
  )
13439
14959
 
13440
14960
  _response_types_map: Dict[str, Optional[str]] = {
13441
- '200': "ListClusterCapacityResponse",
13442
- '422': "HTTPValidationError",
14961
+ '200': "ListServiceAccountsResponse",
13443
14962
  }
13444
14963
  response_data = self.api_client.call_api(
13445
14964
  *_param,
@@ -13448,9 +14967,8 @@ class EXTERNALApi:
13448
14967
  return response_data.response
13449
14968
 
13450
14969
 
13451
- def _list_cluster_capacity_capacity_get_serialize(
14970
+ def _list_service_accounts_service_accounts_get_serialize(
13452
14971
  self,
13453
- cluster_id,
13454
14972
  _request_auth,
13455
14973
  _content_type,
13456
14974
  _headers,
@@ -13473,10 +14991,6 @@ class EXTERNALApi:
13473
14991
 
13474
14992
  # process the path parameters
13475
14993
  # process the query parameters
13476
- if cluster_id is not None:
13477
-
13478
- _query_params.append(('cluster_id', cluster_id))
13479
-
13480
14994
  # process the header parameters
13481
14995
  # process the form parameters
13482
14996
  # process the body parameter
@@ -13498,7 +15012,7 @@ class EXTERNALApi:
13498
15012
 
13499
15013
  return self.api_client.param_serialize(
13500
15014
  method='GET',
13501
- resource_path='/capacity',
15015
+ resource_path='/service-accounts',
13502
15016
  path_params=_path_params,
13503
15017
  query_params=_query_params,
13504
15018
  header_params=_header_params,
@@ -13515,8 +15029,11 @@ class EXTERNALApi:
13515
15029
 
13516
15030
 
13517
15031
  @validate_call
13518
- def list_service_accounts_service_accounts_get(
15032
+ def put_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_put(
13519
15033
  self,
15034
+ cluster_id: StrictInt,
15035
+ organization_id: StrictInt,
15036
+ organization_gpu_quota_request: OrganizationGpuQuotaRequest,
13520
15037
  _request_timeout: Union[
13521
15038
  None,
13522
15039
  Annotated[StrictFloat, Field(gt=0)],
@@ -13529,10 +15046,17 @@ class EXTERNALApi:
13529
15046
  _content_type: Optional[StrictStr] = None,
13530
15047
  _headers: Optional[Dict[StrictStr, Any]] = None,
13531
15048
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13532
- ) -> ListServiceAccountsResponse:
13533
- """List Service Accounts
15049
+ ) -> OrganizationGpuQuotaResponse:
15050
+ """Put Org Gpu Quota On Cluster
13534
15051
 
15052
+ Persist desired organization GPU quota on this cluster. Does not apply KAI Queue CRs. ``gpu_quota`` of -1 is unlimited. Rows are never removed.
13535
15053
 
15054
+ :param cluster_id: (required)
15055
+ :type cluster_id: int
15056
+ :param organization_id: (required)
15057
+ :type organization_id: int
15058
+ :param organization_gpu_quota_request: (required)
15059
+ :type organization_gpu_quota_request: OrganizationGpuQuotaRequest
13536
15060
  :param _request_timeout: timeout setting for this request. If one
13537
15061
  number provided, it will be total request
13538
15062
  timeout. It can also be a pair (tuple) of
@@ -13555,7 +15079,10 @@ class EXTERNALApi:
13555
15079
  :return: Returns the result object.
13556
15080
  """ # noqa: E501
13557
15081
 
13558
- _param = self._list_service_accounts_service_accounts_get_serialize(
15082
+ _param = self._put_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_put_serialize(
15083
+ cluster_id=cluster_id,
15084
+ organization_id=organization_id,
15085
+ organization_gpu_quota_request=organization_gpu_quota_request,
13559
15086
  _request_auth=_request_auth,
13560
15087
  _content_type=_content_type,
13561
15088
  _headers=_headers,
@@ -13563,7 +15090,8 @@ class EXTERNALApi:
13563
15090
  )
13564
15091
 
13565
15092
  _response_types_map: Dict[str, Optional[str]] = {
13566
- '200': "ListServiceAccountsResponse",
15093
+ '200': "OrganizationGpuQuotaResponse",
15094
+ '422': "HTTPValidationError",
13567
15095
  }
13568
15096
  response_data = self.api_client.call_api(
13569
15097
  *_param,
@@ -13577,8 +15105,11 @@ class EXTERNALApi:
13577
15105
 
13578
15106
 
13579
15107
  @validate_call
13580
- def list_service_accounts_service_accounts_get_with_http_info(
15108
+ def put_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_put_with_http_info(
13581
15109
  self,
15110
+ cluster_id: StrictInt,
15111
+ organization_id: StrictInt,
15112
+ organization_gpu_quota_request: OrganizationGpuQuotaRequest,
13582
15113
  _request_timeout: Union[
13583
15114
  None,
13584
15115
  Annotated[StrictFloat, Field(gt=0)],
@@ -13591,10 +15122,17 @@ class EXTERNALApi:
13591
15122
  _content_type: Optional[StrictStr] = None,
13592
15123
  _headers: Optional[Dict[StrictStr, Any]] = None,
13593
15124
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13594
- ) -> ApiResponse[ListServiceAccountsResponse]:
13595
- """List Service Accounts
15125
+ ) -> ApiResponse[OrganizationGpuQuotaResponse]:
15126
+ """Put Org Gpu Quota On Cluster
13596
15127
 
15128
+ Persist desired organization GPU quota on this cluster. Does not apply KAI Queue CRs. ``gpu_quota`` of -1 is unlimited. Rows are never removed.
13597
15129
 
15130
+ :param cluster_id: (required)
15131
+ :type cluster_id: int
15132
+ :param organization_id: (required)
15133
+ :type organization_id: int
15134
+ :param organization_gpu_quota_request: (required)
15135
+ :type organization_gpu_quota_request: OrganizationGpuQuotaRequest
13598
15136
  :param _request_timeout: timeout setting for this request. If one
13599
15137
  number provided, it will be total request
13600
15138
  timeout. It can also be a pair (tuple) of
@@ -13617,7 +15155,10 @@ class EXTERNALApi:
13617
15155
  :return: Returns the result object.
13618
15156
  """ # noqa: E501
13619
15157
 
13620
- _param = self._list_service_accounts_service_accounts_get_serialize(
15158
+ _param = self._put_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_put_serialize(
15159
+ cluster_id=cluster_id,
15160
+ organization_id=organization_id,
15161
+ organization_gpu_quota_request=organization_gpu_quota_request,
13621
15162
  _request_auth=_request_auth,
13622
15163
  _content_type=_content_type,
13623
15164
  _headers=_headers,
@@ -13625,7 +15166,8 @@ class EXTERNALApi:
13625
15166
  )
13626
15167
 
13627
15168
  _response_types_map: Dict[str, Optional[str]] = {
13628
- '200': "ListServiceAccountsResponse",
15169
+ '200': "OrganizationGpuQuotaResponse",
15170
+ '422': "HTTPValidationError",
13629
15171
  }
13630
15172
  response_data = self.api_client.call_api(
13631
15173
  *_param,
@@ -13639,8 +15181,11 @@ class EXTERNALApi:
13639
15181
 
13640
15182
 
13641
15183
  @validate_call
13642
- def list_service_accounts_service_accounts_get_without_preload_content(
15184
+ def put_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_put_without_preload_content(
13643
15185
  self,
15186
+ cluster_id: StrictInt,
15187
+ organization_id: StrictInt,
15188
+ organization_gpu_quota_request: OrganizationGpuQuotaRequest,
13644
15189
  _request_timeout: Union[
13645
15190
  None,
13646
15191
  Annotated[StrictFloat, Field(gt=0)],
@@ -13654,9 +15199,16 @@ class EXTERNALApi:
13654
15199
  _headers: Optional[Dict[StrictStr, Any]] = None,
13655
15200
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13656
15201
  ) -> RESTResponseType:
13657
- """List Service Accounts
15202
+ """Put Org Gpu Quota On Cluster
13658
15203
 
15204
+ Persist desired organization GPU quota on this cluster. Does not apply KAI Queue CRs. ``gpu_quota`` of -1 is unlimited. Rows are never removed.
13659
15205
 
15206
+ :param cluster_id: (required)
15207
+ :type cluster_id: int
15208
+ :param organization_id: (required)
15209
+ :type organization_id: int
15210
+ :param organization_gpu_quota_request: (required)
15211
+ :type organization_gpu_quota_request: OrganizationGpuQuotaRequest
13660
15212
  :param _request_timeout: timeout setting for this request. If one
13661
15213
  number provided, it will be total request
13662
15214
  timeout. It can also be a pair (tuple) of
@@ -13679,7 +15231,10 @@ class EXTERNALApi:
13679
15231
  :return: Returns the result object.
13680
15232
  """ # noqa: E501
13681
15233
 
13682
- _param = self._list_service_accounts_service_accounts_get_serialize(
15234
+ _param = self._put_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_put_serialize(
15235
+ cluster_id=cluster_id,
15236
+ organization_id=organization_id,
15237
+ organization_gpu_quota_request=organization_gpu_quota_request,
13683
15238
  _request_auth=_request_auth,
13684
15239
  _content_type=_content_type,
13685
15240
  _headers=_headers,
@@ -13687,7 +15242,8 @@ class EXTERNALApi:
13687
15242
  )
13688
15243
 
13689
15244
  _response_types_map: Dict[str, Optional[str]] = {
13690
- '200': "ListServiceAccountsResponse",
15245
+ '200': "OrganizationGpuQuotaResponse",
15246
+ '422': "HTTPValidationError",
13691
15247
  }
13692
15248
  response_data = self.api_client.call_api(
13693
15249
  *_param,
@@ -13696,8 +15252,11 @@ class EXTERNALApi:
13696
15252
  return response_data.response
13697
15253
 
13698
15254
 
13699
- def _list_service_accounts_service_accounts_get_serialize(
15255
+ def _put_org_gpu_quota_on_cluster_clusters_cluster_id_organizations_organization_id_gpu_quota_put_serialize(
13700
15256
  self,
15257
+ cluster_id,
15258
+ organization_id,
15259
+ organization_gpu_quota_request,
13701
15260
  _request_auth,
13702
15261
  _content_type,
13703
15262
  _headers,
@@ -13719,10 +15278,16 @@ class EXTERNALApi:
13719
15278
  _body_params: Optional[bytes] = None
13720
15279
 
13721
15280
  # process the path parameters
15281
+ if cluster_id is not None:
15282
+ _path_params['cluster_id'] = cluster_id
15283
+ if organization_id is not None:
15284
+ _path_params['organization_id'] = organization_id
13722
15285
  # process the query parameters
13723
15286
  # process the header parameters
13724
15287
  # process the form parameters
13725
15288
  # process the body parameter
15289
+ if organization_gpu_quota_request is not None:
15290
+ _body_params = organization_gpu_quota_request
13726
15291
 
13727
15292
 
13728
15293
  # set the HTTP header `Accept`
@@ -13733,6 +15298,19 @@ class EXTERNALApi:
13733
15298
  ]
13734
15299
  )
13735
15300
 
15301
+ # set the HTTP header `Content-Type`
15302
+ if _content_type:
15303
+ _header_params['Content-Type'] = _content_type
15304
+ else:
15305
+ _default_content_type = (
15306
+ self.api_client.select_header_content_type(
15307
+ [
15308
+ 'application/json'
15309
+ ]
15310
+ )
15311
+ )
15312
+ if _default_content_type is not None:
15313
+ _header_params['Content-Type'] = _default_content_type
13736
15314
 
13737
15315
  # authentication setting
13738
15316
  _auth_settings: List[str] = [
@@ -13740,8 +15318,8 @@ class EXTERNALApi:
13740
15318
  ]
13741
15319
 
13742
15320
  return self.api_client.param_serialize(
13743
- method='GET',
13744
- resource_path='/service-accounts',
15321
+ method='PUT',
15322
+ resource_path='/clusters/{cluster_id}/organizations/{organization_id}/gpu-quota',
13745
15323
  path_params=_path_params,
13746
15324
  query_params=_query_params,
13747
15325
  header_params=_header_params,