Skip to content

Commit e32b795

Browse files
yinghsienwucopybara-github
yinghsienwu
authored and
copybara-github
committed
feat: Update Client.api_client from private to public
PiperOrigin-RevId: 738550922
1 parent 6cc60b5 commit e32b795

32 files changed

+739
-751
lines changed

‎google/genai/_api_module.py

+2-2
Original file line numberDiff line numberDiff line change
@@ -22,8 +22,8 @@
2222
class BaseModule:
2323

2424
def __init__(self, api_client_: _api_client.BaseApiClient):
25-
self._api_client = api_client_
25+
self.api_client = api_client_
2626

2727
@property
2828
def vertexai(self) -> Optional[bool]:
29-
return self._api_client.vertexai
29+
return self.api_client.vertexai

‎google/genai/batches.py

+62-62
Original file line numberDiff line numberDiff line change
@@ -647,11 +647,11 @@ def _create(
647647
)
648648

649649
request_url_dict: Optional[dict[str, str]]
650-
if not self._api_client.vertexai:
650+
if not self.api_client.vertexai:
651651
raise ValueError('This method is only supported in the Vertex AI client.')
652652
else:
653653
request_dict = _CreateBatchJobParameters_to_vertex(
654-
self._api_client, parameter_model
654+
self.api_client, parameter_model
655655
)
656656
request_url_dict = request_dict.get('_url')
657657
if request_url_dict:
@@ -674,19 +674,19 @@ def _create(
674674
request_dict = _common.convert_to_dict(request_dict)
675675
request_dict = _common.encode_unserializable_types(request_dict)
676676

677-
response_dict = self._api_client.request(
677+
response_dict = self.api_client.request(
678678
'post', path, request_dict, http_options
679679
)
680680

681-
if self._api_client.vertexai:
682-
response_dict = _BatchJob_from_vertex(self._api_client, response_dict)
681+
if self.api_client.vertexai:
682+
response_dict = _BatchJob_from_vertex(self.api_client, response_dict)
683683
else:
684-
response_dict = _BatchJob_from_mldev(self._api_client, response_dict)
684+
response_dict = _BatchJob_from_mldev(self.api_client, response_dict)
685685

686686
return_value = types.BatchJob._from_response(
687687
response=response_dict, kwargs=parameter_model.model_dump()
688688
)
689-
self._api_client._verify_response(return_value)
689+
self.api_client._verify_response(return_value)
690690
return return_value
691691

692692
def get(
@@ -716,11 +716,11 @@ def get(
716716
)
717717

718718
request_url_dict: Optional[dict[str, str]]
719-
if not self._api_client.vertexai:
719+
if not self.api_client.vertexai:
720720
raise ValueError('This method is only supported in the Vertex AI client.')
721721
else:
722722
request_dict = _GetBatchJobParameters_to_vertex(
723-
self._api_client, parameter_model
723+
self.api_client, parameter_model
724724
)
725725
request_url_dict = request_dict.get('_url')
726726
if request_url_dict:
@@ -743,19 +743,19 @@ def get(
743743
request_dict = _common.convert_to_dict(request_dict)
744744
request_dict = _common.encode_unserializable_types(request_dict)
745745

746-
response_dict = self._api_client.request(
746+
response_dict = self.api_client.request(
747747
'get', path, request_dict, http_options
748748
)
749749

750-
if self._api_client.vertexai:
751-
response_dict = _BatchJob_from_vertex(self._api_client, response_dict)
750+
if self.api_client.vertexai:
751+
response_dict = _BatchJob_from_vertex(self.api_client, response_dict)
752752
else:
753-
response_dict = _BatchJob_from_mldev(self._api_client, response_dict)
753+
response_dict = _BatchJob_from_mldev(self.api_client, response_dict)
754754

755755
return_value = types.BatchJob._from_response(
756756
response=response_dict, kwargs=parameter_model.model_dump()
757757
)
758-
self._api_client._verify_response(return_value)
758+
self.api_client._verify_response(return_value)
759759
return return_value
760760

761761
def cancel(
@@ -786,11 +786,11 @@ def cancel(
786786
)
787787

788788
request_url_dict: Optional[dict[str, str]]
789-
if not self._api_client.vertexai:
789+
if not self.api_client.vertexai:
790790
raise ValueError('This method is only supported in the Vertex AI client.')
791791
else:
792792
request_dict = _CancelBatchJobParameters_to_vertex(
793-
self._api_client, parameter_model
793+
self.api_client, parameter_model
794794
)
795795
request_url_dict = request_dict.get('_url')
796796
if request_url_dict:
@@ -813,7 +813,7 @@ def cancel(
813813
request_dict = _common.convert_to_dict(request_dict)
814814
request_dict = _common.encode_unserializable_types(request_dict)
815815

816-
response_dict = self._api_client.request(
816+
response_dict = self.api_client.request(
817817
'post', path, request_dict, http_options
818818
)
819819

@@ -825,11 +825,11 @@ def _list(
825825
)
826826

827827
request_url_dict: Optional[dict[str, str]]
828-
if not self._api_client.vertexai:
828+
if not self.api_client.vertexai:
829829
raise ValueError('This method is only supported in the Vertex AI client.')
830830
else:
831831
request_dict = _ListBatchJobsParameters_to_vertex(
832-
self._api_client, parameter_model
832+
self.api_client, parameter_model
833833
)
834834
request_url_dict = request_dict.get('_url')
835835
if request_url_dict:
@@ -852,23 +852,23 @@ def _list(
852852
request_dict = _common.convert_to_dict(request_dict)
853853
request_dict = _common.encode_unserializable_types(request_dict)
854854

855-
response_dict = self._api_client.request(
855+
response_dict = self.api_client.request(
856856
'get', path, request_dict, http_options
857857
)
858858

859-
if self._api_client.vertexai:
859+
if self.api_client.vertexai:
860860
response_dict = _ListBatchJobsResponse_from_vertex(
861-
self._api_client, response_dict
861+
self.api_client, response_dict
862862
)
863863
else:
864864
response_dict = _ListBatchJobsResponse_from_mldev(
865-
self._api_client, response_dict
865+
self.api_client, response_dict
866866
)
867867

868868
return_value = types.ListBatchJobsResponse._from_response(
869869
response=response_dict, kwargs=parameter_model.model_dump()
870870
)
871-
self._api_client._verify_response(return_value)
871+
self.api_client._verify_response(return_value)
872872
return return_value
873873

874874
def delete(
@@ -900,11 +900,11 @@ def delete(
900900
)
901901

902902
request_url_dict: Optional[dict[str, str]]
903-
if not self._api_client.vertexai:
903+
if not self.api_client.vertexai:
904904
raise ValueError('This method is only supported in the Vertex AI client.')
905905
else:
906906
request_dict = _DeleteBatchJobParameters_to_vertex(
907-
self._api_client, parameter_model
907+
self.api_client, parameter_model
908908
)
909909
request_url_dict = request_dict.get('_url')
910910
if request_url_dict:
@@ -927,23 +927,23 @@ def delete(
927927
request_dict = _common.convert_to_dict(request_dict)
928928
request_dict = _common.encode_unserializable_types(request_dict)
929929

930-
response_dict = self._api_client.request(
930+
response_dict = self.api_client.request(
931931
'delete', path, request_dict, http_options
932932
)
933933

934-
if self._api_client.vertexai:
934+
if self.api_client.vertexai:
935935
response_dict = _DeleteResourceJob_from_vertex(
936-
self._api_client, response_dict
936+
self.api_client, response_dict
937937
)
938938
else:
939939
response_dict = _DeleteResourceJob_from_mldev(
940-
self._api_client, response_dict
940+
self.api_client, response_dict
941941
)
942942

943943
return_value = types.DeleteResourceJob._from_response(
944944
response=response_dict, kwargs=parameter_model.model_dump()
945945
)
946-
self._api_client._verify_response(return_value)
946+
self.api_client._verify_response(return_value)
947947
return return_value
948948

949949
def create(
@@ -1024,11 +1024,11 @@ async def _create(
10241024
)
10251025

10261026
request_url_dict: Optional[dict[str, str]]
1027-
if not self._api_client.vertexai:
1027+
if not self.api_client.vertexai:
10281028
raise ValueError('This method is only supported in the Vertex AI client.')
10291029
else:
10301030
request_dict = _CreateBatchJobParameters_to_vertex(
1031-
self._api_client, parameter_model
1031+
self.api_client, parameter_model
10321032
)
10331033
request_url_dict = request_dict.get('_url')
10341034
if request_url_dict:
@@ -1051,19 +1051,19 @@ async def _create(
10511051
request_dict = _common.convert_to_dict(request_dict)
10521052
request_dict = _common.encode_unserializable_types(request_dict)
10531053

1054-
response_dict = await self._api_client.async_request(
1054+
response_dict = await self.api_client.async_request(
10551055
'post', path, request_dict, http_options
10561056
)
10571057

1058-
if self._api_client.vertexai:
1059-
response_dict = _BatchJob_from_vertex(self._api_client, response_dict)
1058+
if self.api_client.vertexai:
1059+
response_dict = _BatchJob_from_vertex(self.api_client, response_dict)
10601060
else:
1061-
response_dict = _BatchJob_from_mldev(self._api_client, response_dict)
1061+
response_dict = _BatchJob_from_mldev(self.api_client, response_dict)
10621062

10631063
return_value = types.BatchJob._from_response(
10641064
response=response_dict, kwargs=parameter_model.model_dump()
10651065
)
1066-
self._api_client._verify_response(return_value)
1066+
self.api_client._verify_response(return_value)
10671067
return return_value
10681068

10691069
async def get(
@@ -1093,11 +1093,11 @@ async def get(
10931093
)
10941094

10951095
request_url_dict: Optional[dict[str, str]]
1096-
if not self._api_client.vertexai:
1096+
if not self.api_client.vertexai:
10971097
raise ValueError('This method is only supported in the Vertex AI client.')
10981098
else:
10991099
request_dict = _GetBatchJobParameters_to_vertex(
1100-
self._api_client, parameter_model
1100+
self.api_client, parameter_model
11011101
)
11021102
request_url_dict = request_dict.get('_url')
11031103
if request_url_dict:
@@ -1120,19 +1120,19 @@ async def get(
11201120
request_dict = _common.convert_to_dict(request_dict)
11211121
request_dict = _common.encode_unserializable_types(request_dict)
11221122

1123-
response_dict = await self._api_client.async_request(
1123+
response_dict = await self.api_client.async_request(
11241124
'get', path, request_dict, http_options
11251125
)
11261126

1127-
if self._api_client.vertexai:
1128-
response_dict = _BatchJob_from_vertex(self._api_client, response_dict)
1127+
if self.api_client.vertexai:
1128+
response_dict = _BatchJob_from_vertex(self.api_client, response_dict)
11291129
else:
1130-
response_dict = _BatchJob_from_mldev(self._api_client, response_dict)
1130+
response_dict = _BatchJob_from_mldev(self.api_client, response_dict)
11311131

11321132
return_value = types.BatchJob._from_response(
11331133
response=response_dict, kwargs=parameter_model.model_dump()
11341134
)
1135-
self._api_client._verify_response(return_value)
1135+
self.api_client._verify_response(return_value)
11361136
return return_value
11371137

11381138
async def cancel(
@@ -1163,11 +1163,11 @@ async def cancel(
11631163
)
11641164

11651165
request_url_dict: Optional[dict[str, str]]
1166-
if not self._api_client.vertexai:
1166+
if not self.api_client.vertexai:
11671167
raise ValueError('This method is only supported in the Vertex AI client.')
11681168
else:
11691169
request_dict = _CancelBatchJobParameters_to_vertex(
1170-
self._api_client, parameter_model
1170+
self.api_client, parameter_model
11711171
)
11721172
request_url_dict = request_dict.get('_url')
11731173
if request_url_dict:
@@ -1190,7 +1190,7 @@ async def cancel(
11901190
request_dict = _common.convert_to_dict(request_dict)
11911191
request_dict = _common.encode_unserializable_types(request_dict)
11921192

1193-
response_dict = await self._api_client.async_request(
1193+
response_dict = await self.api_client.async_request(
11941194
'post', path, request_dict, http_options
11951195
)
11961196

@@ -1202,11 +1202,11 @@ async def _list(
12021202
)
12031203

12041204
request_url_dict: Optional[dict[str, str]]
1205-
if not self._api_client.vertexai:
1205+
if not self.api_client.vertexai:
12061206
raise ValueError('This method is only supported in the Vertex AI client.')
12071207
else:
12081208
request_dict = _ListBatchJobsParameters_to_vertex(
1209-
self._api_client, parameter_model
1209+
self.api_client, parameter_model
12101210
)
12111211
request_url_dict = request_dict.get('_url')
12121212
if request_url_dict:
@@ -1229,23 +1229,23 @@ async def _list(
12291229
request_dict = _common.convert_to_dict(request_dict)
12301230
request_dict = _common.encode_unserializable_types(request_dict)
12311231

1232-
response_dict = await self._api_client.async_request(
1232+
response_dict = await self.api_client.async_request(
12331233
'get', path, request_dict, http_options
12341234
)
12351235

1236-
if self._api_client.vertexai:
1236+
if self.api_client.vertexai:
12371237
response_dict = _ListBatchJobsResponse_from_vertex(
1238-
self._api_client, response_dict
1238+
self.api_client, response_dict
12391239
)
12401240
else:
12411241
response_dict = _ListBatchJobsResponse_from_mldev(
1242-
self._api_client, response_dict
1242+
self.api_client, response_dict
12431243
)
12441244

12451245
return_value = types.ListBatchJobsResponse._from_response(
12461246
response=response_dict, kwargs=parameter_model.model_dump()
12471247
)
1248-
self._api_client._verify_response(return_value)
1248+
self.api_client._verify_response(return_value)
12491249
return return_value
12501250

12511251
async def delete(
@@ -1277,11 +1277,11 @@ async def delete(
12771277
)
12781278

12791279
request_url_dict: Optional[dict[str, str]]
1280-
if not self._api_client.vertexai:
1280+
if not self.api_client.vertexai:
12811281
raise ValueError('This method is only supported in the Vertex AI client.')
12821282
else:
12831283
request_dict = _DeleteBatchJobParameters_to_vertex(
1284-
self._api_client, parameter_model
1284+
self.api_client, parameter_model
12851285
)
12861286
request_url_dict = request_dict.get('_url')
12871287
if request_url_dict:
@@ -1304,23 +1304,23 @@ async def delete(
13041304
request_dict = _common.convert_to_dict(request_dict)
13051305
request_dict = _common.encode_unserializable_types(request_dict)
13061306

1307-
response_dict = await self._api_client.async_request(
1307+
response_dict = await self.api_client.async_request(
13081308
'delete', path, request_dict, http_options
13091309
)
13101310

1311-
if self._api_client.vertexai:
1311+
if self.api_client.vertexai:
13121312
response_dict = _DeleteResourceJob_from_vertex(
1313-
self._api_client, response_dict
1313+
self.api_client, response_dict
13141314
)
13151315
else:
13161316
response_dict = _DeleteResourceJob_from_mldev(
1317-
self._api_client, response_dict
1317+
self.api_client, response_dict
13181318
)
13191319

13201320
return_value = types.DeleteResourceJob._from_response(
13211321
response=response_dict, kwargs=parameter_model.model_dump()
13221322
)
1323-
self._api_client._verify_response(return_value)
1323+
self.api_client._verify_response(return_value)
13241324
return return_value
13251325

13261326
async def create(

0 commit comments

Comments
 (0)