daytona_api_client 0.21.3a0__py3-none-any.whl → 0.21.4a4__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.

Potentially problematic release.

This version of daytona_api_client might be problematic. Click here for more details.

Files changed (107) hide show
  1. daytona_api_client/api/__init__.py +1 -0
  2. daytona_api_client/api/api_keys_api.py +328 -171
  3. daytona_api_client/api/docker_registry_api.py +463 -239
  4. daytona_api_client/api/object_storage_api.py +63 -33
  5. daytona_api_client/api/organizations_api.py +1582 -612
  6. daytona_api_client/api/preview_api.py +175 -71
  7. daytona_api_client/api/runners_api.py +195 -67
  8. daytona_api_client/api/sandbox_api.py +909 -499
  9. daytona_api_client/api/snapshots_api.py +482 -253
  10. daytona_api_client/api/toolbox_api.py +2684 -1410
  11. daytona_api_client/api/users_api.py +526 -184
  12. daytona_api_client/api/volumes_api.py +332 -180
  13. daytona_api_client/api/workspace_api.py +909 -499
  14. daytona_api_client/api_client.py +192 -90
  15. daytona_api_client/api_response.py +3 -2
  16. daytona_api_client/configuration.py +52 -55
  17. daytona_api_client/exceptions.py +16 -15
  18. daytona_api_client/models/account_provider.py +11 -9
  19. daytona_api_client/models/api_key_list.py +21 -40
  20. daytona_api_client/models/api_key_response.py +19 -38
  21. daytona_api_client/models/build_info.py +15 -22
  22. daytona_api_client/models/command.py +13 -12
  23. daytona_api_client/models/completion_context.py +11 -11
  24. daytona_api_client/models/completion_item.py +17 -28
  25. daytona_api_client/models/completion_list.py +12 -17
  26. daytona_api_client/models/create_api_key.py +17 -32
  27. daytona_api_client/models/create_build_info.py +13 -17
  28. daytona_api_client/models/create_docker_registry.py +18 -21
  29. daytona_api_client/models/create_linked_account.py +11 -9
  30. daytona_api_client/models/create_organization.py +10 -9
  31. daytona_api_client/models/create_organization_invitation.py +17 -24
  32. daytona_api_client/models/create_organization_quota.py +19 -32
  33. daytona_api_client/models/create_organization_role.py +15 -28
  34. daytona_api_client/models/create_runner.py +26 -41
  35. daytona_api_client/models/create_sandbox.py +39 -76
  36. daytona_api_client/models/create_session_request.py +10 -9
  37. daytona_api_client/models/create_snapshot.py +22 -39
  38. daytona_api_client/models/create_user.py +19 -26
  39. daytona_api_client/models/create_volume.py +10 -9
  40. daytona_api_client/models/create_workspace.py +38 -73
  41. daytona_api_client/models/docker_registry.py +21 -33
  42. daytona_api_client/models/execute_request.py +13 -12
  43. daytona_api_client/models/execute_response.py +11 -9
  44. daytona_api_client/models/file_info.py +17 -20
  45. daytona_api_client/models/file_status.py +13 -16
  46. daytona_api_client/models/git_add_request.py +11 -9
  47. daytona_api_client/models/git_branch_request.py +11 -9
  48. daytona_api_client/models/git_checkout_request.py +11 -9
  49. daytona_api_client/models/git_clone_request.py +15 -18
  50. daytona_api_client/models/git_commit_info.py +14 -17
  51. daytona_api_client/models/git_commit_request.py +13 -16
  52. daytona_api_client/models/git_commit_response.py +10 -9
  53. daytona_api_client/models/git_delete_branch_request.py +11 -9
  54. daytona_api_client/models/git_repo_request.py +12 -11
  55. daytona_api_client/models/git_status.py +15 -20
  56. daytona_api_client/models/list_branch_response.py +10 -9
  57. daytona_api_client/models/lsp_completion_params.py +16 -19
  58. daytona_api_client/models/lsp_document_request.py +12 -11
  59. daytona_api_client/models/lsp_location.py +12 -12
  60. daytona_api_client/models/lsp_server_request.py +11 -9
  61. daytona_api_client/models/lsp_symbol.py +13 -16
  62. daytona_api_client/models/match.py +12 -9
  63. daytona_api_client/models/organization.py +20 -34
  64. daytona_api_client/models/organization_invitation.py +27 -44
  65. daytona_api_client/models/organization_role.py +21 -46
  66. daytona_api_client/models/organization_suspension.py +11 -9
  67. daytona_api_client/models/organization_user.py +22 -36
  68. daytona_api_client/models/paginated_snapshots_dto.py +14 -19
  69. daytona_api_client/models/port_preview_url.py +11 -9
  70. daytona_api_client/models/position.py +11 -9
  71. daytona_api_client/models/project_dir_response.py +10 -9
  72. daytona_api_client/models/range.py +13 -16
  73. daytona_api_client/models/registry_push_access_dto.py +15 -18
  74. daytona_api_client/models/replace_request.py +12 -11
  75. daytona_api_client/models/replace_result.py +12 -9
  76. daytona_api_client/models/sandbox.py +49 -95
  77. daytona_api_client/models/sandbox_info.py +13 -18
  78. daytona_api_client/models/sandbox_labels.py +10 -9
  79. daytona_api_client/models/sandbox_state.py +18 -16
  80. daytona_api_client/models/sandbox_volume.py +11 -9
  81. daytona_api_client/models/search_files_response.py +10 -9
  82. daytona_api_client/models/session.py +13 -18
  83. daytona_api_client/models/session_execute_request.py +14 -19
  84. daytona_api_client/models/session_execute_response.py +13 -14
  85. daytona_api_client/models/set_snapshot_general_status_dto.py +10 -9
  86. daytona_api_client/models/snapshot_dto.py +34 -58
  87. daytona_api_client/models/snapshot_state.py +12 -10
  88. daytona_api_client/models/storage_access_dto.py +16 -26
  89. daytona_api_client/models/toggle_state.py +10 -9
  90. daytona_api_client/models/update_assigned_organization_roles.py +10 -9
  91. daytona_api_client/models/update_docker_registry.py +12 -11
  92. daytona_api_client/models/update_organization_invitation.py +15 -16
  93. daytona_api_client/models/update_organization_member_role.py +12 -11
  94. daytona_api_client/models/update_organization_quota.py +28 -41
  95. daytona_api_client/models/update_organization_role.py +15 -28
  96. daytona_api_client/models/usage_overview.py +17 -28
  97. daytona_api_client/models/user.py +14 -19
  98. daytona_api_client/models/user_public_key.py +11 -9
  99. daytona_api_client/models/volume_dto.py +20 -32
  100. daytona_api_client/models/volume_state.py +9 -7
  101. daytona_api_client/models/workspace.py +58 -113
  102. daytona_api_client/rest.py +77 -26
  103. {daytona_api_client-0.21.3a0.dist-info → daytona_api_client-0.21.4a4.dist-info}/METADATA +1 -1
  104. daytona_api_client-0.21.4a4.dist-info/RECORD +117 -0
  105. daytona_api_client-0.21.3a0.dist-info/RECORD +0 -117
  106. {daytona_api_client-0.21.3a0.dist-info → daytona_api_client-0.21.4a4.dist-info}/WHEEL +0 -0
  107. {daytona_api_client-0.21.3a0.dist-info → daytona_api_client-0.21.4a4.dist-info}/top_level.txt +0 -0
daytona_api_client/api/docker_registry_api.py CHANGED
@@ -42,17 +42,19 @@ class DockerRegistryApi:
42
42
  api_client = ApiClient.get_default()
43
43
  self.api_client = api_client
44
44
 
45
+
45
46
  @validate_call
