daytona_api_client 0.21.3a0__py3-none-any.whl → 0.21.5a0__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.5a0.dist-info}/METADATA +1 -1
  104. daytona_api_client-0.21.5a0.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.5a0.dist-info}/WHEEL +0 -0
  107. {daytona_api_client-0.21.3a0.dist-info → daytona_api_client-0.21.5a0.dist-info}/top_level.txt +0 -0
daytona_api_client/api/volumes_api.py CHANGED
@@ -40,17 +40,19 @@ class VolumesApi:
40
40
  api_client = ApiClient.get_default()
41
41
  self.api_client = api_client
42
42
 
43
+
43
44
  @validate_call
44
45
  def create_volume(
45
46
  self,
46
47
  create_volume: CreateVolume,
47
- x_daytona_organization_id: Annotated[
48
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
49
- ] = None,
48
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
50
49
  _request_timeout: Union[
51
50
  None,
52
51
  Annotated[StrictFloat, Field(gt=0)],
53
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
52
+ Tuple[
53
+ Annotated[StrictFloat, Field(gt=0)],
54
+ Annotated[StrictFloat, Field(gt=0)]
55
+ ]
54
56
  ] = None,
55
57
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
56
58
  _content_type: Optional[StrictStr] = None,
@@ -84,7 +86,7 @@ class VolumesApi:
84
86
  in the spec for a single request.
85
87
  :type _host_index: int, optional
86
88
  :return: Returns the result object.
87
- """ # noqa: E501
89
+ """ # noqa: E501
88
90
 
89
91
  _param = self._create_volume_serialize(
90
92
  create_volume=create_volume,
@@ -92,30 +94,35 @@ class VolumesApi:
92
94
  _request_auth=_request_auth,
93
95
  _content_type=_content_type,
94
96
  _headers=_headers,
95
- _host_index=_host_index,
97
+ _host_index=_host_index
96
98
  )
97
99
 
98
100
  _response_types_map: Dict[str, Optional[str]] = {
99
- "200": "VolumeDto",
101
+ '200': "VolumeDto",
100
102
  }
101
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
103
+ response_data = self.api_client.call_api(
104
+ *_param,
105
+ _request_timeout=_request_timeout
106
+ )
102
107
  response_data.read()
103
108
  return self.api_client.response_deserialize(
104
109
  response_data=response_data,
105
110
  response_types_map=_response_types_map,
106
111
  ).data
107
112
 
113
+
108
114
  @validate_call
109
115
  def create_volume_with_http_info(
110
116
  self,
111
117
  create_volume: CreateVolume,
112
- x_daytona_organization_id: Annotated[
113
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
114
- ] = None,
118
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
115
119
  _request_timeout: Union[
116
120
  None,
117
121
  Annotated[StrictFloat, Field(gt=0)],
118
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
122
+ Tuple[
123
+ Annotated[StrictFloat, Field(gt=0)],
124
+ Annotated[StrictFloat, Field(gt=0)]
125
+ ]
119
126
  ] = None,
120
127
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
121
128
  _content_type: Optional[StrictStr] = None,
@@ -149,7 +156,7 @@ class VolumesApi:
149
156
  in the spec for a single request.
150
157
  :type _host_index: int, optional
151
158
  :return: Returns the result object.
152
- """ # noqa: E501
159
+ """ # noqa: E501
153
160
 
154
161
  _param = self._create_volume_serialize(
155
162
  create_volume=create_volume,
@@ -157,30 +164,35 @@ class VolumesApi:
157
164
  _request_auth=_request_auth,
158
165
  _content_type=_content_type,
159
166
  _headers=_headers,
160
- _host_index=_host_index,
167
+ _host_index=_host_index
161
168
  )
162
169
 
163
170
  _response_types_map: Dict[str, Optional[str]] = {
164
- "200": "VolumeDto",
171
+ '200': "VolumeDto",
165
172
  }
166
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
173
+ response_data = self.api_client.call_api(
174
+ *_param,
175
+ _request_timeout=_request_timeout
176
+ )
167
177
  response_data.read()
168
178
  return self.api_client.response_deserialize(
169
179
  response_data=response_data,
170
180
  response_types_map=_response_types_map,
171
181
  )
172
182
 
183
+
173
184
  @validate_call
174
185
  def create_volume_without_preload_content(
175
186
  self,
176
187
  create_volume: CreateVolume,
177
- x_daytona_organization_id: Annotated[
178
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
179
- ] = None,
188
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
180
189
  _request_timeout: Union[
181
190
  None,
182
191
  Annotated[StrictFloat, Field(gt=0)],
183
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
192
+ Tuple[
193
+ Annotated[StrictFloat, Field(gt=0)],
194
+ Annotated[StrictFloat, Field(gt=0)]
195
+ ]
184
196
  ] = None,
185
197
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
186
198
  _content_type: Optional[StrictStr] = None,
@@ -214,7 +226,7 @@ class VolumesApi:
214
226
  in the spec for a single request.
215
227
  :type _host_index: int, optional
216
228
  :return: Returns the result object.
217
- """ # noqa: E501
229
+ """ # noqa: E501
218
230
 
219
231
  _param = self._create_volume_serialize(
220
232
  create_volume=create_volume,
@@ -222,15 +234,19 @@ class VolumesApi:
222
234
  _request_auth=_request_auth,
223
235
  _content_type=_content_type,
224
236
  _headers=_headers,
225
- _host_index=_host_index,
237
+ _host_index=_host_index
226
238
  )
227
239
 
228
240
  _response_types_map: Dict[str, Optional[str]] = {
229
- "200": "VolumeDto",
241
+ '200': "VolumeDto",
230
242
  }
231
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
243
+ response_data = self.api_client.call_api(
244
+ *_param,
245
+ _request_timeout=_request_timeout
246
+ )
232
247
  return response_data.response
233
248
 
249
+
234
250
  def _create_volume_serialize(
235
251
  self,
236
252
  create_volume,
@@ -240,45 +256,63 @@ class VolumesApi:
240
256
  _headers,
241
257
  _host_index,
242
258
  ) -> RequestSerialized:
259
+
243
260
  _host = None
244
261
 
245
- _collection_formats: Dict[str, str] = {}
262
+ _collection_formats: Dict[str, str] = {
263
+ }
246
264
 
247
265
  _path_params: Dict[str, str] = {}
248
266
  _query_params: List[Tuple[str, str]] = []
249
267
  _header_params: Dict[str, Optional[str]] = _headers or {}
250
268
  _form_params: List[Tuple[str, str]] = []
251
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
269
+ _files: Dict[
270
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
271
+ ] = {}
252
272
  _body_params: Optional[bytes] = None
253
273
 
254
274
  # process the path parameters
255
275
  # process the query parameters
256
276
  # process the header parameters
257
277
  if x_daytona_organization_id is not None:
258
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
278
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
259
279
  # process the form parameters
260
280
  # process the body parameter
261
281
  if create_volume is not None:
262
282
  _body_params = create_volume
263
283
 
284
+
264
285
  # set the HTTP header `Accept`
265
- if "Accept" not in _header_params:
266
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
286
+ if 'Accept' not in _header_params:
287
+ _header_params['Accept'] = self.api_client.select_header_accept(
288
+ [
289
+ 'application/json'
290
+ ]
291
+ )
267
292
 
268
293
  # set the HTTP header `Content-Type`
269
294
  if _content_type:
270
- _header_params["Content-Type"] = _content_type
295
+ _header_params['Content-Type'] = _content_type
271
296
  else:
272
- _default_content_type = self.api_client.select_header_content_type(["application/json"])
297
+ _default_content_type = (
298
+ self.api_client.select_header_content_type(
299
+ [
300
+ 'application/json'
301
+ ]
302
+ )
303
+ )
273
304
  if _default_content_type is not None:
274
- _header_params["Content-Type"] = _default_content_type
305
+ _header_params['Content-Type'] = _default_content_type
275
306
 
276
307
  # authentication setting
277
- _auth_settings: List[str] = ["bearer", "oauth2"]
308
+ _auth_settings: List[str] = [
309
+ 'bearer',
310
+ 'oauth2'
311
+ ]
278
312
 
279
313
  return self.api_client.param_serialize(
280
- method="POST",
281
- resource_path="/volumes",
314
+ method='POST',
315
+ resource_path='/volumes',
282
316
  path_params=_path_params,
283
317
  query_params=_query_params,
284
318
  header_params=_header_params,
@@ -288,20 +322,24 @@ class VolumesApi:
288
322
  auth_settings=_auth_settings,
289
323
  collection_formats=_collection_formats,
290
324
  _host=_host,
291
- _request_auth=_request_auth,
325
+ _request_auth=_request_auth
292
326
  )
293
327
 
328
+
329
+
330
+
294
331
  @validate_call
295
332
  def delete_volume(
296
333
  self,
297
334
  volume_id: Annotated[StrictStr, Field(description="ID of the volume")],
298
- x_daytona_organization_id: Annotated[
299
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
300
- ] = None,
335
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
301
336
  _request_timeout: Union[
302
337
  None,
303
338
  Annotated[StrictFloat, Field(gt=0)],
304
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
339
+ Tuple[
340
+ Annotated[StrictFloat, Field(gt=0)],
341
+ Annotated[StrictFloat, Field(gt=0)]
342
+ ]
305
343
  ] = None,
306
344
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
307
345
  _content_type: Optional[StrictStr] = None,
@@ -335,7 +373,7 @@ class VolumesApi:
335
373
  in the spec for a single request.
336
374
  :type _host_index: int, optional
337
375
  :return: Returns the result object.
338
- """ # noqa: E501
376
+ """ # noqa: E501
339
377
 
340
378
  _param = self._delete_volume_serialize(
341
379
  volume_id=volume_id,
@@ -343,30 +381,35 @@ class VolumesApi:
343
381
  _request_auth=_request_auth,
344
382
  _content_type=_content_type,
345
383
  _headers=_headers,
346
- _host_index=_host_index,
384
+ _host_index=_host_index
347
385
  )
348
386
 
349
387
  _response_types_map: Dict[str, Optional[str]] = {
350
- "200": None,
388
+ '200': None,
351
389
  }
352
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
390
+ response_data = self.api_client.call_api(
391
+ *_param,
392
+ _request_timeout=_request_timeout
393
+ )
353
394
  response_data.read()
354
395
  return self.api_client.response_deserialize(
355
396
  response_data=response_data,
356
397
  response_types_map=_response_types_map,
357
398
  ).data
358
399
 
400
+
359
401
  @validate_call
360
402
  def delete_volume_with_http_info(
361
403
  self,
362
404
  volume_id: Annotated[StrictStr, Field(description="ID of the volume")],
363
- x_daytona_organization_id: Annotated[
364
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
365
- ] = None,
405
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
366
406
  _request_timeout: Union[
367
407
  None,
368
408
  Annotated[StrictFloat, Field(gt=0)],
369
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
409
+ Tuple[
410
+ Annotated[StrictFloat, Field(gt=0)],
411
+ Annotated[StrictFloat, Field(gt=0)]
412
+ ]
370
413
  ] = None,
371
414
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
372
415
  _content_type: Optional[StrictStr] = None,
@@ -400,7 +443,7 @@ class VolumesApi:
400
443
  in the spec for a single request.
401
444
  :type _host_index: int, optional
402
445
  :return: Returns the result object.
403
- """ # noqa: E501
446
+ """ # noqa: E501
404
447
 
405
448
  _param = self._delete_volume_serialize(
406
449
  volume_id=volume_id,
@@ -408,30 +451,35 @@ class VolumesApi:
408
451
  _request_auth=_request_auth,
409
452
  _content_type=_content_type,
410
453
  _headers=_headers,
411
- _host_index=_host_index,
454
+ _host_index=_host_index
412
455
  )
413
456
 
414
457
  _response_types_map: Dict[str, Optional[str]] = {
415
- "200": None,
458
+ '200': None,
416
459
  }
417
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
460
+ response_data = self.api_client.call_api(
461
+ *_param,
462
+ _request_timeout=_request_timeout
463
+ )
418
464
  response_data.read()
419
465
  return self.api_client.response_deserialize(
420
466
  response_data=response_data,
421
467
  response_types_map=_response_types_map,
422
468
  )
423
469
 
470
+
424
471
  @validate_call
425
472
  def delete_volume_without_preload_content(
426
473
  self,
427
474
  volume_id: Annotated[StrictStr, Field(description="ID of the volume")],
428
- x_daytona_organization_id: Annotated[
429
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
430
- ] = None,
475
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
431
476
  _request_timeout: Union[
432
477
  None,
433
478
  Annotated[StrictFloat, Field(gt=0)],
434
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
479
+ Tuple[
480
+ Annotated[StrictFloat, Field(gt=0)],
481
+ Annotated[StrictFloat, Field(gt=0)]
482
+ ]
435
483
  ] = None,
436
484
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
437
485
  _content_type: Optional[StrictStr] = None,
@@ -465,7 +513,7 @@ class VolumesApi:
465
513
  in the spec for a single request.
466
514
  :type _host_index: int, optional
467
515
  :return: Returns the result object.
468
- """ # noqa: E501
516
+ """ # noqa: E501
469
517
 
470
518
  _param = self._delete_volume_serialize(
471
519
  volume_id=volume_id,
@@ -473,15 +521,19 @@ class VolumesApi:
473
521
  _request_auth=_request_auth,
474
522
  _content_type=_content_type,
475
523
  _headers=_headers,
476
- _host_index=_host_index,
524
+ _host_index=_host_index
477
525
  )
478
526
 
479
527
  _response_types_map: Dict[str, Optional[str]] = {
480
- "200": None,
528
+ '200': None,
481
529
  }
482
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
530
+ response_data = self.api_client.call_api(
531
+ *_param,
532
+ _request_timeout=_request_timeout
533
+ )
483
534
  return response_data.response
484
535
 
536
+
485
537
  def _delete_volume_serialize(
486
538
  self,
487
539
  volume_id,
@@ -491,33 +543,43 @@ class VolumesApi:
491
543
  _headers,
492
544
  _host_index,
493
545
  ) -> RequestSerialized:
546
+
494
547
  _host = None
495
548
 
496
- _collection_formats: Dict[str, str] = {}
549
+ _collection_formats: Dict[str, str] = {
550
+ }
497
551
 
498
552
  _path_params: Dict[str, str] = {}
499
553
  _query_params: List[Tuple[str, str]] = []
500
554
  _header_params: Dict[str, Optional[str]] = _headers or {}
501
555
  _form_params: List[Tuple[str, str]] = []
502
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
556
+ _files: Dict[
557
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
558
+ ] = {}
503
559
  _body_params: Optional[bytes] = None
504
560
 
505
561
  # process the path parameters
506
562
  if volume_id is not None:
507
- _path_params["volumeId"] = volume_id
563
+ _path_params['volumeId'] = volume_id
508
564
  # process the query parameters
509
565
  # process the header parameters
510
566
  if x_daytona_organization_id is not None:
511
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
567
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
512
568
  # process the form parameters
513
569
  # process the body parameter
514
570
 
571
+
572
+
573
+
515
574
  # authentication setting
516
- _auth_settings: List[str] = ["bearer", "oauth2"]
575
+ _auth_settings: List[str] = [
576
+ 'bearer',
577
+ 'oauth2'
578
+ ]
517
579
 
518
580
  return self.api_client.param_serialize(
519
- method="DELETE",
520
- resource_path="/volumes/{volumeId}",
581
+ method='DELETE',
582
+ resource_path='/volumes/{volumeId}',
521
583
  path_params=_path_params,
522
584
  query_params=_query_params,
523
585
  header_params=_header_params,
@@ -527,20 +589,24 @@ class VolumesApi:
527
589
  auth_settings=_auth_settings,
528
590
  collection_formats=_collection_formats,
529
591
  _host=_host,
530
- _request_auth=_request_auth,
592
+ _request_auth=_request_auth
531
593
  )
532
594
 
595
+
596
+
597
+
533
598
  @validate_call
534
599
  def get_volume(
535
600
  self,
536
601
  volume_id: Annotated[StrictStr, Field(description="ID of the volume")],
537
- x_daytona_organization_id: Annotated[
538
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
539
- ] = None,
602
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
540
603
  _request_timeout: Union[
541
604
  None,
542
605
  Annotated[StrictFloat, Field(gt=0)],
543
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
606
+ Tuple[
607
+ Annotated[StrictFloat, Field(gt=0)],
608
+ Annotated[StrictFloat, Field(gt=0)]
609
+ ]
544
610
  ] = None,
545
611
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
546
612
  _content_type: Optional[StrictStr] = None,
@@ -574,7 +640,7 @@ class VolumesApi:
574
640
  in the spec for a single request.
575
641
  :type _host_index: int, optional
576
642
  :return: Returns the result object.
577
- """ # noqa: E501
643
+ """ # noqa: E501
578
644
 
579
645
  _param = self._get_volume_serialize(
580
646
  volume_id=volume_id,
@@ -582,30 +648,35 @@ class VolumesApi:
582
648
  _request_auth=_request_auth,
583
649
  _content_type=_content_type,
584
650
  _headers=_headers,
585
- _host_index=_host_index,
651
+ _host_index=_host_index
586
652
  )
587
653
 
588
654
  _response_types_map: Dict[str, Optional[str]] = {
589
- "200": "VolumeDto",
655
+ '200': "VolumeDto",
590
656
  }
591
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
657
+ response_data = self.api_client.call_api(
658
+ *_param,
659
+ _request_timeout=_request_timeout
660
+ )
592
661
  response_data.read()
593
662
  return self.api_client.response_deserialize(
594
663
  response_data=response_data,
595
664
  response_types_map=_response_types_map,
596
665
  ).data
597
666
 
667
+
598
668
  @validate_call
599
669
  def get_volume_with_http_info(
600
670
  self,
601
671
  volume_id: Annotated[StrictStr, Field(description="ID of the volume")],
602
- x_daytona_organization_id: Annotated[
603
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
604
- ] = None,
672
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
605
673
  _request_timeout: Union[
606
674
  None,
607
675
  Annotated[StrictFloat, Field(gt=0)],
608
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
676
+ Tuple[
677
+ Annotated[StrictFloat, Field(gt=0)],
678
+ Annotated[StrictFloat, Field(gt=0)]
679
+ ]
609
680
  ] = None,
610
681
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
611
682
  _content_type: Optional[StrictStr] = None,
@@ -639,7 +710,7 @@ class VolumesApi:
639
710
  in the spec for a single request.
640
711
  :type _host_index: int, optional
641
712
  :return: Returns the result object.
642
- """ # noqa: E501
713
+ """ # noqa: E501
643
714
 
644
715
  _param = self._get_volume_serialize(
645
716
  volume_id=volume_id,
@@ -647,30 +718,35 @@ class VolumesApi:
647
718
  _request_auth=_request_auth,
648
719
  _content_type=_content_type,
649
720
  _headers=_headers,
650
- _host_index=_host_index,
721
+ _host_index=_host_index
651
722
  )
652
723
 
653
724
  _response_types_map: Dict[str, Optional[str]] = {
654
- "200": "VolumeDto",
725
+ '200': "VolumeDto",
655
726
  }
656
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
727
+ response_data = self.api_client.call_api(
728
+ *_param,
729
+ _request_timeout=_request_timeout
730
+ )
657
731
  response_data.read()
658
732
  return self.api_client.response_deserialize(
659
733
  response_data=response_data,
660
734
  response_types_map=_response_types_map,
661
735
  )
662
736
 
737
+
663
738
  @validate_call
664
739
  def get_volume_without_preload_content(
665
740
  self,
666
741
  volume_id: Annotated[StrictStr, Field(description="ID of the volume")],
667
- x_daytona_organization_id: Annotated[
668
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
669
- ] = None,
742
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
670
743
  _request_timeout: Union[
671
744
  None,
672
745
  Annotated[StrictFloat, Field(gt=0)],
673
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
746
+ Tuple[
747
+ Annotated[StrictFloat, Field(gt=0)],
748
+ Annotated[StrictFloat, Field(gt=0)]
749
+ ]
674
750
  ] = None,
675
751
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
676
752
  _content_type: Optional[StrictStr] = None,
@@ -704,7 +780,7 @@ class VolumesApi:
704
780
  in the spec for a single request.
705
781
  :type _host_index: int, optional
706
782
  :return: Returns the result object.
707
- """ # noqa: E501
783
+ """ # noqa: E501
708
784
 
709
785
  _param = self._get_volume_serialize(
710
786
  volume_id=volume_id,
@@ -712,15 +788,19 @@ class VolumesApi:
712
788
  _request_auth=_request_auth,
713
789
  _content_type=_content_type,
714
790
  _headers=_headers,
715
- _host_index=_host_index,
791
+ _host_index=_host_index
716
792
  )
717
793
 
718
794
  _response_types_map: Dict[str, Optional[str]] = {
719
- "200": "VolumeDto",
795
+ '200': "VolumeDto",
720
796
  }
721
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
797
+ response_data = self.api_client.call_api(
798
+ *_param,
799
+ _request_timeout=_request_timeout
800
+ )
722
801
  return response_data.response
723
802
 
803
+
724
804
  def _get_volume_serialize(
725
805
  self,
726
806
  volume_id,
@@ -730,37 +810,50 @@ class VolumesApi:
730
810
  _headers,
731
811
  _host_index,
732
812
  ) -> RequestSerialized:
813
+
733
814
  _host = None
734
815
 
735
- _collection_formats: Dict[str, str] = {}
816
+ _collection_formats: Dict[str, str] = {
817
+ }
736
818
 
737
819
  _path_params: Dict[str, str] = {}
738
820
  _query_params: List[Tuple[str, str]] = []
739
821
  _header_params: Dict[str, Optional[str]] = _headers or {}
740
822
  _form_params: List[Tuple[str, str]] = []
741
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
823
+ _files: Dict[
824
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
825
+ ] = {}
742
826
  _body_params: Optional[bytes] = None
743
827
 
744
828
  # process the path parameters
745
829
  if volume_id is not None:
746
- _path_params["volumeId"] = volume_id
830
+ _path_params['volumeId'] = volume_id
747
831
  # process the query parameters
748
832
  # process the header parameters
749
833
  if x_daytona_organization_id is not None:
750
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
834
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
751
835
  # process the form parameters
752
836
  # process the body parameter
753
837
 
838
+
754
839
  # set the HTTP header `Accept`
755
- if "Accept" not in _header_params:
756
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
840
+ if 'Accept' not in _header_params:
841
+ _header_params['Accept'] = self.api_client.select_header_accept(
842
+ [
843
+ 'application/json'
844
+ ]
845
+ )
846
+
757
847
 
758
848
  # authentication setting
759
- _auth_settings: List[str] = ["bearer", "oauth2"]
849
+ _auth_settings: List[str] = [
850
+ 'bearer',
851
+ 'oauth2'
852
+ ]
760
853
 
761
854
  return self.api_client.param_serialize(
762
- method="GET",
763
- resource_path="/volumes/{volumeId}",
855
+ method='GET',
856
+ resource_path='/volumes/{volumeId}',
764
857
  path_params=_path_params,
765
858
  query_params=_query_params,
766
859
  header_params=_header_params,
@@ -770,20 +863,24 @@ class VolumesApi:
770
863
  auth_settings=_auth_settings,
771
864
  collection_formats=_collection_formats,
772
865
  _host=_host,
773
- _request_auth=_request_auth,
866
+ _request_auth=_request_auth
774
867
  )
775
868
 
869
+
870
+
871
+
776
872
  @validate_call
777
873
  def get_volume_by_name(
778
874
  self,
779
875
  name: Annotated[StrictStr, Field(description="Name of the volume")],
780
- x_daytona_organization_id: Annotated[
781
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
782
- ] = None,
876
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
783
877
  _request_timeout: Union[
784
878
  None,
785
879
  Annotated[StrictFloat, Field(gt=0)],
786
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
880
+ Tuple[
881
+ Annotated[StrictFloat, Field(gt=0)],
882
+ Annotated[StrictFloat, Field(gt=0)]
883
+ ]
787
884
  ] = None,
788
885
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
789
886
  _content_type: Optional[StrictStr] = None,
@@ -817,7 +914,7 @@ class VolumesApi:
817
914
  in the spec for a single request.
818
915
  :type _host_index: int, optional
819
916
  :return: Returns the result object.
820
- """ # noqa: E501
917
+ """ # noqa: E501
821
918
 
822
919
  _param = self._get_volume_by_name_serialize(
823
920
  name=name,
@@ -825,30 +922,35 @@ class VolumesApi:
825
922
  _request_auth=_request_auth,
826
923
  _content_type=_content_type,
827
924
  _headers=_headers,
828
- _host_index=_host_index,
925
+ _host_index=_host_index
829
926
  )
830
927
 
831
928
  _response_types_map: Dict[str, Optional[str]] = {
832
- "200": "VolumeDto",
929
+ '200': "VolumeDto",
833
930
  }
834
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
931
+ response_data = self.api_client.call_api(
932
+ *_param,
933
+ _request_timeout=_request_timeout
934
+ )
835
935
  response_data.read()
836
936
  return self.api_client.response_deserialize(
837
937
  response_data=response_data,
838
938
  response_types_map=_response_types_map,
839
939
  ).data
840
940
 
941
+
841
942
  @validate_call
842
943
  def get_volume_by_name_with_http_info(
843
944
  self,
844
945
  name: Annotated[StrictStr, Field(description="Name of the volume")],
845
- x_daytona_organization_id: Annotated[
846
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
847
- ] = None,
946
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
848
947
  _request_timeout: Union[
849
948
  None,
850
949
  Annotated[StrictFloat, Field(gt=0)],
851
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
950
+ Tuple[
951
+ Annotated[StrictFloat, Field(gt=0)],
952
+ Annotated[StrictFloat, Field(gt=0)]
953
+ ]
852
954
  ] = None,
853
955
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
854
956
  _content_type: Optional[StrictStr] = None,
@@ -882,7 +984,7 @@ class VolumesApi:
882
984
  in the spec for a single request.
883
985
  :type _host_index: int, optional
884
986
  :return: Returns the result object.
885
- """ # noqa: E501
987
+ """ # noqa: E501
886
988
 
887
989
  _param = self._get_volume_by_name_serialize(
888
990
  name=name,
@@ -890,30 +992,35 @@ class VolumesApi:
890
992
  _request_auth=_request_auth,
891
993
  _content_type=_content_type,
892
994
  _headers=_headers,
893
- _host_index=_host_index,
995
+ _host_index=_host_index
894
996
  )
895
997
 
896
998
  _response_types_map: Dict[str, Optional[str]] = {
897
- "200": "VolumeDto",
999
+ '200': "VolumeDto",
898
1000
  }
899
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1001
+ response_data = self.api_client.call_api(
1002
+ *_param,
1003
+ _request_timeout=_request_timeout
1004
+ )
900
1005
  response_data.read()
901
1006
  return self.api_client.response_deserialize(
902
1007
  response_data=response_data,
903
1008
  response_types_map=_response_types_map,
904
1009
  )
905
1010
 
1011
+
906
1012
  @validate_call
907
1013
  def get_volume_by_name_without_preload_content(
908
1014
  self,
909
1015
  name: Annotated[StrictStr, Field(description="Name of the volume")],
910
- x_daytona_organization_id: Annotated[
911
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
912
- ] = None,
1016
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
913
1017
  _request_timeout: Union[
914
1018
  None,
915
1019
  Annotated[StrictFloat, Field(gt=0)],
916
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1020
+ Tuple[
1021
+ Annotated[StrictFloat, Field(gt=0)],
1022
+ Annotated[StrictFloat, Field(gt=0)]
1023
+ ]
917
1024
  ] = None,
918
1025
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
919
1026
  _content_type: Optional[StrictStr] = None,
@@ -947,7 +1054,7 @@ class VolumesApi:
947
1054
  in the spec for a single request.
948
1055
  :type _host_index: int, optional
949
1056
  :return: Returns the result object.
950
- """ # noqa: E501
1057
+ """ # noqa: E501
951
1058
 
952
1059
  _param = self._get_volume_by_name_serialize(
953
1060
  name=name,
@@ -955,15 +1062,19 @@ class VolumesApi:
955
1062
  _request_auth=_request_auth,
956
1063
  _content_type=_content_type,
957
1064
  _headers=_headers,
958
- _host_index=_host_index,
1065
+ _host_index=_host_index
959
1066
  )
960
1067
 
961
1068
  _response_types_map: Dict[str, Optional[str]] = {
962
- "200": "VolumeDto",
1069
+ '200': "VolumeDto",
963
1070
  }
964
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1071
+ response_data = self.api_client.call_api(
1072
+ *_param,
1073
+ _request_timeout=_request_timeout
1074
+ )
965
1075
  return response_data.response
966
1076
 
1077
+
967
1078
  def _get_volume_by_name_serialize(
968
1079
  self,
969
1080
  name,
@@ -973,37 +1084,50 @@ class VolumesApi:
973
1084
  _headers,
974
1085
  _host_index,
975
1086
  ) -> RequestSerialized:
1087
+
976
1088
  _host = None
977
1089
 
978
- _collection_formats: Dict[str, str] = {}
1090
+ _collection_formats: Dict[str, str] = {
1091
+ }
979
1092
 
980
1093
  _path_params: Dict[str, str] = {}
981
1094
  _query_params: List[Tuple[str, str]] = []
982
1095
  _header_params: Dict[str, Optional[str]] = _headers or {}
983
1096
  _form_params: List[Tuple[str, str]] = []
984
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
1097
+ _files: Dict[
1098
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1099
+ ] = {}
985
1100
  _body_params: Optional[bytes] = None
986
1101
 
987
1102
  # process the path parameters
988
1103
  if name is not None:
989
- _path_params["name"] = name
1104
+ _path_params['name'] = name
990
1105
  # process the query parameters
991
1106
  # process the header parameters
992
1107
  if x_daytona_organization_id is not None:
993
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
1108
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
994
1109
  # process the form parameters
995
1110
  # process the body parameter
996
1111
 
1112
+
997
1113
  # set the HTTP header `Accept`
998
- if "Accept" not in _header_params:
999
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
1114
+ if 'Accept' not in _header_params:
1115
+ _header_params['Accept'] = self.api_client.select_header_accept(
1116
+ [
1117
+ 'application/json'
1118
+ ]
1119
+ )
1120
+
1000
1121
 
1001
1122
  # authentication setting
1002
- _auth_settings: List[str] = ["bearer", "oauth2"]
1123
+ _auth_settings: List[str] = [
1124
+ 'bearer',
1125
+ 'oauth2'
1126
+ ]
1003
1127
 
1004
1128
  return self.api_client.param_serialize(
1005
- method="GET",
1006
- resource_path="/volumes/by-name/{name}",
1129
+ method='GET',
1130
+ resource_path='/volumes/by-name/{name}',
1007
1131
  path_params=_path_params,
1008
1132
  query_params=_query_params,
1009
1133
  header_params=_header_params,
@@ -1013,22 +1137,24 @@ class VolumesApi:
1013
1137
  auth_settings=_auth_settings,
1014
1138
  collection_formats=_collection_formats,
1015
1139
  _host=_host,
1016
- _request_auth=_request_auth,
1140
+ _request_auth=_request_auth
1017
1141
  )
1018
1142
 
1143
+
1144
+
1145
+
1019
1146
  @validate_call
1020
1147
  def list_volumes(
1021
1148
  self,
1022
- x_daytona_organization_id: Annotated[
1023
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1024
- ] = None,
1025
- include_deleted: Annotated[
1026
- Optional[StrictBool], Field(description="Include deleted volumes in the response")
1027
- ] = None,
1149
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1150
+ include_deleted: Annotated[Optional[StrictBool], Field(description="Include deleted volumes in the response")] = None,
1028
1151
  _request_timeout: Union[
1029
1152
  None,
1030
1153
  Annotated[StrictFloat, Field(gt=0)],
1031
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1154
+ Tuple[
1155
+ Annotated[StrictFloat, Field(gt=0)],
1156
+ Annotated[StrictFloat, Field(gt=0)]
1157
+ ]
1032
1158
  ] = None,
1033
1159
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1034
1160
  _content_type: Optional[StrictStr] = None,
@@ -1062,7 +1188,7 @@ class VolumesApi:
1062
1188
  in the spec for a single request.
1063
1189
  :type _host_index: int, optional
1064
1190
  :return: Returns the result object.
1065
- """ # noqa: E501
1191
+ """ # noqa: E501
1066
1192
 
1067
1193
  _param = self._list_volumes_serialize(
1068
1194
  x_daytona_organization_id=x_daytona_organization_id,
@@ -1070,32 +1196,35 @@ class VolumesApi:
1070
1196
  _request_auth=_request_auth,
1071
1197
  _content_type=_content_type,
1072
1198
  _headers=_headers,
1073
- _host_index=_host_index,
1199
+ _host_index=_host_index
1074
1200
  )
1075
1201
 
1076
1202
  _response_types_map: Dict[str, Optional[str]] = {
1077
- "200": "List[VolumeDto]",
1203
+ '200': "List[VolumeDto]",
1078
1204
  }
1079
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1205
+ response_data = self.api_client.call_api(
1206
+ *_param,
1207
+ _request_timeout=_request_timeout
1208
+ )
1080
1209
  response_data.read()
1081
1210
  return self.api_client.response_deserialize(
1082
1211
  response_data=response_data,
1083
1212
  response_types_map=_response_types_map,
1084
1213
  ).data
1085
1214
 
1215
+
1086
1216
  @validate_call
1087
1217
  def list_volumes_with_http_info(
1088
1218
  self,
1089
- x_daytona_organization_id: Annotated[
1090
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1091
- ] = None,
1092
- include_deleted: Annotated[
1093
- Optional[StrictBool], Field(description="Include deleted volumes in the response")
1094
- ] = None,
1219
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1220
+ include_deleted: Annotated[Optional[StrictBool], Field(description="Include deleted volumes in the response")] = None,
1095
1221
  _request_timeout: Union[
1096
1222
  None,
1097
1223
  Annotated[StrictFloat, Field(gt=0)],
1098
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1224
+ Tuple[
1225
+ Annotated[StrictFloat, Field(gt=0)],
1226
+ Annotated[StrictFloat, Field(gt=0)]
1227
+ ]
1099
1228
  ] = None,
1100
1229
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1101
1230
  _content_type: Optional[StrictStr] = None,
@@ -1129,7 +1258,7 @@ class VolumesApi:
1129
1258
  in the spec for a single request.
1130
1259
  :type _host_index: int, optional
1131
1260
  :return: Returns the result object.
1132
- """ # noqa: E501
1261
+ """ # noqa: E501
1133
1262
 
1134
1263
  _param = self._list_volumes_serialize(
1135
1264
  x_daytona_organization_id=x_daytona_organization_id,
@@ -1137,32 +1266,35 @@ class VolumesApi:
1137
1266
  _request_auth=_request_auth,
1138
1267
  _content_type=_content_type,
1139
1268
  _headers=_headers,
1140
- _host_index=_host_index,
1269
+ _host_index=_host_index
1141
1270
  )
1142
1271
 
1143
1272
  _response_types_map: Dict[str, Optional[str]] = {
1144
- "200": "List[VolumeDto]",
1273
+ '200': "List[VolumeDto]",
1145
1274
  }
1146
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1275
+ response_data = self.api_client.call_api(
1276
+ *_param,
1277
+ _request_timeout=_request_timeout
1278
+ )
1147
1279
  response_data.read()
1148
1280
  return self.api_client.response_deserialize(
1149
1281
  response_data=response_data,
1150
1282
  response_types_map=_response_types_map,
1151
1283
  )
1152
1284
 
1285
+
1153
1286
  @validate_call
1154
1287
  def list_volumes_without_preload_content(
1155
1288
  self,
1156
- x_daytona_organization_id: Annotated[
1157
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1158
- ] = None,
1159
- include_deleted: Annotated[
1160
- Optional[StrictBool], Field(description="Include deleted volumes in the response")
1161
- ] = None,
1289
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1290
+ include_deleted: Annotated[Optional[StrictBool], Field(description="Include deleted volumes in the response")] = None,
1162
1291
  _request_timeout: Union[
1163
1292
  None,
1164
1293
  Annotated[StrictFloat, Field(gt=0)],
1165
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1294
+ Tuple[
1295
+ Annotated[StrictFloat, Field(gt=0)],
1296
+ Annotated[StrictFloat, Field(gt=0)]
1297
+ ]
1166
1298
  ] = None,
1167
1299
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1168
1300
  _content_type: Optional[StrictStr] = None,
@@ -1196,7 +1328,7 @@ class VolumesApi:
1196
1328
  in the spec for a single request.
1197
1329
  :type _host_index: int, optional
1198
1330
  :return: Returns the result object.
1199
- """ # noqa: E501
1331
+ """ # noqa: E501
1200
1332
 
1201
1333
  _param = self._list_volumes_serialize(
1202
1334
  x_daytona_organization_id=x_daytona_organization_id,
@@ -1204,15 +1336,19 @@ class VolumesApi:
1204
1336
  _request_auth=_request_auth,
1205
1337
  _content_type=_content_type,
1206
1338
  _headers=_headers,
1207
- _host_index=_host_index,
1339
+ _host_index=_host_index
1208
1340
  )
1209
1341
 
1210
1342
  _response_types_map: Dict[str, Optional[str]] = {
1211
- "200": "List[VolumeDto]",
1343
+ '200': "List[VolumeDto]",
1212
1344
  }
1213
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1345
+ response_data = self.api_client.call_api(
1346
+ *_param,
1347
+ _request_timeout=_request_timeout
1348
+ )
1214
1349
  return response_data.response
1215
1350
 
1351
+
1216
1352
  def _list_volumes_serialize(
1217
1353
  self,
1218
1354
  x_daytona_organization_id,
@@ -1222,38 +1358,52 @@ class VolumesApi:
1222
1358
  _headers,
1223
1359
  _host_index,
1224
1360
  ) -> RequestSerialized:
1361
+
1225
1362
  _host = None
1226
1363
 
1227
- _collection_formats: Dict[str, str] = {}
1364
+ _collection_formats: Dict[str, str] = {
1365
+ }
1228
1366
 
1229
1367
  _path_params: Dict[str, str] = {}
1230
1368
  _query_params: List[Tuple[str, str]] = []
1231
1369
  _header_params: Dict[str, Optional[str]] = _headers or {}
1232
1370
  _form_params: List[Tuple[str, str]] = []
1233
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
1371
+ _files: Dict[
1372
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1373
+ ] = {}
1234
1374
  _body_params: Optional[bytes] = None
1235
1375
 
1236
1376
  # process the path parameters
1237
1377
  # process the query parameters
1238
1378
  if include_deleted is not None:
1239
- _query_params.append(("includeDeleted", include_deleted))
1240
-
1379
+
1380
+ _query_params.append(('includeDeleted', include_deleted))
1381
+
1241
1382
  # process the header parameters
1242
1383
  if x_daytona_organization_id is not None:
1243
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
1384
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
1244
1385
  # process the form parameters
1245
1386
  # process the body parameter
1246
1387
 
1388
+
1247
1389
  # set the HTTP header `Accept`
1248
- if "Accept" not in _header_params:
1249
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
1390
+ if 'Accept' not in _header_params:
1391
+ _header_params['Accept'] = self.api_client.select_header_accept(
1392
+ [
1393
+ 'application/json'
1394
+ ]
1395
+ )
1396
+
1250
1397
 
1251
1398
  # authentication setting
1252
- _auth_settings: List[str] = ["bearer", "oauth2"]
1399
+ _auth_settings: List[str] = [
1400
+ 'bearer',
1401
+ 'oauth2'
1402
+ ]
1253
1403
 
1254
1404
  return self.api_client.param_serialize(
1255
- method="GET",
1256
- resource_path="/volumes",
1405
+ method='GET',
1406
+ resource_path='/volumes',
1257
1407
  path_params=_path_params,
1258
1408
  query_params=_query_params,
1259
1409
  header_params=_header_params,
@@ -1263,5 +1413,7 @@ class VolumesApi:
1263
1413
  auth_settings=_auth_settings,
1264
1414
  collection_formats=_collection_formats,
1265
1415
  _host=_host,
1266
- _request_auth=_request_auth,
1416
+ _request_auth=_request_auth
1267
1417
  )
1418
+
1419
+