46
47
  def create_registry(
47
48
  self,
48
49
  create_docker_registry: CreateDockerRegistry,
49
- x_daytona_organization_id: Annotated[
50
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
51
- ] = None,
50
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
52
51
  _request_timeout: Union[
53
52
  None,
54
53
  Annotated[StrictFloat, Field(gt=0)],
55
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
54
+ Tuple[
55
+ Annotated[StrictFloat, Field(gt=0)],
56
+ Annotated[StrictFloat, Field(gt=0)]
57
+ ]
56
58
  ] = None,
57
59
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
58
60
  _content_type: Optional[StrictStr] = None,
@@ -86,7 +88,7 @@ class DockerRegistryApi:
86
88
  in the spec for a single request.
87
89
  :type _host_index: int, optional
88
90
  :return: Returns the result object.
89
- """ # noqa: E501
91
+ """ # noqa: E501
90
92
 
91
93
  _param = self._create_registry_serialize(
92
94
  create_docker_registry=create_docker_registry,
@@ -94,30 +96,35 @@ class DockerRegistryApi:
94
96
  _request_auth=_request_auth,
95
97
  _content_type=_content_type,
96
98
  _headers=_headers,
97
- _host_index=_host_index,
99
+ _host_index=_host_index
98
100
  )
99
101
 
100
102
  _response_types_map: Dict[str, Optional[str]] = {
101
- "201": "DockerRegistry",
103
+ '201': "DockerRegistry",
102
104
  }
103
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
105
+ response_data = self.api_client.call_api(
106
+ *_param,
107
+ _request_timeout=_request_timeout
108
+ )
104
109
  response_data.read()
105
110
  return self.api_client.response_deserialize(
106
111
  response_data=response_data,
107
112
  response_types_map=_response_types_map,
108
113
  ).data
109
114
 
115
+
110
116
  @validate_call
111
117
  def create_registry_with_http_info(
112
118
  self,
113
119
  create_docker_registry: CreateDockerRegistry,
114
- x_daytona_organization_id: Annotated[
115
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
116
- ] = None,
120
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
117
121
  _request_timeout: Union[
118
122
  None,
119
123
  Annotated[StrictFloat, Field(gt=0)],
120
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
124
+ Tuple[
125
+ Annotated[StrictFloat, Field(gt=0)],
126
+ Annotated[StrictFloat, Field(gt=0)]
127
+ ]
121
128
  ] = None,
122
129
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
123
130
  _content_type: Optional[StrictStr] = None,
@@ -151,7 +158,7 @@ class DockerRegistryApi:
151
158
  in the spec for a single request.
152
159
  :type _host_index: int, optional
153
160
  :return: Returns the result object.
154
- """ # noqa: E501
161
+ """ # noqa: E501
155
162
 
156
163
  _param = self._create_registry_serialize(
157
164
  create_docker_registry=create_docker_registry,
@@ -159,30 +166,35 @@ class DockerRegistryApi:
159
166
  _request_auth=_request_auth,
160
167
  _content_type=_content_type,
161
168
  _headers=_headers,
162
- _host_index=_host_index,
169
+ _host_index=_host_index
163
170
  )
164
171
 
165
172
  _response_types_map: Dict[str, Optional[str]] = {
166
- "201": "DockerRegistry",
173
+ '201': "DockerRegistry",
167
174
  }
168
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
175
+ response_data = self.api_client.call_api(
176
+ *_param,
177
+ _request_timeout=_request_timeout
178
+ )
169
179
  response_data.read()
170
180
  return self.api_client.response_deserialize(
171
181
  response_data=response_data,
172
182
  response_types_map=_response_types_map,
173
183
  )
174
184
 
185
+
175
186
  @validate_call
176
187
  def create_registry_without_preload_content(
177
188
  self,
178
189
  create_docker_registry: CreateDockerRegistry,
179
- x_daytona_organization_id: Annotated[
180
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
181
- ] = None,
190
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
182
191
  _request_timeout: Union[
183
192
  None,
184
193
  Annotated[StrictFloat, Field(gt=0)],
185
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
194
+ Tuple[
195
+ Annotated[StrictFloat, Field(gt=0)],
196
+ Annotated[StrictFloat, Field(gt=0)]
197
+ ]
186
198
  ] = None,
187
199
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
188
200
  _content_type: Optional[StrictStr] = None,
@@ -216,7 +228,7 @@ class DockerRegistryApi:
216
228
  in the spec for a single request.
217
229
  :type _host_index: int, optional
218
230
  :return: Returns the result object.
219
- """ # noqa: E501
231
+ """ # noqa: E501
220
232
 
221
233
  _param = self._create_registry_serialize(
222
234
  create_docker_registry=create_docker_registry,
@@ -224,15 +236,19 @@ class DockerRegistryApi:
224
236
  _request_auth=_request_auth,
225
237
  _content_type=_content_type,
226
238
  _headers=_headers,
227
- _host_index=_host_index,
239
+ _host_index=_host_index
228
240
  )
229
241
 
230
242
  _response_types_map: Dict[str, Optional[str]] = {
231
- "201": "DockerRegistry",
243
+ '201': "DockerRegistry",
232
244
  }
233
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
245
+ response_data = self.api_client.call_api(
246
+ *_param,
247
+ _request_timeout=_request_timeout
248
+ )
234
249
  return response_data.response
235
250
 
251
+
236
252
  def _create_registry_serialize(
237
253
  self,
238
254
  create_docker_registry,
@@ -242,45 +258,63 @@ class DockerRegistryApi:
242
258
  _headers,
243
259
  _host_index,
244
260
  ) -> RequestSerialized:
261
+
245
262
  _host = None
246
263
 
247
- _collection_formats: Dict[str, str] = {}
264
+ _collection_formats: Dict[str, str] = {
265
+ }
248
266
 
249
267
  _path_params: Dict[str, str] = {}
250
268
  _query_params: List[Tuple[str, str]] = []
251
269
  _header_params: Dict[str, Optional[str]] = _headers or {}
252
270
  _form_params: List[Tuple[str, str]] = []
253
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
271
+ _files: Dict[
272
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
273
+ ] = {}
254
274
  _body_params: Optional[bytes] = None
255
275
 
256
276
  # process the path parameters
257
277
  # process the query parameters
258
278
  # process the header parameters
259
279
  if x_daytona_organization_id is not None:
260
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
280
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
261
281
  # process the form parameters
262
282
  # process the body parameter
263
283
  if create_docker_registry is not None:
264
284
  _body_params = create_docker_registry
265
285
 
286
+
266
287
  # set the HTTP header `Accept`
267
- if "Accept" not in _header_params:
268
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
288
+ if 'Accept' not in _header_params:
289
+ _header_params['Accept'] = self.api_client.select_header_accept(
290
+ [
291
+ 'application/json'
292
+ ]
293
+ )
269
294
 
270
295
  # set the HTTP header `Content-Type`
271
296
  if _content_type:
272
- _header_params["Content-Type"] = _content_type
297
+ _header_params['Content-Type'] = _content_type
273
298
  else:
274
- _default_content_type = self.api_client.select_header_content_type(["application/json"])
299
+ _default_content_type = (
300
+ self.api_client.select_header_content_type(
301
+ [
302
+ 'application/json'
303
+ ]
304
+ )
305
+ )
275
306
  if _default_content_type is not None:
276
- _header_params["Content-Type"] = _default_content_type
307
+ _header_params['Content-Type'] = _default_content_type
277
308
 
278
309
  # authentication setting
279
- _auth_settings: List[str] = ["bearer", "oauth2"]
310
+ _auth_settings: List[str] = [
311
+ 'bearer',
312
+ 'oauth2'
313
+ ]
280
314
 
281
315
  return self.api_client.param_serialize(
282
- method="POST",
283
- resource_path="/docker-registry",
316
+ method='POST',
317
+ resource_path='/docker-registry',
284
318
  path_params=_path_params,
285
319
  query_params=_query_params,
286
320
  header_params=_header_params,
@@ -290,20 +324,24 @@ class DockerRegistryApi:
290
324
  auth_settings=_auth_settings,
291
325
  collection_formats=_collection_formats,
292
326
  _host=_host,
293
- _request_auth=_request_auth,
327
+ _request_auth=_request_auth
294
328
  )
295
329
 
330
+
331
+
332
+
296
333
  @validate_call
297
334
  def delete_registry(
298
335
  self,
299
336
  id: Annotated[StrictStr, Field(description="ID of the docker registry")],
300
- x_daytona_organization_id: Annotated[
301
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
302
- ] = None,
337
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
303
338
  _request_timeout: Union[
304
339
  None,
305
340
  Annotated[StrictFloat, Field(gt=0)],
306
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
341
+ Tuple[
342
+ Annotated[StrictFloat, Field(gt=0)],
343
+ Annotated[StrictFloat, Field(gt=0)]
344
+ ]
307
345
  ] = None,
308
346
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
309
347
  _content_type: Optional[StrictStr] = None,
@@ -337,7 +375,7 @@ class DockerRegistryApi:
337
375
  in the spec for a single request.
338
376
  :type _host_index: int, optional
339
377
  :return: Returns the result object.
340
- """ # noqa: E501
378
+ """ # noqa: E501
341
379
 
342
380
  _param = self._delete_registry_serialize(
343
381
  id=id,
@@ -345,30 +383,35 @@ class DockerRegistryApi:
345
383
  _request_auth=_request_auth,
346
384
  _content_type=_content_type,
347
385
  _headers=_headers,
348
- _host_index=_host_index,
386
+ _host_index=_host_index
349
387
  )
350
388
 
351
389
  _response_types_map: Dict[str, Optional[str]] = {
352
- "204": None,
390
+ '204': None,
353
391
  }
354
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
392
+ response_data = self.api_client.call_api(
393
+ *_param,
394
+ _request_timeout=_request_timeout
395
+ )
355
396
  response_data.read()
356
397
  return self.api_client.response_deserialize(
357
398
  response_data=response_data,
358
399
  response_types_map=_response_types_map,
359
400
  ).data
360
401
 
402
+
361
403
  @validate_call
362
404
  def delete_registry_with_http_info(
363
405
  self,
364
406
  id: Annotated[StrictStr, Field(description="ID of the docker registry")],
365
- x_daytona_organization_id: Annotated[
366
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
367
- ] = None,
407
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
368
408
  _request_timeout: Union[
369
409
  None,
370
410
  Annotated[StrictFloat, Field(gt=0)],
371
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
411
+ Tuple[
412
+ Annotated[StrictFloat, Field(gt=0)],
413
+ Annotated[StrictFloat, Field(gt=0)]
414
+ ]
372
415
  ] = None,
373
416
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
374
417
  _content_type: Optional[StrictStr] = None,
@@ -402,7 +445,7 @@ class DockerRegistryApi:
402
445
  in the spec for a single request.
403
446
  :type _host_index: int, optional
404
447
  :return: Returns the result object.
405
- """ # noqa: E501
448
+ """ # noqa: E501
406
449
 
407
450
  _param = self._delete_registry_serialize(
408
451
  id=id,
@@ -410,30 +453,35 @@ class DockerRegistryApi:
410
453
  _request_auth=_request_auth,
411
454
  _content_type=_content_type,
412
455
  _headers=_headers,
413
- _host_index=_host_index,
456
+ _host_index=_host_index
414
457
  )
415
458
 
416
459
  _response_types_map: Dict[str, Optional[str]] = {
417
- "204": None,
460
+ '204': None,
418
461
  }
419
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
462
+ response_data = self.api_client.call_api(
463
+ *_param,
464
+ _request_timeout=_request_timeout
465
+ )
420
466
  response_data.read()
421
467
  return self.api_client.response_deserialize(
422
468
  response_data=response_data,
423
469
  response_types_map=_response_types_map,
424
470
  )
425
471
 
472
+
426
473
  @validate_call
427
474
  def delete_registry_without_preload_content(
428
475
  self,
429
476
  id: Annotated[StrictStr, Field(description="ID of the docker registry")],
430
- x_daytona_organization_id: Annotated[
431
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
432
- ] = None,
477
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
433
478
  _request_timeout: Union[
434
479
  None,
435
480
  Annotated[StrictFloat, Field(gt=0)],
436
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
481
+ Tuple[
482
+ Annotated[StrictFloat, Field(gt=0)],
483
+ Annotated[StrictFloat, Field(gt=0)]
484
+ ]
437
485
  ] = None,
438
486
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
439
487
  _content_type: Optional[StrictStr] = None,
@@ -467,7 +515,7 @@ class DockerRegistryApi:
467
515
  in the spec for a single request.
468
516
  :type _host_index: int, optional
469
517
  :return: Returns the result object.
470
- """ # noqa: E501
518
+ """ # noqa: E501
471
519
 
472
520
  _param = self._delete_registry_serialize(
473
521
  id=id,
@@ -475,15 +523,19 @@ class DockerRegistryApi:
475
523
  _request_auth=_request_auth,
476
524
  _content_type=_content_type,
477
525
  _headers=_headers,
478
- _host_index=_host_index,
526
+ _host_index=_host_index
479
527
  )
480
528
 
481
529
  _response_types_map: Dict[str, Optional[str]] = {
482
- "204": None,
530
+ '204': None,
483
531
  }
484
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
532
+ response_data = self.api_client.call_api(
533
+ *_param,
534
+ _request_timeout=_request_timeout
535
+ )
485
536
  return response_data.response
486
537
 
538
+
487
539
  def _delete_registry_serialize(
488
540
  self,
489
541
  id,
@@ -493,33 +545,43 @@ class DockerRegistryApi:
493
545
  _headers,
494
546
  _host_index,
495
547
  ) -> RequestSerialized:
548
+
496
549
  _host = None
497
550
 
498
- _collection_formats: Dict[str, str] = {}
551
+ _collection_formats: Dict[str, str] = {
552
+ }
499
553
 
500
554
  _path_params: Dict[str, str] = {}
501
555
  _query_params: List[Tuple[str, str]] = []
502
556
  _header_params: Dict[str, Optional[str]] = _headers or {}
503
557
  _form_params: List[Tuple[str, str]] = []
504
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
558
+ _files: Dict[
559
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
560
+ ] = {}
505
561
  _body_params: Optional[bytes] = None
506
562
 
507
563
  # process the path parameters
508
564
  if id is not None:
509
- _path_params["id"] = id
565
+ _path_params['id'] = id
510
566
  # process the query parameters
511
567
  # process the header parameters
512
568
  if x_daytona_organization_id is not None:
513
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
569
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
514
570
  # process the form parameters
515
571
  # process the body parameter
516
572
 
573
+
574
+
575
+
517
576
  # authentication setting
518
- _auth_settings: List[str] = ["bearer", "oauth2"]
577
+ _auth_settings: List[str] = [
578
+ 'bearer',
579
+ 'oauth2'
580
+ ]
519
581
 
520
582
  return self.api_client.param_serialize(
521
- method="DELETE",
522
- resource_path="/docker-registry/{id}",
583
+ method='DELETE',
584
+ resource_path='/docker-registry/{id}',
523
585
  path_params=_path_params,
524
586
  query_params=_query_params,
525
587
  header_params=_header_params,
@@ -529,20 +591,24 @@ class DockerRegistryApi:
529
591
  auth_settings=_auth_settings,
530
592
  collection_formats=_collection_formats,
531
593
  _host=_host,
532
- _request_auth=_request_auth,
594
+ _request_auth=_request_auth
533
595
  )
534
596
 
597
+
598
+
599
+
535
600
  @validate_call
536
601
  def get_registry(
537
602
  self,
538
603
  id: Annotated[StrictStr, Field(description="ID of the docker registry")],
539
- x_daytona_organization_id: Annotated[
540
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
541
- ] = None,
604
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
542
605
  _request_timeout: Union[
543
606
  None,
544
607
  Annotated[StrictFloat, Field(gt=0)],
545
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
608
+ Tuple[
609
+ Annotated[StrictFloat, Field(gt=0)],
610
+ Annotated[StrictFloat, Field(gt=0)]
611
+ ]
546
612
  ] = None,
547
613
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
548
614
  _content_type: Optional[StrictStr] = None,
@@ -576,7 +642,7 @@ class DockerRegistryApi:
576
642
  in the spec for a single request.
577
643
  :type _host_index: int, optional
578
644
  :return: Returns the result object.
579
- """ # noqa: E501
645
+ """ # noqa: E501
580
646
 
581
647
  _param = self._get_registry_serialize(
582
648
  id=id,
@@ -584,30 +650,35 @@ class DockerRegistryApi:
584
650
  _request_auth=_request_auth,
585
651
  _content_type=_content_type,
586
652
  _headers=_headers,
587
- _host_index=_host_index,
653
+ _host_index=_host_index
588
654
  )
589
655
 
590
656
  _response_types_map: Dict[str, Optional[str]] = {
591
- "200": "DockerRegistry",
657
+ '200': "DockerRegistry",
592
658
  }
593
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
659
+ response_data = self.api_client.call_api(
660
+ *_param,
661
+ _request_timeout=_request_timeout
662
+ )
594
663
  response_data.read()
595
664
  return self.api_client.response_deserialize(
596
665
  response_data=response_data,
597
666
  response_types_map=_response_types_map,
598
667
  ).data
599
668
 
669
+
600
670
  @validate_call
601
671
  def get_registry_with_http_info(
602
672
  self,
603
673
  id: Annotated[StrictStr, Field(description="ID of the docker registry")],
604
- x_daytona_organization_id: Annotated[
605
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
606
- ] = None,
674
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
607
675
  _request_timeout: Union[
608
676
  None,
609
677
  Annotated[StrictFloat, Field(gt=0)],
610
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
678
+ Tuple[
679
+ Annotated[StrictFloat, Field(gt=0)],
680
+ Annotated[StrictFloat, Field(gt=0)]
681
+ ]
611
682
  ] = None,
612
683
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
613
684
  _content_type: Optional[StrictStr] = None,
@@ -641,7 +712,7 @@ class DockerRegistryApi:
641
712
  in the spec for a single request.
642
713
  :type _host_index: int, optional
643
714
  :return: Returns the result object.
644
- """ # noqa: E501
715
+ """ # noqa: E501
645
716
 
646
717
  _param = self._get_registry_serialize(
647
718
  id=id,
@@ -649,30 +720,35 @@ class DockerRegistryApi:
649
720
  _request_auth=_request_auth,
650
721
  _content_type=_content_type,
651
722
  _headers=_headers,
652
- _host_index=_host_index,
723
+ _host_index=_host_index
653
724
  )
654
725
 
655
726
  _response_types_map: Dict[str, Optional[str]] = {
656
- "200": "DockerRegistry",
727
+ '200': "DockerRegistry",
657
728
  }
658
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
729
+ response_data = self.api_client.call_api(
730
+ *_param,
731
+ _request_timeout=_request_timeout
732
+ )
659
733
  response_data.read()
660
734
  return self.api_client.response_deserialize(
661
735
  response_data=response_data,
662
736
  response_types_map=_response_types_map,
663
737
  )
664
738
 
739
+
665
740
  @validate_call
666
741
  def get_registry_without_preload_content(
667
742
  self,
668
743
  id: Annotated[StrictStr, Field(description="ID of the docker registry")],
669
- x_daytona_organization_id: Annotated[
670
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
671
- ] = None,
744
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
672
745
  _request_timeout: Union[
673
746
  None,
674
747
  Annotated[StrictFloat, Field(gt=0)],
675
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
748
+ Tuple[
749
+ Annotated[StrictFloat, Field(gt=0)],
750
+ Annotated[StrictFloat, Field(gt=0)]
751
+ ]
676
752
  ] = None,
677
753
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
678
754
  _content_type: Optional[StrictStr] = None,
@@ -706,7 +782,7 @@ class DockerRegistryApi:
706
782
  in the spec for a single request.
707
783
  :type _host_index: int, optional
708
784
  :return: Returns the result object.
709
- """ # noqa: E501
785
+ """ # noqa: E501
710
786
 
711
787
  _param = self._get_registry_serialize(
712
788
  id=id,
@@ -714,15 +790,19 @@ class DockerRegistryApi:
714
790
  _request_auth=_request_auth,
715
791
  _content_type=_content_type,
716
792
  _headers=_headers,
717
- _host_index=_host_index,
793
+ _host_index=_host_index
718
794
  )
719
795
 
720
796
  _response_types_map: Dict[str, Optional[str]] = {
721
- "200": "DockerRegistry",
797
+ '200': "DockerRegistry",
722
798
  }
723
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
799
+ response_data = self.api_client.call_api(
800
+ *_param,
801
+ _request_timeout=_request_timeout
802
+ )
724
803
  return response_data.response
725
804
 
805
+
726
806
  def _get_registry_serialize(
727
807
  self,
728
808
  id,
@@ -732,37 +812,50 @@ class DockerRegistryApi:
732
812
  _headers,
733
813
  _host_index,
734
814
  ) -> RequestSerialized:
815
+
735
816
  _host = None
736
817
 
737
- _collection_formats: Dict[str, str] = {}
818
+ _collection_formats: Dict[str, str] = {
819
+ }
738
820
 
739
821
  _path_params: Dict[str, str] = {}
740
822
  _query_params: List[Tuple[str, str]] = []
741
823
  _header_params: Dict[str, Optional[str]] = _headers or {}
742
824
  _form_params: List[Tuple[str, str]] = []
743
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
825
+ _files: Dict[
826
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
827
+ ] = {}
744
828
  _body_params: Optional[bytes] = None
745
829
 
746
830
  # process the path parameters
747
831
  if id is not None:
748
- _path_params["id"] = id
832
+ _path_params['id'] = id
749
833
  # process the query parameters
750
834
  # process the header parameters
751
835
  if x_daytona_organization_id is not None:
752
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
836
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
753
837
  # process the form parameters
754
838
  # process the body parameter
755
839
 
840
+
756
841
  # set the HTTP header `Accept`
757
- if "Accept" not in _header_params:
758
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
842
+ if 'Accept' not in _header_params:
843
+ _header_params['Accept'] = self.api_client.select_header_accept(
844
+ [
845
+ 'application/json'
846
+ ]
847
+ )
848
+
759
849
 
760
850
  # authentication setting
761
- _auth_settings: List[str] = ["bearer", "oauth2"]
851
+ _auth_settings: List[str] = [
852
+ 'bearer',
853
+ 'oauth2'
854
+ ]
762
855
 
763
856
  return self.api_client.param_serialize(
764
- method="GET",
765
- resource_path="/docker-registry/{id}",
857
+ method='GET',
858
+ resource_path='/docker-registry/{id}',
766
859
  path_params=_path_params,
767
860
  query_params=_query_params,
768
861
  header_params=_header_params,
@@ -772,19 +865,23 @@ class DockerRegistryApi:
772
865
  auth_settings=_auth_settings,
773
866
  collection_formats=_collection_formats,
774
867
  _host=_host,
775
- _request_auth=_request_auth,
868
+ _request_auth=_request_auth
776
869
  )
777
870
 
871
+
872
+
873
+
778
874
  @validate_call
779
875
  def get_transient_push_access(
780
876
  self,
781
- x_daytona_organization_id: Annotated[
782
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
783
- ] = None,
877
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
784
878
  _request_timeout: Union[
785
879
  None,
786
880
  Annotated[StrictFloat, Field(gt=0)],
787
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
881
+ Tuple[
882
+ Annotated[StrictFloat, Field(gt=0)],
883
+ Annotated[StrictFloat, Field(gt=0)]
884
+ ]
788
885
  ] = None,
789
886
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
790
887
  _content_type: Optional[StrictStr] = None,
@@ -816,36 +913,41 @@ class DockerRegistryApi:
816
913
  in the spec for a single request.
817
914
  :type _host_index: int, optional
818
915
  :return: Returns the result object.
819
- """ # noqa: E501
916
+ """ # noqa: E501
820
917
 
821
918
  _param = self._get_transient_push_access_serialize(
822
919
  x_daytona_organization_id=x_daytona_organization_id,
823
920
  _request_auth=_request_auth,
824
921
  _content_type=_content_type,
825
922
  _headers=_headers,
826
- _host_index=_host_index,
923
+ _host_index=_host_index
827
924
  )
828
925
 
829
926
  _response_types_map: Dict[str, Optional[str]] = {
830
- "200": "RegistryPushAccessDto",
927
+ '200': "RegistryPushAccessDto",
831
928
  }
832
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
929
+ response_data = self.api_client.call_api(
930
+ *_param,
931
+ _request_timeout=_request_timeout
932
+ )
833
933
  response_data.read()
834
934
  return self.api_client.response_deserialize(
835
935
  response_data=response_data,
836
936
  response_types_map=_response_types_map,
837
937
  ).data
838
938
 
939
+
839
940
  @validate_call
840
941
  def get_transient_push_access_with_http_info(
841
942
  self,
842
- x_daytona_organization_id: Annotated[
843
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
844
- ] = None,
943
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
845
944
  _request_timeout: Union[
846
945
  None,
847
946
  Annotated[StrictFloat, Field(gt=0)],
848
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
947
+ Tuple[
948
+ Annotated[StrictFloat, Field(gt=0)],
949
+ Annotated[StrictFloat, Field(gt=0)]
950
+ ]
849
951
  ] = None,
850
952
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
851
953
  _content_type: Optional[StrictStr] = None,
@@ -877,36 +979,41 @@ class DockerRegistryApi:
877
979
  in the spec for a single request.
878
980
  :type _host_index: int, optional
879
981
  :return: Returns the result object.
880
- """ # noqa: E501
982
+ """ # noqa: E501
881
983
 
882
984
  _param = self._get_transient_push_access_serialize(
883
985
  x_daytona_organization_id=x_daytona_organization_id,
884
986
  _request_auth=_request_auth,
885
987
  _content_type=_content_type,
886
988
  _headers=_headers,
887
- _host_index=_host_index,
989
+ _host_index=_host_index
888
990
  )
889
991
 
890
992
  _response_types_map: Dict[str, Optional[str]] = {
891
- "200": "RegistryPushAccessDto",
993
+ '200': "RegistryPushAccessDto",
892
994
  }
893
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
995
+ response_data = self.api_client.call_api(
996
+ *_param,
997
+ _request_timeout=_request_timeout
998
+ )
894
999
  response_data.read()
895
1000
  return self.api_client.response_deserialize(
896
1001
  response_data=response_data,
897
1002
  response_types_map=_response_types_map,
898
1003
  )
899
1004
 
1005
+
900
1006
  @validate_call
901
1007
  def get_transient_push_access_without_preload_content(
902
1008
  self,
903
- x_daytona_organization_id: Annotated[
904
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
905
- ] = None,
1009
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
906
1010
  _request_timeout: Union[
907
1011
  None,
908
1012
  Annotated[StrictFloat, Field(gt=0)],
909
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1013
+ Tuple[
1014
+ Annotated[StrictFloat, Field(gt=0)],
1015
+ Annotated[StrictFloat, Field(gt=0)]
1016
+ ]
910
1017
  ] = None,
911
1018
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
912
1019
  _content_type: Optional[StrictStr] = None,
@@ -938,22 +1045,26 @@ class DockerRegistryApi:
938
1045
  in the spec for a single request.
939
1046
  :type _host_index: int, optional
940
1047
  :return: Returns the result object.
941
- """ # noqa: E501
1048
+ """ # noqa: E501
942
1049
 
943
1050
  _param = self._get_transient_push_access_serialize(
944
1051
  x_daytona_organization_id=x_daytona_organization_id,
945
1052
  _request_auth=_request_auth,
946
1053
  _content_type=_content_type,
947
1054
  _headers=_headers,
948
- _host_index=_host_index,
1055
+ _host_index=_host_index
949
1056
  )
950
1057
 
951
1058
  _response_types_map: Dict[str, Optional[str]] = {
952
- "200": "RegistryPushAccessDto",
1059
+ '200': "RegistryPushAccessDto",
953
1060
  }
954
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1061
+ response_data = self.api_client.call_api(
1062
+ *_param,
1063
+ _request_timeout=_request_timeout
1064
+ )
955
1065
  return response_data.response
956
1066
 
1067
+
957
1068
  def _get_transient_push_access_serialize(
958
1069
  self,
959
1070
  x_daytona_organization_id,
@@ -962,35 +1073,48 @@ class DockerRegistryApi:
962
1073
  _headers,
963
1074
  _host_index,
964
1075
  ) -> RequestSerialized:
1076
+
965
1077
  _host = None
966
1078
 
967
- _collection_formats: Dict[str, str] = {}
1079
+ _collection_formats: Dict[str, str] = {
1080
+ }
968
1081
 
969
1082
  _path_params: Dict[str, str] = {}
970
1083
  _query_params: List[Tuple[str, str]] = []
971
1084
  _header_params: Dict[str, Optional[str]] = _headers or {}
972
1085
  _form_params: List[Tuple[str, str]] = []
973
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
1086
+ _files: Dict[
1087
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1088
+ ] = {}
974
1089
  _body_params: Optional[bytes] = None
975
1090
 
976
1091
  # process the path parameters
977
1092
  # process the query parameters
978
1093
  # process the header parameters
979
1094
  if x_daytona_organization_id is not None:
980
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
1095
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
981
1096
  # process the form parameters
982
1097
  # process the body parameter
983
1098
 
1099
+
984
1100
  # set the HTTP header `Accept`
985
- if "Accept" not in _header_params:
986
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
1101
+ if 'Accept' not in _header_params:
1102
+ _header_params['Accept'] = self.api_client.select_header_accept(
1103
+ [
1104
+ 'application/json'
1105
+ ]
1106
+ )
1107
+
987
1108
 
988
1109
  # authentication setting
989
- _auth_settings: List[str] = ["bearer", "oauth2"]
1110
+ _auth_settings: List[str] = [
1111
+ 'bearer',
1112
+ 'oauth2'
1113
+ ]
990
1114
 
991
1115
  return self.api_client.param_serialize(
992
- method="GET",
993
- resource_path="/docker-registry/registry-push-access",
1116
+ method='GET',
1117
+ resource_path='/docker-registry/registry-push-access',
994
1118
  path_params=_path_params,
995
1119
  query_params=_query_params,
996
1120
  header_params=_header_params,
@@ -1000,19 +1124,23 @@ class DockerRegistryApi:
1000
1124
  auth_settings=_auth_settings,
1001
1125
  collection_formats=_collection_formats,
1002
1126
  _host=_host,
1003
- _request_auth=_request_auth,
1127
+ _request_auth=_request_auth
1004
1128
  )
1005
1129
 
1130
+
1131
+
1132
+
1006
1133
  @validate_call
1007
1134
  def list_registries(
1008
1135
  self,
1009
- x_daytona_organization_id: Annotated[
1010
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1011
- ] = None,
1136
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1012
1137
  _request_timeout: Union[
1013
1138
  None,
1014
1139
  Annotated[StrictFloat, Field(gt=0)],
1015
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1140
+ Tuple[
1141
+ Annotated[StrictFloat, Field(gt=0)],
1142
+ Annotated[StrictFloat, Field(gt=0)]
1143
+ ]
1016
1144
  ] = None,
1017
1145
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1018
1146
  _content_type: Optional[StrictStr] = None,
@@ -1044,36 +1172,41 @@ class DockerRegistryApi:
1044
1172
  in the spec for a single request.
1045
1173
  :type _host_index: int, optional
1046
1174
  :return: Returns the result object.
1047
- """ # noqa: E501
1175
+ """ # noqa: E501
1048
1176
 
1049
1177
  _param = self._list_registries_serialize(
1050
1178
  x_daytona_organization_id=x_daytona_organization_id,
1051
1179
  _request_auth=_request_auth,
1052
1180
  _content_type=_content_type,
1053
1181
  _headers=_headers,
1054
- _host_index=_host_index,
1182
+ _host_index=_host_index
1055
1183
  )
1056
1184
 
1057
1185
  _response_types_map: Dict[str, Optional[str]] = {
1058
- "200": "List[DockerRegistry]",
1186
+ '200': "List[DockerRegistry]",
1059
1187
  }
1060
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1188
+ response_data = self.api_client.call_api(
1189
+ *_param,
1190
+ _request_timeout=_request_timeout
1191
+ )
1061
1192
  response_data.read()
1062
1193
  return self.api_client.response_deserialize(
1063
1194
  response_data=response_data,
1064
1195
  response_types_map=_response_types_map,
1065
1196
  ).data
1066
1197
 
1198
+
1067
1199
  @validate_call
1068
1200
  def list_registries_with_http_info(
1069
1201
  self,
1070
- x_daytona_organization_id: Annotated[
1071
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1072
- ] = None,
1202
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1073
1203
  _request_timeout: Union[
1074
1204
  None,
1075
1205
  Annotated[StrictFloat, Field(gt=0)],
1076
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1206
+ Tuple[
1207
+ Annotated[StrictFloat, Field(gt=0)],
1208
+ Annotated[StrictFloat, Field(gt=0)]
1209
+ ]
1077
1210
  ] = None,
1078
1211
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1079
1212
  _content_type: Optional[StrictStr] = None,
@@ -1105,36 +1238,41 @@ class DockerRegistryApi:
1105
1238
  in the spec for a single request.
1106
1239
  :type _host_index: int, optional
1107
1240
  :return: Returns the result object.
1108
- """ # noqa: E501
1241
+ """ # noqa: E501
1109
1242
 
1110
1243
  _param = self._list_registries_serialize(
1111
1244
  x_daytona_organization_id=x_daytona_organization_id,
1112
1245
  _request_auth=_request_auth,
1113
1246
  _content_type=_content_type,
1114
1247
  _headers=_headers,
1115
- _host_index=_host_index,
1248
+ _host_index=_host_index
1116
1249
  )
1117
1250
 
1118
1251
  _response_types_map: Dict[str, Optional[str]] = {
1119
- "200": "List[DockerRegistry]",
1252
+ '200': "List[DockerRegistry]",
1120
1253
  }
1121
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1254
+ response_data = self.api_client.call_api(
1255
+ *_param,
1256
+ _request_timeout=_request_timeout
1257
+ )
1122
1258
  response_data.read()
1123
1259
  return self.api_client.response_deserialize(
1124
1260
  response_data=response_data,
1125
1261
  response_types_map=_response_types_map,
1126
1262
  )
1127
1263
 
1264
+
1128
1265
  @validate_call
1129
1266
  def list_registries_without_preload_content(
1130
1267
  self,
1131
- x_daytona_organization_id: Annotated[
1132
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1133
- ] = None,
1268
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1134
1269
  _request_timeout: Union[
1135
1270
  None,
1136
1271
  Annotated[StrictFloat, Field(gt=0)],
1137
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1272
+ Tuple[
1273
+ Annotated[StrictFloat, Field(gt=0)],
1274
+ Annotated[StrictFloat, Field(gt=0)]
1275
+ ]
1138
1276
  ] = None,
1139
1277
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1140
1278
  _content_type: Optional[StrictStr] = None,
@@ -1166,22 +1304,26 @@ class DockerRegistryApi:
1166
1304
  in the spec for a single request.
1167
1305
  :type _host_index: int, optional
1168
1306
  :return: Returns the result object.
1169
- """ # noqa: E501
1307
+ """ # noqa: E501
1170
1308
 
1171
1309
  _param = self._list_registries_serialize(
1172
1310
  x_daytona_organization_id=x_daytona_organization_id,
1173
1311
  _request_auth=_request_auth,
1174
1312
  _content_type=_content_type,
1175
1313
  _headers=_headers,
1176
- _host_index=_host_index,
1314
+ _host_index=_host_index
1177
1315
  )
1178
1316
 
1179
1317
  _response_types_map: Dict[str, Optional[str]] = {
1180
- "200": "List[DockerRegistry]",
1318
+ '200': "List[DockerRegistry]",
1181
1319
  }
1182
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1320
+ response_data = self.api_client.call_api(
1321
+ *_param,
1322
+ _request_timeout=_request_timeout
1323
+ )
1183
1324
  return response_data.response
1184
1325
 
1326
+
1185
1327
  def _list_registries_serialize(
1186
1328
  self,
1187
1329
  x_daytona_organization_id,
@@ -1190,35 +1332,48 @@ class DockerRegistryApi:
1190
1332
  _headers,
1191
1333
  _host_index,
1192
1334
  ) -> RequestSerialized:
1335
+
1193
1336
  _host = None
1194
1337
 
1195
- _collection_formats: Dict[str, str] = {}
1338
+ _collection_formats: Dict[str, str] = {
1339
+ }
1196
1340
 
1197
1341
  _path_params: Dict[str, str] = {}
1198
1342
  _query_params: List[Tuple[str, str]] = []
1199
1343
  _header_params: Dict[str, Optional[str]] = _headers or {}
1200
1344
  _form_params: List[Tuple[str, str]] = []
1201
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
1345
+ _files: Dict[
1346
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1347
+ ] = {}
1202
1348
  _body_params: Optional[bytes] = None
1203
1349
 
1204
1350
  # process the path parameters
1205
1351
  # process the query parameters
1206
1352
  # process the header parameters
1207
1353
  if x_daytona_organization_id is not None:
1208
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
1354
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
1209
1355
  # process the form parameters
1210
1356
  # process the body parameter
1211
1357
 
1358
+
1212
1359
  # set the HTTP header `Accept`
1213
- if "Accept" not in _header_params:
1214
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
1360
+ if 'Accept' not in _header_params:
1361
+ _header_params['Accept'] = self.api_client.select_header_accept(
1362
+ [
1363
+ 'application/json'
1364
+ ]
1365
+ )
1366
+
1215
1367
 
1216
1368
  # authentication setting
1217
- _auth_settings: List[str] = ["bearer", "oauth2"]
1369
+ _auth_settings: List[str] = [
1370
+ 'bearer',
1371
+ 'oauth2'
1372
+ ]
1218
1373
 
1219
1374
  return self.api_client.param_serialize(
1220
- method="GET",
1221
- resource_path="/docker-registry",
1375
+ method='GET',
1376
+ resource_path='/docker-registry',
1222
1377
  path_params=_path_params,
1223
1378
  query_params=_query_params,
1224
1379
  header_params=_header_params,
@@ -1228,20 +1383,24 @@ class DockerRegistryApi:
1228
1383
  auth_settings=_auth_settings,
1229
1384
  collection_formats=_collection_formats,
1230
1385
  _host=_host,
1231
- _request_auth=_request_auth,
1386
+ _request_auth=_request_auth
1232
1387
  )
1233
1388
 
1389
+
1390
+
1391
+
1234
1392
  @validate_call
1235
1393
  def set_default_registry(
1236
1394
  self,
1237
1395
  id: Annotated[StrictStr, Field(description="ID of the docker registry")],
1238
- x_daytona_organization_id: Annotated[
1239
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1240
- ] = None,
1396
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1241
1397
  _request_timeout: Union[
1242
1398
  None,
1243
1399
  Annotated[StrictFloat, Field(gt=0)],
1244
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1400
+ Tuple[
1401
+ Annotated[StrictFloat, Field(gt=0)],
1402
+ Annotated[StrictFloat, Field(gt=0)]
1403
+ ]
1245
1404
  ] = None,
1246
1405
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1247
1406
  _content_type: Optional[StrictStr] = None,
@@ -1275,7 +1434,7 @@ class DockerRegistryApi:
1275
1434
  in the spec for a single request.
1276
1435
  :type _host_index: int, optional
1277
1436
  :return: Returns the result object.
1278
- """ # noqa: E501
1437
+ """ # noqa: E501
1279
1438
 
1280
1439
  _param = self._set_default_registry_serialize(
1281
1440
  id=id,
@@ -1283,30 +1442,35 @@ class DockerRegistryApi:
1283
1442
  _request_auth=_request_auth,
1284
1443
  _content_type=_content_type,
1285
1444
  _headers=_headers,
1286
- _host_index=_host_index,
1445
+ _host_index=_host_index
1287
1446
  )
1288
1447
 
1289
1448
  _response_types_map: Dict[str, Optional[str]] = {
1290
- "200": "DockerRegistry",
1449
+ '200': "DockerRegistry",
1291
1450
  }
1292
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1451
+ response_data = self.api_client.call_api(
1452
+ *_param,
1453
+ _request_timeout=_request_timeout
1454
+ )
1293
1455
  response_data.read()
1294
1456
  return self.api_client.response_deserialize(
1295
1457
  response_data=response_data,
1296
1458
  response_types_map=_response_types_map,
1297
1459
  ).data
1298
1460
 
1461
+
1299
1462
  @validate_call
1300
1463
  def set_default_registry_with_http_info(
1301
1464
  self,
1302
1465
  id: Annotated[StrictStr, Field(description="ID of the docker registry")],
1303
- x_daytona_organization_id: Annotated[
1304
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1305
- ] = None,
1466
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1306
1467
  _request_timeout: Union[
1307
1468
  None,
1308
1469
  Annotated[StrictFloat, Field(gt=0)],
1309
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1470
+ Tuple[
1471
+ Annotated[StrictFloat, Field(gt=0)],
1472
+ Annotated[StrictFloat, Field(gt=0)]
1473
+ ]
1310
1474
  ] = None,
1311
1475
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1312
1476
  _content_type: Optional[StrictStr] = None,
@@ -1340,7 +1504,7 @@ class DockerRegistryApi:
1340
1504
  in the spec for a single request.
1341
1505
  :type _host_index: int, optional
1342
1506
  :return: Returns the result object.
1343
- """ # noqa: E501
1507
+ """ # noqa: E501
1344
1508
 
1345
1509
  _param = self._set_default_registry_serialize(
1346
1510
  id=id,
@@ -1348,30 +1512,35 @@ class DockerRegistryApi:
1348
1512
  _request_auth=_request_auth,
1349
1513
  _content_type=_content_type,
1350
1514
  _headers=_headers,
1351
- _host_index=_host_index,
1515
+ _host_index=_host_index
1352
1516
  )
1353
1517
 
1354
1518
  _response_types_map: Dict[str, Optional[str]] = {
1355
- "200": "DockerRegistry",
1519
+ '200': "DockerRegistry",
1356
1520
  }
1357
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1521
+ response_data = self.api_client.call_api(
1522
+ *_param,
1523
+ _request_timeout=_request_timeout
1524
+ )
1358
1525
  response_data.read()
1359
1526
  return self.api_client.response_deserialize(
1360
1527
  response_data=response_data,
1361
1528
  response_types_map=_response_types_map,
1362
1529
  )
1363
1530
 
1531
+
1364
1532
  @validate_call
1365
1533
  def set_default_registry_without_preload_content(
1366
1534
  self,
1367
1535
  id: Annotated[StrictStr, Field(description="ID of the docker registry")],
1368
- x_daytona_organization_id: Annotated[
1369
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1370
- ] = None,
1536
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1371
1537
  _request_timeout: Union[
1372
1538
  None,
1373
1539
  Annotated[StrictFloat, Field(gt=0)],
1374
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1540
+ Tuple[
1541
+ Annotated[StrictFloat, Field(gt=0)],
1542
+ Annotated[StrictFloat, Field(gt=0)]
1543
+ ]
1375
1544
  ] = None,
1376
1545
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1377
1546
  _content_type: Optional[StrictStr] = None,
@@ -1405,7 +1574,7 @@ class DockerRegistryApi:
1405
1574
  in the spec for a single request.
1406
1575
  :type _host_index: int, optional
1407
1576
  :return: Returns the result object.
1408
- """ # noqa: E501
1577
+ """ # noqa: E501
1409
1578
 
1410
1579
  _param = self._set_default_registry_serialize(
1411
1580
  id=id,
@@ -1413,15 +1582,19 @@ class DockerRegistryApi:
1413
1582
  _request_auth=_request_auth,
1414
1583
  _content_type=_content_type,
1415
1584
  _headers=_headers,
1416
- _host_index=_host_index,
1585
+ _host_index=_host_index
1417
1586
  )
1418
1587
 
1419
1588
  _response_types_map: Dict[str, Optional[str]] = {
1420
- "200": "DockerRegistry",
1589
+ '200': "DockerRegistry",
1421
1590
  }
1422
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1591
+ response_data = self.api_client.call_api(
1592
+ *_param,
1593
+ _request_timeout=_request_timeout
1594
+ )
1423
1595
  return response_data.response
1424
1596
 
1597
+
1425
1598
  def _set_default_registry_serialize(
1426
1599
  self,
1427
1600
  id,
@@ -1431,37 +1604,50 @@ class DockerRegistryApi:
1431
1604
  _headers,
1432
1605
  _host_index,
1433
1606
  ) -> RequestSerialized:
1607
+
1434
1608
  _host = None
1435
1609
 
1436
- _collection_formats: Dict[str, str] = {}
1610
+ _collection_formats: Dict[str, str] = {
1611
+ }
1437
1612
 
1438
1613
  _path_params: Dict[str, str] = {}
1439
1614
  _query_params: List[Tuple[str, str]] = []
1440
1615
  _header_params: Dict[str, Optional[str]] = _headers or {}
1441
1616
  _form_params: List[Tuple[str, str]] = []
1442
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
1617
+ _files: Dict[
1618
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1619
+ ] = {}
1443
1620
  _body_params: Optional[bytes] = None
1444
1621
 
1445
1622
  # process the path parameters
1446
1623
  if id is not None:
1447
- _path_params["id"] = id
1624
+ _path_params['id'] = id
1448
1625
  # process the query parameters
1449
1626
  # process the header parameters
1450
1627
  if x_daytona_organization_id is not None:
1451
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
1628
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
1452
1629
  # process the form parameters
1453
1630
  # process the body parameter
1454
1631
 
1632
+
1455
1633
  # set the HTTP header `Accept`
1456
- if "Accept" not in _header_params:
1457
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
1634
+ if 'Accept' not in _header_params:
1635
+ _header_params['Accept'] = self.api_client.select_header_accept(
1636
+ [
1637
+ 'application/json'
1638
+ ]
1639
+ )
1640
+
1458
1641
 
1459
1642
  # authentication setting
1460
- _auth_settings: List[str] = ["bearer", "oauth2"]
1643
+ _auth_settings: List[str] = [
1644
+ 'bearer',
1645
+ 'oauth2'
1646
+ ]
1461
1647
 
1462
1648
  return self.api_client.param_serialize(
1463
- method="POST",
1464
- resource_path="/docker-registry/{id}/set-default",
1649
+ method='POST',
1650
+ resource_path='/docker-registry/{id}/set-default',
1465
1651
  path_params=_path_params,
1466
1652
  query_params=_query_params,
1467
1653
  header_params=_header_params,
@@ -1471,21 +1657,25 @@ class DockerRegistryApi:
1471
1657
  auth_settings=_auth_settings,
1472
1658
  collection_formats=_collection_formats,
1473
1659
  _host=_host,
1474
- _request_auth=_request_auth,
1660
+ _request_auth=_request_auth
1475
1661
  )
1476
1662
 
1663
+
1664
+
1665
+
1477
1666
  @validate_call
1478
1667
  def update_registry(
1479
1668
  self,
1480
1669
  id: Annotated[StrictStr, Field(description="ID of the docker registry")],
1481
1670
  update_docker_registry: UpdateDockerRegistry,
1482
- x_daytona_organization_id: Annotated[
1483
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1484
- ] = None,
1671
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1485
1672
  _request_timeout: Union[
1486
1673
  None,
1487
1674
  Annotated[StrictFloat, Field(gt=0)],
1488
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1675
+ Tuple[
1676
+ Annotated[StrictFloat, Field(gt=0)],
1677
+ Annotated[StrictFloat, Field(gt=0)]
1678
+ ]
1489
1679
  ] = None,
1490
1680
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1491
1681
  _content_type: Optional[StrictStr] = None,
@@ -1521,7 +1711,7 @@ class DockerRegistryApi:
1521
1711
  in the spec for a single request.
1522
1712
  :type _host_index: int, optional
1523
1713
  :return: Returns the result object.
1524
- """ # noqa: E501
1714
+ """ # noqa: E501
1525
1715
 
1526
1716
  _param = self._update_registry_serialize(
1527
1717
  id=id,
@@ -1530,31 +1720,36 @@ class DockerRegistryApi:
1530
1720
  _request_auth=_request_auth,
1531
1721
  _content_type=_content_type,
1532
1722
  _headers=_headers,
1533
- _host_index=_host_index,
1723
+ _host_index=_host_index
1534
1724
  )
1535
1725
 
1536
1726
  _response_types_map: Dict[str, Optional[str]] = {
1537
- "200": "DockerRegistry",
1727
+ '200': "DockerRegistry",
1538
1728
  }
1539
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1729
+ response_data = self.api_client.call_api(
1730
+ *_param,
1731
+ _request_timeout=_request_timeout
1732
+ )
1540
1733
  response_data.read()
1541
1734
  return self.api_client.response_deserialize(
1542
1735
  response_data=response_data,
1543
1736
  response_types_map=_response_types_map,
1544
1737
  ).data
1545
1738
 
1739
+
1546
1740
  @validate_call
1547
1741
  def update_registry_with_http_info(
1548
1742
  self,
1549
1743
  id: Annotated[StrictStr, Field(description="ID of the docker registry")],
1550
1744
  update_docker_registry: UpdateDockerRegistry,
1551
- x_daytona_organization_id: Annotated[
1552
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1553
- ] = None,
1745
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1554
1746
  _request_timeout: Union[
1555
1747
  None,
1556
1748
  Annotated[StrictFloat, Field(gt=0)],
1557
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1749
+ Tuple[
1750
+ Annotated[StrictFloat, Field(gt=0)],
1751
+ Annotated[StrictFloat, Field(gt=0)]
1752
+ ]
1558
1753
  ] = None,
1559
1754
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1560
1755
  _content_type: Optional[StrictStr] = None,
@@ -1590,7 +1785,7 @@ class DockerRegistryApi:
1590
1785
  in the spec for a single request.
1591
1786
  :type _host_index: int, optional
1592
1787
  :return: Returns the result object.
1593
- """ # noqa: E501
1788
+ """ # noqa: E501
1594
1789
 
1595
1790
  _param = self._update_registry_serialize(
1596
1791
  id=id,
@@ -1599,31 +1794,36 @@ class DockerRegistryApi:
1599
1794
  _request_auth=_request_auth,
1600
1795
  _content_type=_content_type,
1601
1796
  _headers=_headers,
1602
- _host_index=_host_index,
1797
+ _host_index=_host_index
1603
1798
  )
1604
1799
 
1605
1800
  _response_types_map: Dict[str, Optional[str]] = {
1606
- "200": "DockerRegistry",
1801
+ '200': "DockerRegistry",
1607
1802
  }
1608
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1803
+ response_data = self.api_client.call_api(
1804
+ *_param,
1805
+ _request_timeout=_request_timeout
1806
+ )
1609
1807
  response_data.read()
1610
1808
  return self.api_client.response_deserialize(
1611
1809
  response_data=response_data,
1612
1810
  response_types_map=_response_types_map,
1613
1811
  )
1614
1812
 
1813
+
1615
1814
  @validate_call
1616
1815
  def update_registry_without_preload_content(
1617
1816
  self,
1618
1817
  id: Annotated[StrictStr, Field(description="ID of the docker registry")],
1619
1818
  update_docker_registry: UpdateDockerRegistry,
1620
- x_daytona_organization_id: Annotated[
1621
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1622
- ] = None,
1819
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1623
1820
  _request_timeout: Union[
1624
1821
  None,
1625
1822
  Annotated[StrictFloat, Field(gt=0)],
1626
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1823
+ Tuple[
1824
+ Annotated[StrictFloat, Field(gt=0)],
1825
+ Annotated[StrictFloat, Field(gt=0)]
1826
+ ]
1627
1827
  ] = None,
1628
1828
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1629
1829
  _content_type: Optional[StrictStr] = None,
@@ -1659,7 +1859,7 @@ class DockerRegistryApi:
1659
1859
  in the spec for a single request.
1660
1860
  :type _host_index: int, optional
1661
1861
  :return: Returns the result object.
1662
- """ # noqa: E501
1862
+ """ # noqa: E501
1663
1863
 
1664
1864
  _param = self._update_registry_serialize(
1665
1865
  id=id,
@@ -1668,15 +1868,19 @@ class DockerRegistryApi:
1668
1868
  _request_auth=_request_auth,
1669
1869
  _content_type=_content_type,
1670
1870
  _headers=_headers,
1671
- _host_index=_host_index,
1871
+ _host_index=_host_index
1672
1872
  )
1673
1873
 
1674
1874
  _response_types_map: Dict[str, Optional[str]] = {
1675
- "200": "DockerRegistry",
1875
+ '200': "DockerRegistry",
1676
1876
  }
1677
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1877
+ response_data = self.api_client.call_api(
1878
+ *_param,
1879
+ _request_timeout=_request_timeout
1880
+ )
1678
1881
  return response_data.response
1679
1882
 
1883
+
1680
1884
  def _update_registry_serialize(
1681
1885
  self,
1682
1886
  id,
@@ -1687,47 +1891,65 @@ class DockerRegistryApi:
1687
1891
  _headers,
1688
1892
  _host_index,
1689
1893
  ) -> RequestSerialized:
1894
+
1690
1895
  _host = None
1691
1896
 
1692
- _collection_formats: Dict[str, str] = {}
1897
+ _collection_formats: Dict[str, str] = {
1898
+ }
1693
1899
 
1694
1900
  _path_params: Dict[str, str] = {}
1695
1901
  _query_params: List[Tuple[str, str]] = []
1696
1902
  _header_params: Dict[str, Optional[str]] = _headers or {}
1697
1903
  _form_params: List[Tuple[str, str]] = []
1698
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
1904
+ _files: Dict[
1905
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1906
+ ] = {}
1699
1907
  _body_params: Optional[bytes] = None
1700
1908
 
1701
1909
  # process the path parameters
1702
1910
  if id is not None:
1703
- _path_params["id"] = id
1911
+ _path_params['id'] = id
1704
1912
  # process the query parameters
1705
1913
  # process the header parameters
1706
1914
  if x_daytona_organization_id is not None:
1707
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
1915
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
1708
1916
  # process the form parameters
1709
1917
  # process the body parameter
1710
1918
  if update_docker_registry is not None:
1711
1919
  _body_params = update_docker_registry
1712
1920
 
1921
+
1713
1922
  # set the HTTP header `Accept`
1714
- if "Accept" not in _header_params:
1715
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
1923
+ if 'Accept' not in _header_params:
1924
+ _header_params['Accept'] = self.api_client.select_header_accept(
1925
+ [
1926
+ 'application/json'
1927
+ ]
1928
+ )
1716
1929
 
1717
1930
  # set the HTTP header `Content-Type`
1718
1931
  if _content_type:
1719
- _header_params["Content-Type"] = _content_type
1932
+ _header_params['Content-Type'] = _content_type
1720
1933
  else:
1721
- _default_content_type = self.api_client.select_header_content_type(["application/json"])
1934
+ _default_content_type = (
1935
+ self.api_client.select_header_content_type(
1936
+ [
1937
+ 'application/json'
1938
+ ]
1939
+ )
1940
+ )
1722
1941
  if _default_content_type is not None:
1723
- _header_params["Content-Type"] = _default_content_type
1942
+ _header_params['Content-Type'] = _default_content_type
1724
1943
 
1725
1944
  # authentication setting
1726
- _auth_settings: List[str] = ["bearer", "oauth2"]
1945
+ _auth_settings: List[str] = [
1946
+ 'bearer',
1947
+ 'oauth2'
1948
+ ]
1727
1949
 
1728
1950
  return self.api_client.param_serialize(
1729
- method="PATCH",
1730
- resource_path="/docker-registry/{id}",
1951
+ method='PATCH',
1952
+ resource_path='/docker-registry/{id}',
1731
1953
  path_params=_path_params,
1732
1954
  query_params=_query_params,
1733
1955
  header_params=_header_params,
@@ -1737,5 +1959,7 @@ class DockerRegistryApi:
1737
1959
  auth_settings=_auth_settings,
1738
1960
  collection_formats=_collection_formats,
1739
1961
  _host=_host,
1740
- _request_auth=_request_auth,
1962
+ _request_auth=_request_auth
1741
1963
  )
1964
+
1965
+