language
stringclasses 6
values | original_string
stringlengths 25
887k
| text
stringlengths 25
887k
|
|---|---|---|
Python | def unclaim_storage_volume(self, cluster_name, name, unclaim_payload, **kwargs): # noqa: E501
"""Unclaim a StorageVolume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.unclaim_storage_volume(cluster_name, name, unclaim_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:param UnclaimPayload unclaim_payload: (required)
:param str x_include_object: When passed as part of a POST request, controls whether the representation of the newly created object is included in the response. Defaults to 'true' which will include the object in the response. This header is useful because refreshing the newly created object is usually the slowest part of a POST operation.
:return: StorageVolume
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.unclaim_storage_volume_with_http_info(cluster_name, name, unclaim_payload, **kwargs) # noqa: E501
else:
(data) = self.unclaim_storage_volume_with_http_info(cluster_name, name, unclaim_payload, **kwargs) # noqa: E501
return data | def unclaim_storage_volume(self, cluster_name, name, unclaim_payload, **kwargs): # noqa: E501
"""Unclaim a StorageVolume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.unclaim_storage_volume(cluster_name, name, unclaim_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:param UnclaimPayload unclaim_payload: (required)
:param str x_include_object: When passed as part of a POST request, controls whether the representation of the newly created object is included in the response. Defaults to 'true' which will include the object in the response. This header is useful because refreshing the newly created object is usually the slowest part of a POST operation.
:return: StorageVolume
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.unclaim_storage_volume_with_http_info(cluster_name, name, unclaim_payload, **kwargs) # noqa: E501
else:
(data) = self.unclaim_storage_volume_with_http_info(cluster_name, name, unclaim_payload, **kwargs) # noqa: E501
return data |
Python | def unclaim_storage_volume_with_http_info(self, cluster_name, name, unclaim_payload, **kwargs): # noqa: E501
"""Unclaim a StorageVolume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.unclaim_storage_volume_with_http_info(cluster_name, name, unclaim_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:param UnclaimPayload unclaim_payload: (required)
:param str x_include_object: When passed as part of a POST request, controls whether the representation of the newly created object is included in the response. Defaults to 'true' which will include the object in the response. This header is useful because refreshing the newly created object is usually the slowest part of a POST operation.
:return: StorageVolume
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'name', 'unclaim_payload', 'x_include_object'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method unclaim_storage_volume" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `unclaim_storage_volume`") # noqa: E501
# verify the required parameter 'name' is set
if ('name' not in params or
params['name'] is None):
raise ValueError("Missing the required parameter `name` when calling `unclaim_storage_volume`") # noqa: E501
# verify the required parameter 'unclaim_payload' is set
if ('unclaim_payload' not in params or
params['unclaim_payload'] is None):
raise ValueError("Missing the required parameter `unclaim_payload` when calling `unclaim_storage_volume`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
if 'name' in params:
path_params['name'] = params['name'] # noqa: E501
query_params = []
header_params = {}
if 'x_include_object' in params:
header_params['X-Include-Object'] = params['x_include_object'] # noqa: E501
form_params = []
local_var_files = {}
body_params = None
if 'unclaim_payload' in params:
body_params = params['unclaim_payload']
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/storage_volumes/{name}/unclaim', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='StorageVolume', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) | def unclaim_storage_volume_with_http_info(self, cluster_name, name, unclaim_payload, **kwargs): # noqa: E501
"""Unclaim a StorageVolume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.unclaim_storage_volume_with_http_info(cluster_name, name, unclaim_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:param UnclaimPayload unclaim_payload: (required)
:param str x_include_object: When passed as part of a POST request, controls whether the representation of the newly created object is included in the response. Defaults to 'true' which will include the object in the response. This header is useful because refreshing the newly created object is usually the slowest part of a POST operation.
:return: StorageVolume
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'name', 'unclaim_payload', 'x_include_object'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method unclaim_storage_volume" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `unclaim_storage_volume`") # noqa: E501
# verify the required parameter 'name' is set
if ('name' not in params or
params['name'] is None):
raise ValueError("Missing the required parameter `name` when calling `unclaim_storage_volume`") # noqa: E501
# verify the required parameter 'unclaim_payload' is set
if ('unclaim_payload' not in params or
params['unclaim_payload'] is None):
raise ValueError("Missing the required parameter `unclaim_payload` when calling `unclaim_storage_volume`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
if 'name' in params:
path_params['name'] = params['name'] # noqa: E501
query_params = []
header_params = {}
if 'x_include_object' in params:
header_params['X-Include-Object'] = params['x_include_object'] # noqa: E501
form_params = []
local_var_files = {}
body_params = None
if 'unclaim_payload' in params:
body_params = params['unclaim_payload']
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/storage_volumes/{name}/unclaim', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='StorageVolume', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) |
Python | def block_count(self):
"""Gets the block_count of this Device. # noqa: E501
:return: The block_count of this Device. # noqa: E501
:rtype: float
"""
return self._block_count | def block_count(self):
"""Gets the block_count of this Device. # noqa: E501
:return: The block_count of this Device. # noqa: E501
:rtype: float
"""
return self._block_count |
Python | def transfer_size(self):
"""Gets the transfer_size of this Device. # noqa: E501
:return: The transfer_size of this Device. # noqa: E501
:rtype: float
"""
return self._transfer_size | def transfer_size(self):
"""Gets the transfer_size of this Device. # noqa: E501
:return: The transfer_size of this Device. # noqa: E501
:rtype: float
"""
return self._transfer_size |
Python | def health_indications(self):
"""Gets the health_indications of this Device. # noqa: E501
:return: The health_indications of this Device. # noqa: E501
:rtype: list[str]
"""
return self._health_indications | def health_indications(self):
"""Gets the health_indications of this Device. # noqa: E501
:return: The health_indications of this Device. # noqa: E501
:rtype: list[str]
"""
return self._health_indications |
Python | def health_indications(self, health_indications):
"""Sets the health_indications of this Device.
:param health_indications: The health_indications of this Device. # noqa: E501
:type: list[str]
"""
self._health_indications = health_indications | def health_indications(self, health_indications):
"""Sets the health_indications of this Device.
:param health_indications: The health_indications of this Device. # noqa: E501
:type: list[str]
"""
self._health_indications = health_indications |
Python | def health_state(self):
"""Gets the health_state of this Device. # noqa: E501
:return: The health_state of this Device. # noqa: E501
:rtype: str
"""
return self._health_state | def health_state(self):
"""Gets the health_state of this Device. # noqa: E501
:return: The health_state of this Device. # noqa: E501
:rtype: str
"""
return self._health_state |
Python | def operational_status(self):
"""Gets the operational_status of this Device. # noqa: E501
:return: The operational_status of this Device. # noqa: E501
:rtype: str
"""
return self._operational_status | def operational_status(self):
"""Gets the operational_status of this Device. # noqa: E501
:return: The operational_status of this Device. # noqa: E501
:rtype: str
"""
return self._operational_status |
Python | def operational_status(self, operational_status):
"""Sets the operational_status of this Device.
:param operational_status: The operational_status of this Device. # noqa: E501
:type: str
"""
self._operational_status = operational_status | def operational_status(self, operational_status):
"""Sets the operational_status of this Device.
:param operational_status: The operational_status of this Device. # noqa: E501
:type: str
"""
self._operational_status = operational_status |
Python | def virtual_volume(self):
"""Gets the virtual_volume of this Device. # noqa: E501
:return: The virtual_volume of this Device. # noqa: E501
:rtype: str
"""
return self._virtual_volume | def virtual_volume(self):
"""Gets the virtual_volume of this Device. # noqa: E501
:return: The virtual_volume of this Device. # noqa: E501
:rtype: str
"""
return self._virtual_volume |
Python | def virtual_volume(self, virtual_volume):
"""Sets the virtual_volume of this Device.
:param virtual_volume: The virtual_volume of this Device. # noqa: E501
:type: str
"""
self._virtual_volume = virtual_volume | def virtual_volume(self, virtual_volume):
"""Sets the virtual_volume of this Device.
:param virtual_volume: The virtual_volume of this Device. # noqa: E501
:type: str
"""
self._virtual_volume = virtual_volume |
Python | def application_consistent(self):
"""Gets the application_consistent of this Device. # noqa: E501
:return: The application_consistent of this Device. # noqa: E501
:rtype: bool
"""
return self._application_consistent | def application_consistent(self):
"""Gets the application_consistent of this Device. # noqa: E501
:return: The application_consistent of this Device. # noqa: E501
:rtype: bool
"""
return self._application_consistent |
Python | def application_consistent(self, application_consistent):
"""Sets the application_consistent of this Device.
:param application_consistent: The application_consistent of this Device. # noqa: E501
:type: bool
"""
self._application_consistent = application_consistent | def application_consistent(self, application_consistent):
"""Sets the application_consistent of this Device.
:param application_consistent: The application_consistent of this Device. # noqa: E501
:type: bool
"""
self._application_consistent = application_consistent |
Python | def auto_resume(self):
"""Gets the auto_resume of this Device. # noqa: E501
:return: The auto_resume of this Device. # noqa: E501
:rtype: bool
"""
return self._auto_resume | def auto_resume(self):
"""Gets the auto_resume of this Device. # noqa: E501
:return: The auto_resume of this Device. # noqa: E501
:rtype: bool
"""
return self._auto_resume |
Python | def rebuild_eta(self):
"""Gets the rebuild_eta of this Device. # noqa: E501
:return: The rebuild_eta of this Device. # noqa: E501
:rtype: str
"""
return self._rebuild_eta | def rebuild_eta(self):
"""Gets the rebuild_eta of this Device. # noqa: E501
:return: The rebuild_eta of this Device. # noqa: E501
:rtype: str
"""
return self._rebuild_eta |
Python | def rebuild_allowed(self):
"""Gets the rebuild_allowed of this Device. # noqa: E501
:return: The rebuild_allowed of this Device. # noqa: E501
:rtype: bool
"""
return self._rebuild_allowed | def rebuild_allowed(self):
"""Gets the rebuild_allowed of this Device. # noqa: E501
:return: The rebuild_allowed of this Device. # noqa: E501
:rtype: bool
"""
return self._rebuild_allowed |
Python | def rebuild_progress(self):
"""Gets the rebuild_progress of this Device. # noqa: E501
:return: The rebuild_progress of this Device. # noqa: E501
:rtype: str
"""
return self._rebuild_progress | def rebuild_progress(self):
"""Gets the rebuild_progress of this Device. # noqa: E501
:return: The rebuild_progress of this Device. # noqa: E501
:rtype: str
"""
return self._rebuild_progress |
Python | def rebuild_progress(self, rebuild_progress):
"""Sets the rebuild_progress of this Device.
:param rebuild_progress: The rebuild_progress of this Device. # noqa: E501
:type: str
"""
self._rebuild_progress = rebuild_progress | def rebuild_progress(self, rebuild_progress):
"""Sets the rebuild_progress of this Device.
:param rebuild_progress: The rebuild_progress of this Device. # noqa: E501
:type: str
"""
self._rebuild_progress = rebuild_progress |
Python | def rebuild_status(self):
"""Gets the rebuild_status of this Device. # noqa: E501
:return: The rebuild_status of this Device. # noqa: E501
:rtype: str
"""
return self._rebuild_status | def rebuild_status(self):
"""Gets the rebuild_status of this Device. # noqa: E501
:return: The rebuild_status of this Device. # noqa: E501
:rtype: str
"""
return self._rebuild_status |
Python | def rebuild_status(self, rebuild_status):
"""Sets the rebuild_status of this Device.
:param rebuild_status: The rebuild_status of this Device. # noqa: E501
:type: str
"""
self._rebuild_status = rebuild_status | def rebuild_status(self, rebuild_status):
"""Sets the rebuild_status of this Device.
:param rebuild_status: The rebuild_status of this Device. # noqa: E501
:type: str
"""
self._rebuild_status = rebuild_status |
Python | def rebuild_type(self):
"""Gets the rebuild_type of this Device. # noqa: E501
:return: The rebuild_type of this Device. # noqa: E501
:rtype: str
"""
return self._rebuild_type | def rebuild_type(self):
"""Gets the rebuild_type of this Device. # noqa: E501
:return: The rebuild_type of this Device. # noqa: E501
:rtype: str
"""
return self._rebuild_type |
Python | def service_status(self):
"""Gets the service_status of this Device. # noqa: E501
:return: The service_status of this Device. # noqa: E501
:rtype: str
"""
return self._service_status | def service_status(self):
"""Gets the service_status of this Device. # noqa: E501
:return: The service_status of this Device. # noqa: E501
:rtype: str
"""
return self._service_status |
Python | def service_status(self, service_status):
"""Sets the service_status of this Device.
:param service_status: The service_status of this Device. # noqa: E501
:type: str
"""
self._service_status = service_status | def service_status(self, service_status):
"""Sets the service_status of this Device.
:param service_status: The service_status of this Device. # noqa: E501
:type: str
"""
self._service_status = service_status |
Python | def storage_array_family(self):
"""Gets the storage_array_family of this Device. # noqa: E501
:return: The storage_array_family of this Device. # noqa: E501
:rtype: str
"""
return self._storage_array_family | def storage_array_family(self):
"""Gets the storage_array_family of this Device. # noqa: E501
:return: The storage_array_family of this Device. # noqa: E501
:rtype: str
"""
return self._storage_array_family |
Python | def stripe_depth(self):
"""Gets the stripe_depth of this Device. # noqa: E501
:return: The stripe_depth of this Device. # noqa: E501
:rtype: str
"""
return self._stripe_depth | def stripe_depth(self):
"""Gets the stripe_depth of this Device. # noqa: E501
:return: The stripe_depth of this Device. # noqa: E501
:rtype: str
"""
return self._stripe_depth |
Python | def thin_capable(self):
"""Gets the thin_capable of this Device. # noqa: E501
:return: The thin_capable of this Device. # noqa: E501
:rtype: bool
"""
return self._thin_capable | def thin_capable(self):
"""Gets the thin_capable of this Device. # noqa: E501
:return: The thin_capable of this Device. # noqa: E501
:rtype: bool
"""
return self._thin_capable |
Python | def top_level(self):
"""Gets the top_level of this Device. # noqa: E501
:return: The top_level of this Device. # noqa: E501
:rtype: bool
"""
return self._top_level | def top_level(self):
"""Gets the top_level of this Device. # noqa: E501
:return: The top_level of this Device. # noqa: E501
:rtype: bool
"""
return self._top_level |
Python | def op(self, op):
"""Sets the op of this JsonPatchOp.
The body of an HTTP PATCH is a Json array of JsonPatchOp objects. These patch operations are applied sequentially to the resource to which the PATCH was sent. If any operation results in a failure, execution of any subsequent operations is aborted, but no roll-back is performed. The field the operation acts on is specified by 'path'. Operations are applied in a consistent order, by type: 1. test - Assert that the value of a scalar-valued field is equal to 'value' at the start of the patch operation. 2. add - Insert 'value' into a collection-valued field. 3. remove - Remove 'value' from a collection-valued field. 4. replace - Set a scalar-valued field to 'value'. Operations of the same type are applied in the order they appear in the patch body. # noqa: E501
:param op: The op of this JsonPatchOp. # noqa: E501
:type: str
"""
if op is None:
raise ValueError("Invalid value for `op`, must not be `None`") # noqa: E501
allowed_values = ["add", "remove", "replace", "test"] # noqa: E501
if op not in allowed_values:
raise ValueError(
"Invalid value for `op` ({0}), must be one of {1}" # noqa: E501
.format(op, allowed_values)
)
self._op = op | def op(self, op):
"""Sets the op of this JsonPatchOp.
The body of an HTTP PATCH is a Json array of JsonPatchOp objects. These patch operations are applied sequentially to the resource to which the PATCH was sent. If any operation results in a failure, execution of any subsequent operations is aborted, but no roll-back is performed. The field the operation acts on is specified by 'path'. Operations are applied in a consistent order, by type: 1. test - Assert that the value of a scalar-valued field is equal to 'value' at the start of the patch operation. 2. add - Insert 'value' into a collection-valued field. 3. remove - Remove 'value' from a collection-valued field. 4. replace - Set a scalar-valued field to 'value'. Operations of the same type are applied in the order they appear in the patch body. # noqa: E501
:param op: The op of this JsonPatchOp. # noqa: E501
:type: str
"""
if op is None:
raise ValueError("Invalid value for `op`, must not be `None`") # noqa: E501
allowed_values = ["add", "remove", "replace", "test"] # noqa: E501
if op not in allowed_values:
raise ValueError(
"Invalid value for `op` ({0}), must be one of {1}" # noqa: E501
.format(op, allowed_values)
)
self._op = op |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(JsonPatchOp, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(JsonPatchOp, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(BulkResponse, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(BulkResponse, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(LoggingVolume, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(LoggingVolume, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(LicensePayload, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(LicensePayload, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(DistributedDevice, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(DistributedDevice, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def luns(self):
"""Gets the luns of this LogicalUnit. # noqa: E501
:return: The luns of this LogicalUnit. # noqa: E501
:rtype: list[str]
"""
return self._luns | def luns(self):
"""Gets the luns of this LogicalUnit. # noqa: E501
:return: The luns of this LogicalUnit. # noqa: E501
:rtype: list[str]
"""
return self._luns |
Python | def luns(self, luns):
"""Sets the luns of this LogicalUnit.
:param luns: The luns of this LogicalUnit. # noqa: E501
:type: list[str]
"""
self._luns = luns | def luns(self, luns):
"""Sets the luns of this LogicalUnit.
:param luns: The luns of this LogicalUnit. # noqa: E501
:type: list[str]
"""
self._luns = luns |
Python | def visibility(self, visibility):
"""Sets the visibility of this LogicalUnit.
:param visibility: The visibility of this LogicalUnit. # noqa: E501
:type: str
"""
allowed_values = ["active", "passsive", "active-optimized", "active-non-optimized", "both", "both-alua", "none"] # noqa: E501
if visibility not in allowed_values:
raise ValueError(
"Invalid value for `visibility` ({0}), must be one of {1}" # noqa: E501
.format(visibility, allowed_values)
)
self._visibility = visibility | def visibility(self, visibility):
"""Sets the visibility of this LogicalUnit.
:param visibility: The visibility of this LogicalUnit. # noqa: E501
:type: str
"""
allowed_values = ["active", "passsive", "active-optimized", "active-non-optimized", "both", "both-alua", "none"] # noqa: E501
if visibility not in allowed_values:
raise ValueError(
"Invalid value for `visibility` ({0}), must be one of {1}" # noqa: E501
.format(visibility, allowed_values)
)
self._visibility = visibility |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(LogicalUnit, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(LogicalUnit, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(ValidatePayload, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(ValidatePayload, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(JobsStoragePools, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(JobsStoragePools, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def delete_cluster_witness(self, **kwargs): # noqa: E501
"""Deletes the cluster witness configuration. # noqa: E501
Cluster witness can't be deleted if its currently enabled. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_cluster_witness(async_req=True)
>>> result = thread.get()
:param async_req bool
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.delete_cluster_witness_with_http_info(**kwargs) # noqa: E501
else:
(data) = self.delete_cluster_witness_with_http_info(**kwargs) # noqa: E501
return data | def delete_cluster_witness(self, **kwargs): # noqa: E501
"""Deletes the cluster witness configuration. # noqa: E501
Cluster witness can't be deleted if its currently enabled. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_cluster_witness(async_req=True)
>>> result = thread.get()
:param async_req bool
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.delete_cluster_witness_with_http_info(**kwargs) # noqa: E501
else:
(data) = self.delete_cluster_witness_with_http_info(**kwargs) # noqa: E501
return data |
Python | def delete_cluster_witness_with_http_info(self, **kwargs): # noqa: E501
"""Deletes the cluster witness configuration. # noqa: E501
Cluster witness can't be deleted if its currently enabled. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_cluster_witness_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = [] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method delete_cluster_witness" % key
)
params[key] = val
del params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/cluster_witness', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) | def delete_cluster_witness_with_http_info(self, **kwargs): # noqa: E501
"""Deletes the cluster witness configuration. # noqa: E501
Cluster witness can't be deleted if its currently enabled. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_cluster_witness_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = [] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method delete_cluster_witness" % key
)
params[key] = val
del params['kwargs']
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/cluster_witness', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) |
Python | def patch_cluster_witness(self, clusterwitness_patch_payload, **kwargs): # noqa: E501
"""Update attributes of a cluster witness. # noqa: E501
Settable attributes are 'admin state' # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.patch_cluster_witness(clusterwitness_patch_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param list[JsonPatchOp] clusterwitness_patch_payload: (required)
:return: ClusterWitness
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.patch_cluster_witness_with_http_info(clusterwitness_patch_payload, **kwargs) # noqa: E501
else:
(data) = self.patch_cluster_witness_with_http_info(clusterwitness_patch_payload, **kwargs) # noqa: E501
return data | def patch_cluster_witness(self, clusterwitness_patch_payload, **kwargs): # noqa: E501
"""Update attributes of a cluster witness. # noqa: E501
Settable attributes are 'admin state' # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.patch_cluster_witness(clusterwitness_patch_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param list[JsonPatchOp] clusterwitness_patch_payload: (required)
:return: ClusterWitness
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.patch_cluster_witness_with_http_info(clusterwitness_patch_payload, **kwargs) # noqa: E501
else:
(data) = self.patch_cluster_witness_with_http_info(clusterwitness_patch_payload, **kwargs) # noqa: E501
return data |
Python | def patch_cluster_witness_with_http_info(self, clusterwitness_patch_payload, **kwargs): # noqa: E501
"""Update attributes of a cluster witness. # noqa: E501
Settable attributes are 'admin state' # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.patch_cluster_witness_with_http_info(clusterwitness_patch_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param list[JsonPatchOp] clusterwitness_patch_payload: (required)
:return: ClusterWitness
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['clusterwitness_patch_payload'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method patch_cluster_witness" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'clusterwitness_patch_payload' is set
if ('clusterwitness_patch_payload' not in params or
params['clusterwitness_patch_payload'] is None):
raise ValueError("Missing the required parameter `clusterwitness_patch_payload` when calling `patch_cluster_witness`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'clusterwitness_patch_payload' in params:
body_params = params['clusterwitness_patch_payload']
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/cluster_witness', 'PATCH',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='ClusterWitness', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) | def patch_cluster_witness_with_http_info(self, clusterwitness_patch_payload, **kwargs): # noqa: E501
"""Update attributes of a cluster witness. # noqa: E501
Settable attributes are 'admin state' # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.patch_cluster_witness_with_http_info(clusterwitness_patch_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param list[JsonPatchOp] clusterwitness_patch_payload: (required)
:return: ClusterWitness
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['clusterwitness_patch_payload'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method patch_cluster_witness" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'clusterwitness_patch_payload' is set
if ('clusterwitness_patch_payload' not in params or
params['clusterwitness_patch_payload'] is None):
raise ValueError("Missing the required parameter `clusterwitness_patch_payload` when calling `patch_cluster_witness`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'clusterwitness_patch_payload' in params:
body_params = params['clusterwitness_patch_payload']
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/cluster_witness', 'PATCH',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='ClusterWitness', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(DeviceMigrationPayload, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(DeviceMigrationPayload, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def log(self, request, **kwargs): # noqa: E501
"""Log information on the server. This endpoint is intended for internal system use only. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.log(request, async_req=True)
>>> result = thread.get()
:param async_req bool
:param object request: (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.log_with_http_info(request, **kwargs) # noqa: E501
else:
(data) = self.log_with_http_info(request, **kwargs) # noqa: E501
return data | def log(self, request, **kwargs): # noqa: E501
"""Log information on the server. This endpoint is intended for internal system use only. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.log(request, async_req=True)
>>> result = thread.get()
:param async_req bool
:param object request: (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.log_with_http_info(request, **kwargs) # noqa: E501
else:
(data) = self.log_with_http_info(request, **kwargs) # noqa: E501
return data |
Python | def log_with_http_info(self, request, **kwargs): # noqa: E501
"""Log information on the server. This endpoint is intended for internal system use only. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.log_with_http_info(request, async_req=True)
>>> result = thread.get()
:param async_req bool
:param object request: (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['request'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method log" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'request' is set
if ('request' not in params or
params['request'] is None):
raise ValueError("Missing the required parameter `request` when calling `log`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'request' in params:
body_params = params['request']
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/logger/', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) | def log_with_http_info(self, request, **kwargs): # noqa: E501
"""Log information on the server. This endpoint is intended for internal system use only. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.log_with_http_info(request, async_req=True)
>>> result = thread.get()
:param async_req bool
:param object request: (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['request'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method log" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'request' is set
if ('request' not in params or
params['request'] is None):
raise ValueError("Missing the required parameter `request` when calling `log`") # noqa: E501
collection_formats = {}
path_params = {}
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'request' in params:
body_params = params['request']
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/logger/', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(InlineResponse2011, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(InlineResponse2011, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def thin(self):
"""Gets the thin of this VirtualVolumePayload. # noqa: E501
:return: The thin of this VirtualVolumePayload. # noqa: E501
:rtype: bool
"""
return self._thin | def thin(self):
"""Gets the thin of this VirtualVolumePayload. # noqa: E501
:return: The thin of this VirtualVolumePayload. # noqa: E501
:rtype: bool
"""
return self._thin |
Python | def thin(self, thin):
"""Sets the thin of this VirtualVolumePayload.
:param thin: The thin of this VirtualVolumePayload. # noqa: E501
:type: bool
"""
self._thin = thin | def thin(self, thin):
"""Sets the thin of this VirtualVolumePayload.
:param thin: The thin of this VirtualVolumePayload. # noqa: E501
:type: bool
"""
self._thin = thin |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(VirtualVolumePayload, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(VirtualVolumePayload, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def feature_name(self):
"""Gets the feature_name of this License. # noqa: E501
:return: The feature_name of this License. # noqa: E501
:rtype: str
"""
return self._feature_name | def feature_name(self):
"""Gets the feature_name of this License. # noqa: E501
:return: The feature_name of this License. # noqa: E501
:rtype: str
"""
return self._feature_name |
Python | def feature_name(self, feature_name):
"""Sets the feature_name of this License.
:param feature_name: The feature_name of this License. # noqa: E501
:type: str
"""
if feature_name is None:
raise ValueError("Invalid value for `feature_name`, must not be `None`") # noqa: E501
self._feature_name = feature_name | def feature_name(self, feature_name):
"""Sets the feature_name of this License.
:param feature_name: The feature_name of this License. # noqa: E501
:type: str
"""
if feature_name is None:
raise ValueError("Invalid value for `feature_name`, must not be `None`") # noqa: E501
self._feature_name = feature_name |
Python | def issued_date(self):
"""Gets the issued_date of this License. # noqa: E501
:return: The issued_date of this License. # noqa: E501
:rtype: datetime
"""
return self._issued_date | def issued_date(self):
"""Gets the issued_date of this License. # noqa: E501
:return: The issued_date of this License. # noqa: E501
:rtype: datetime
"""
return self._issued_date |
Python | def notice(self):
"""Gets the notice of this License. # noqa: E501
:return: The notice of this License. # noqa: E501
:rtype: str
"""
return self._notice | def notice(self):
"""Gets the notice of this License. # noqa: E501
:return: The notice of this License. # noqa: E501
:rtype: str
"""
return self._notice |
Python | def notice(self, notice):
"""Sets the notice of this License.
:param notice: The notice of this License. # noqa: E501
:type: str
"""
self._notice = notice | def notice(self, notice):
"""Sets the notice of this License.
:param notice: The notice of this License. # noqa: E501
:type: str
"""
self._notice = notice |
Python | def uom_code(self):
"""Gets the uom_code of this License. # noqa: E501
:return: The uom_code of this License. # noqa: E501
:rtype: str
"""
return self._uom_code | def uom_code(self):
"""Gets the uom_code of this License. # noqa: E501
:return: The uom_code of this License. # noqa: E501
:rtype: str
"""
return self._uom_code |
Python | def uom_name(self):
"""Gets the uom_name of this License. # noqa: E501
:return: The uom_name of this License. # noqa: E501
:rtype: str
"""
return self._uom_name | def uom_name(self):
"""Gets the uom_name of this License. # noqa: E501
:return: The uom_name of this License. # noqa: E501
:rtype: str
"""
return self._uom_name |
Python | def plc(self):
"""Gets the plc of this License. # noqa: E501
:return: The plc of this License. # noqa: E501
:rtype: str
"""
return self._plc | def plc(self):
"""Gets the plc of this License. # noqa: E501
:return: The plc of this License. # noqa: E501
:rtype: str
"""
return self._plc |
Python | def plc(self, plc):
"""Sets the plc of this License.
:param plc: The plc of this License. # noqa: E501
:type: str
"""
self._plc = plc | def plc(self, plc):
"""Sets the plc of this License.
:param plc: The plc of this License. # noqa: E501
:type: str
"""
self._plc = plc |
Python | def product_line(self):
"""Gets the product_line of this License. # noqa: E501
:return: The product_line of this License. # noqa: E501
:rtype: str
"""
return self._product_line | def product_line(self):
"""Gets the product_line of this License. # noqa: E501
:return: The product_line of this License. # noqa: E501
:rtype: str
"""
return self._product_line |
Python | def product_line(self, product_line):
"""Sets the product_line of this License.
:param product_line: The product_line of this License. # noqa: E501
:type: str
"""
self._product_line = product_line | def product_line(self, product_line):
"""Sets the product_line of this License.
:param product_line: The product_line of this License. # noqa: E501
:type: str
"""
self._product_line = product_line |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(LoggingVolumePayload, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(LoggingVolumePayload, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def forget_logical_units(self, cluster_name, storagearray_name, **kwargs): # noqa: E501
"""Forgets logicalUnits in an array # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.forget_logical_units(cluster_name, storagearray_name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str storagearray_name: The name of the storage array (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.forget_logical_units_with_http_info(cluster_name, storagearray_name, **kwargs) # noqa: E501
else:
(data) = self.forget_logical_units_with_http_info(cluster_name, storagearray_name, **kwargs) # noqa: E501
return data | def forget_logical_units(self, cluster_name, storagearray_name, **kwargs): # noqa: E501
"""Forgets logicalUnits in an array # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.forget_logical_units(cluster_name, storagearray_name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str storagearray_name: The name of the storage array (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.forget_logical_units_with_http_info(cluster_name, storagearray_name, **kwargs) # noqa: E501
else:
(data) = self.forget_logical_units_with_http_info(cluster_name, storagearray_name, **kwargs) # noqa: E501
return data |
Python | def forget_logical_units_with_http_info(self, cluster_name, storagearray_name, **kwargs): # noqa: E501
"""Forgets logicalUnits in an array # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.forget_logical_units_with_http_info(cluster_name, storagearray_name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str storagearray_name: The name of the storage array (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'storagearray_name'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method forget_logical_units" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `forget_logical_units`") # noqa: E501
# verify the required parameter 'storagearray_name' is set
if ('storagearray_name' not in params or
params['storagearray_name'] is None):
raise ValueError("Missing the required parameter `storagearray_name` when calling `forget_logical_units`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
if 'storagearray_name' in params:
path_params['storagearray_name'] = params['storagearray_name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/storage_arrays/{storagearray_name}/logical_units', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) | def forget_logical_units_with_http_info(self, cluster_name, storagearray_name, **kwargs): # noqa: E501
"""Forgets logicalUnits in an array # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.forget_logical_units_with_http_info(cluster_name, storagearray_name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str storagearray_name: The name of the storage array (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'storagearray_name'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method forget_logical_units" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `forget_logical_units`") # noqa: E501
# verify the required parameter 'storagearray_name' is set
if ('storagearray_name' not in params or
params['storagearray_name'] is None):
raise ValueError("Missing the required parameter `storagearray_name` when calling `forget_logical_units`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
if 'storagearray_name' in params:
path_params['storagearray_name'] = params['storagearray_name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/storage_arrays/{storagearray_name}/logical_units', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(ConnectivityStatus, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(ConnectivityStatus, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(VirtualVolume, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(VirtualVolume, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def array(self, array):
"""Sets the array of this ViasJobStoragePools.
:param array: The array of this ViasJobStoragePools. # noqa: E501
:type: str
"""
self._array = array | def array(self, array):
"""Sets the array of this ViasJobStoragePools.
:param array: The array of this ViasJobStoragePools. # noqa: E501
:type: str
"""
self._array = array |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(ViasJobStoragePools, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(ViasJobStoragePools, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def itls(self):
"""Gets the itls of this StorageVolume. # noqa: E501
:return: The itls of this StorageVolume. # noqa: E501
:rtype: list[StorageVolumeItls]
"""
return self._itls | def itls(self):
"""Gets the itls of this StorageVolume. # noqa: E501
:return: The itls of this StorageVolume. # noqa: E501
:rtype: list[StorageVolumeItls]
"""
return self._itls |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(StorageVolume, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(StorageVolume, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(BulkResponseTasks, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(BulkResponseTasks, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(ExtentMigration, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(ExtentMigration, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(ClusterWitness, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(ClusterWitness, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(Aggregate, dict):
for key, value in self.items():
result[key] = value
return result | def to_dict(self):
"""Returns the model properties as a dict"""
result = {}
for attr, _ in six.iteritems(self.swagger_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
if issubclass(Aggregate, dict):
for key, value in self.items():
result[key] = value
return result |
Python | def island_id(self):
"""Gets the island_id of this Cluster. # noqa: E501
:return: The island_id of this Cluster. # noqa: E501
:rtype: int
"""
return self._island_id | def island_id(self):
"""Gets the island_id of this Cluster. # noqa: E501
:return: The island_id of this Cluster. # noqa: E501
:rtype: int
"""
return self._island_id |
Python | def allow_auto_join(self):
"""Gets the allow_auto_join of this Cluster. # noqa: E501
:return: The allow_auto_join of this Cluster. # noqa: E501
:rtype: bool
"""
return self._allow_auto_join | def allow_auto_join(self):
"""Gets the allow_auto_join of this Cluster. # noqa: E501
:return: The allow_auto_join of this Cluster. # noqa: E501
:rtype: bool
"""
return self._allow_auto_join |
Python | def top_level_assembly(self):
"""Gets the top_level_assembly of this Cluster. # noqa: E501
:return: The top_level_assembly of this Cluster. # noqa: E501
:rtype: str
"""
return self._top_level_assembly | def top_level_assembly(self):
"""Gets the top_level_assembly of this Cluster. # noqa: E501
:return: The top_level_assembly of this Cluster. # noqa: E501
:rtype: str
"""
return self._top_level_assembly |
Python | def transition_indications(self):
"""Gets the transition_indications of this Cluster. # noqa: E501
:return: The transition_indications of this Cluster. # noqa: E501
:rtype: list[str]
"""
return self._transition_indications | def transition_indications(self):
"""Gets the transition_indications of this Cluster. # noqa: E501
:return: The transition_indications of this Cluster. # noqa: E501
:rtype: list[str]
"""
return self._transition_indications |
Python | def transition_indications(self, transition_indications):
"""Sets the transition_indications of this Cluster.
:param transition_indications: The transition_indications of this Cluster. # noqa: E501
:type: list[str]
"""
self._transition_indications = transition_indications | def transition_indications(self, transition_indications):
"""Sets the transition_indications of this Cluster.
:param transition_indications: The transition_indications of this Cluster. # noqa: E501
:type: list[str]
"""
self._transition_indications = transition_indications |
Python | def transition_progress(self):
"""Gets the transition_progress of this Cluster. # noqa: E501
:return: The transition_progress of this Cluster. # noqa: E501
:rtype: list[str]
"""
return self._transition_progress | def transition_progress(self):
"""Gets the transition_progress of this Cluster. # noqa: E501
:return: The transition_progress of this Cluster. # noqa: E501
:rtype: list[str]
"""
return self._transition_progress |
Python | def transition_progress(self, transition_progress):
"""Sets the transition_progress of this Cluster.
:param transition_progress: The transition_progress of this Cluster. # noqa: E501
:type: list[str]
"""
self._transition_progress = transition_progress | def transition_progress(self, transition_progress):
"""Sets the transition_progress of this Cluster.
:param transition_progress: The transition_progress of this Cluster. # noqa: E501
:type: list[str]
"""
self._transition_progress = transition_progress |
Python | def health_state(self, health_state):
"""Sets the health_state of this Cluster.
:param health_state: The health_state of this Cluster. # noqa: E501
:type: str
"""
self._health_state = health_state | def health_state(self, health_state):
"""Sets the health_state of this Cluster.
:param health_state: The health_state of this Cluster. # noqa: E501
:type: str
"""
self._health_state = health_state |
Python | def system_time(self):
"""Gets the system_time of this Cluster. # noqa: E501
:return: The system_time of this Cluster. # noqa: E501
:rtype: str
"""
return self._system_time | def system_time(self):
"""Gets the system_time of this Cluster. # noqa: E501
:return: The system_time of this Cluster. # noqa: E501
:rtype: str
"""
return self._system_time |
Python | def delete_licenses(self, cluster_name, **kwargs): # noqa: E501
"""Deletes the licenses # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_licenses(cluster_name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.delete_licenses_with_http_info(cluster_name, **kwargs) # noqa: E501
else:
(data) = self.delete_licenses_with_http_info(cluster_name, **kwargs) # noqa: E501
return data | def delete_licenses(self, cluster_name, **kwargs): # noqa: E501
"""Deletes the licenses # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_licenses(cluster_name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.delete_licenses_with_http_info(cluster_name, **kwargs) # noqa: E501
else:
(data) = self.delete_licenses_with_http_info(cluster_name, **kwargs) # noqa: E501
return data |
Python | def delete_licenses_with_http_info(self, cluster_name, **kwargs): # noqa: E501
"""Deletes the licenses # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_licenses_with_http_info(cluster_name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method delete_licenses" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `delete_licenses`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/licenses', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) | def delete_licenses_with_http_info(self, cluster_name, **kwargs): # noqa: E501
"""Deletes the licenses # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_licenses_with_http_info(cluster_name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method delete_licenses" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `delete_licenses`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/licenses', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) |
Python | def install_license(self, cluster_name, license_payload, **kwargs): # noqa: E501
"""Install a new license file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.install_license(cluster_name, license_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param LicensePayload license_payload: (required)
:param bool validate:
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.install_license_with_http_info(cluster_name, license_payload, **kwargs) # noqa: E501
else:
(data) = self.install_license_with_http_info(cluster_name, license_payload, **kwargs) # noqa: E501
return data | def install_license(self, cluster_name, license_payload, **kwargs): # noqa: E501
"""Install a new license file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.install_license(cluster_name, license_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param LicensePayload license_payload: (required)
:param bool validate:
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.install_license_with_http_info(cluster_name, license_payload, **kwargs) # noqa: E501
else:
(data) = self.install_license_with_http_info(cluster_name, license_payload, **kwargs) # noqa: E501
return data |
Python | def install_license_with_http_info(self, cluster_name, license_payload, **kwargs): # noqa: E501
"""Install a new license file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.install_license_with_http_info(cluster_name, license_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param LicensePayload license_payload: (required)
:param bool validate:
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'license_payload', 'validate'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method install_license" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `install_license`") # noqa: E501
# verify the required parameter 'license_payload' is set
if ('license_payload' not in params or
params['license_payload'] is None):
raise ValueError("Missing the required parameter `license_payload` when calling `install_license`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
query_params = []
if 'validate' in params:
query_params.append(('validate', params['validate'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'license_payload' in params:
body_params = params['license_payload']
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/licenses', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) | def install_license_with_http_info(self, cluster_name, license_payload, **kwargs): # noqa: E501
"""Install a new license file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.install_license_with_http_info(cluster_name, license_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param LicensePayload license_payload: (required)
:param bool validate:
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'license_payload', 'validate'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method install_license" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `install_license`") # noqa: E501
# verify the required parameter 'license_payload' is set
if ('license_payload' not in params or
params['license_payload'] is None):
raise ValueError("Missing the required parameter `license_payload` when calling `install_license`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
query_params = []
if 'validate' in params:
query_params.append(('validate', params['validate'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'license_payload' in params:
body_params = params['license_payload']
# HTTP header `Content-Type`
header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/licenses', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) |
Python | def validate_license(self, cluster_name, validate_payload, **kwargs): # noqa: E501
"""Validate a license file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.validate_license(cluster_name, validate_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param ValidatePayload validate_payload: (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.validate_license_with_http_info(cluster_name, validate_payload, **kwargs) # noqa: E501
else:
(data) = self.validate_license_with_http_info(cluster_name, validate_payload, **kwargs) # noqa: E501
return data | def validate_license(self, cluster_name, validate_payload, **kwargs): # noqa: E501
"""Validate a license file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.validate_license(cluster_name, validate_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param ValidatePayload validate_payload: (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.validate_license_with_http_info(cluster_name, validate_payload, **kwargs) # noqa: E501
else:
(data) = self.validate_license_with_http_info(cluster_name, validate_payload, **kwargs) # noqa: E501
return data |
Python | def validate_license_with_http_info(self, cluster_name, validate_payload, **kwargs): # noqa: E501
"""Validate a license file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.validate_license_with_http_info(cluster_name, validate_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param ValidatePayload validate_payload: (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'validate_payload'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method validate_license" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `validate_license`") # noqa: E501
# verify the required parameter 'validate_payload' is set
if ('validate_payload' not in params or
params['validate_payload'] is None):
raise ValueError("Missing the required parameter `validate_payload` when calling `validate_license`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'validate_payload' in params:
body_params = params['validate_payload']
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/licenses/validate', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) | def validate_license_with_http_info(self, cluster_name, validate_payload, **kwargs): # noqa: E501
"""Validate a license file # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.validate_license_with_http_info(cluster_name, validate_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param ValidatePayload validate_payload: (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'validate_payload'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method validate_license" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `validate_license`") # noqa: E501
# verify the required parameter 'validate_payload' is set
if ('validate_payload' not in params or
params['validate_payload'] is None):
raise ValueError("Missing the required parameter `validate_payload` when calling `validate_license`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'validate_payload' in params:
body_params = params['validate_payload']
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/licenses/validate', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) |
Python | def create_virtual_volume(self, cluster_name, virtual_volume_payload, **kwargs): # noqa: E501
"""Create a new virtual volume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_virtual_volume(cluster_name, virtual_volume_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param VirtualVolumePayload virtual_volume_payload: (required)
:param str x_include_object: When passed as part of a POST request, controls whether the representation of the newly created object is included in the response. Defaults to 'true' which will include the object in the response. This header is useful because refreshing the newly created object is usually the slowest part of a POST operation.
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.create_virtual_volume_with_http_info(cluster_name, virtual_volume_payload, **kwargs) # noqa: E501
else:
(data) = self.create_virtual_volume_with_http_info(cluster_name, virtual_volume_payload, **kwargs) # noqa: E501
return data | def create_virtual_volume(self, cluster_name, virtual_volume_payload, **kwargs): # noqa: E501
"""Create a new virtual volume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_virtual_volume(cluster_name, virtual_volume_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param VirtualVolumePayload virtual_volume_payload: (required)
:param str x_include_object: When passed as part of a POST request, controls whether the representation of the newly created object is included in the response. Defaults to 'true' which will include the object in the response. This header is useful because refreshing the newly created object is usually the slowest part of a POST operation.
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.create_virtual_volume_with_http_info(cluster_name, virtual_volume_payload, **kwargs) # noqa: E501
else:
(data) = self.create_virtual_volume_with_http_info(cluster_name, virtual_volume_payload, **kwargs) # noqa: E501
return data |
Python | def create_virtual_volume_with_http_info(self, cluster_name, virtual_volume_payload, **kwargs): # noqa: E501
"""Create a new virtual volume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_virtual_volume_with_http_info(cluster_name, virtual_volume_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param VirtualVolumePayload virtual_volume_payload: (required)
:param str x_include_object: When passed as part of a POST request, controls whether the representation of the newly created object is included in the response. Defaults to 'true' which will include the object in the response. This header is useful because refreshing the newly created object is usually the slowest part of a POST operation.
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'virtual_volume_payload', 'x_include_object'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method create_virtual_volume" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `create_virtual_volume`") # noqa: E501
# verify the required parameter 'virtual_volume_payload' is set
if ('virtual_volume_payload' not in params or
params['virtual_volume_payload'] is None):
raise ValueError("Missing the required parameter `virtual_volume_payload` when calling `create_virtual_volume`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
query_params = []
header_params = {}
if 'x_include_object' in params:
header_params['X-Include-Object'] = params['x_include_object'] # noqa: E501
form_params = []
local_var_files = {}
body_params = None
if 'virtual_volume_payload' in params:
body_params = params['virtual_volume_payload']
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/virtual_volumes', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='VirtualVolume', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) | def create_virtual_volume_with_http_info(self, cluster_name, virtual_volume_payload, **kwargs): # noqa: E501
"""Create a new virtual volume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_virtual_volume_with_http_info(cluster_name, virtual_volume_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param VirtualVolumePayload virtual_volume_payload: (required)
:param str x_include_object: When passed as part of a POST request, controls whether the representation of the newly created object is included in the response. Defaults to 'true' which will include the object in the response. This header is useful because refreshing the newly created object is usually the slowest part of a POST operation.
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'virtual_volume_payload', 'x_include_object'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method create_virtual_volume" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `create_virtual_volume`") # noqa: E501
# verify the required parameter 'virtual_volume_payload' is set
if ('virtual_volume_payload' not in params or
params['virtual_volume_payload'] is None):
raise ValueError("Missing the required parameter `virtual_volume_payload` when calling `create_virtual_volume`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
query_params = []
header_params = {}
if 'x_include_object' in params:
header_params['X-Include-Object'] = params['x_include_object'] # noqa: E501
form_params = []
local_var_files = {}
body_params = None
if 'virtual_volume_payload' in params:
body_params = params['virtual_volume_payload']
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/virtual_volumes', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='VirtualVolume', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) |
Python | def delete_virtual_volume(self, cluster_name, name, **kwargs): # noqa: E501
"""Deletes a single VirtualVolume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_virtual_volume(cluster_name, name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.delete_virtual_volume_with_http_info(cluster_name, name, **kwargs) # noqa: E501
else:
(data) = self.delete_virtual_volume_with_http_info(cluster_name, name, **kwargs) # noqa: E501
return data | def delete_virtual_volume(self, cluster_name, name, **kwargs): # noqa: E501
"""Deletes a single VirtualVolume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_virtual_volume(cluster_name, name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.delete_virtual_volume_with_http_info(cluster_name, name, **kwargs) # noqa: E501
else:
(data) = self.delete_virtual_volume_with_http_info(cluster_name, name, **kwargs) # noqa: E501
return data |
Python | def delete_virtual_volume_with_http_info(self, cluster_name, name, **kwargs): # noqa: E501
"""Deletes a single VirtualVolume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_virtual_volume_with_http_info(cluster_name, name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'name'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method delete_virtual_volume" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `delete_virtual_volume`") # noqa: E501
# verify the required parameter 'name' is set
if ('name' not in params or
params['name'] is None):
raise ValueError("Missing the required parameter `name` when calling `delete_virtual_volume`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
if 'name' in params:
path_params['name'] = params['name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/virtual_volumes/{name}', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) | def delete_virtual_volume_with_http_info(self, cluster_name, name, **kwargs): # noqa: E501
"""Deletes a single VirtualVolume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_virtual_volume_with_http_info(cluster_name, name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:return: None
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'name'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method delete_virtual_volume" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `delete_virtual_volume`") # noqa: E501
# verify the required parameter 'name' is set
if ('name' not in params or
params['name'] is None):
raise ValueError("Missing the required parameter `name` when calling `delete_virtual_volume`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
if 'name' in params:
path_params['name'] = params['name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/virtual_volumes/{name}', 'DELETE',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type=None, # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) |
Python | def expand_virtual_volume(self, cluster_name, name, virtual_volume_expand_payload, **kwargs): # noqa: E501
"""Expand the capacity of a VirtualVolume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.expand_virtual_volume(cluster_name, name, virtual_volume_expand_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:param VirtualVolumeExpandPayload virtual_volume_expand_payload: (required)
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.expand_virtual_volume_with_http_info(cluster_name, name, virtual_volume_expand_payload, **kwargs) # noqa: E501
else:
(data) = self.expand_virtual_volume_with_http_info(cluster_name, name, virtual_volume_expand_payload, **kwargs) # noqa: E501
return data | def expand_virtual_volume(self, cluster_name, name, virtual_volume_expand_payload, **kwargs): # noqa: E501
"""Expand the capacity of a VirtualVolume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.expand_virtual_volume(cluster_name, name, virtual_volume_expand_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:param VirtualVolumeExpandPayload virtual_volume_expand_payload: (required)
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.expand_virtual_volume_with_http_info(cluster_name, name, virtual_volume_expand_payload, **kwargs) # noqa: E501
else:
(data) = self.expand_virtual_volume_with_http_info(cluster_name, name, virtual_volume_expand_payload, **kwargs) # noqa: E501
return data |
Python | def expand_virtual_volume_with_http_info(self, cluster_name, name, virtual_volume_expand_payload, **kwargs): # noqa: E501
"""Expand the capacity of a VirtualVolume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.expand_virtual_volume_with_http_info(cluster_name, name, virtual_volume_expand_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:param VirtualVolumeExpandPayload virtual_volume_expand_payload: (required)
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'name', 'virtual_volume_expand_payload'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method expand_virtual_volume" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `expand_virtual_volume`") # noqa: E501
# verify the required parameter 'name' is set
if ('name' not in params or
params['name'] is None):
raise ValueError("Missing the required parameter `name` when calling `expand_virtual_volume`") # noqa: E501
# verify the required parameter 'virtual_volume_expand_payload' is set
if ('virtual_volume_expand_payload' not in params or
params['virtual_volume_expand_payload'] is None):
raise ValueError("Missing the required parameter `virtual_volume_expand_payload` when calling `expand_virtual_volume`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
if 'name' in params:
path_params['name'] = params['name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'virtual_volume_expand_payload' in params:
body_params = params['virtual_volume_expand_payload']
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/virtual_volumes/{name}/expand', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='VirtualVolume', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) | def expand_virtual_volume_with_http_info(self, cluster_name, name, virtual_volume_expand_payload, **kwargs): # noqa: E501
"""Expand the capacity of a VirtualVolume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.expand_virtual_volume_with_http_info(cluster_name, name, virtual_volume_expand_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:param VirtualVolumeExpandPayload virtual_volume_expand_payload: (required)
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'name', 'virtual_volume_expand_payload'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method expand_virtual_volume" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `expand_virtual_volume`") # noqa: E501
# verify the required parameter 'name' is set
if ('name' not in params or
params['name'] is None):
raise ValueError("Missing the required parameter `name` when calling `expand_virtual_volume`") # noqa: E501
# verify the required parameter 'virtual_volume_expand_payload' is set
if ('virtual_volume_expand_payload' not in params or
params['virtual_volume_expand_payload'] is None):
raise ValueError("Missing the required parameter `virtual_volume_expand_payload` when calling `expand_virtual_volume`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
if 'name' in params:
path_params['name'] = params['name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'virtual_volume_expand_payload' in params:
body_params = params['virtual_volume_expand_payload']
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/virtual_volumes/{name}/expand', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='VirtualVolume', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) |
Python | def patch_virtual_volume(self, cluster_name, name, virtual_volume_patch_payload, **kwargs): # noqa: E501
"""Update attributes on a VirtualVolume # noqa: E501
Settable attributes: 'name' # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.patch_virtual_volume(cluster_name, name, virtual_volume_patch_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:param list[JsonPatchOp] virtual_volume_patch_payload: (required)
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.patch_virtual_volume_with_http_info(cluster_name, name, virtual_volume_patch_payload, **kwargs) # noqa: E501
else:
(data) = self.patch_virtual_volume_with_http_info(cluster_name, name, virtual_volume_patch_payload, **kwargs) # noqa: E501
return data | def patch_virtual_volume(self, cluster_name, name, virtual_volume_patch_payload, **kwargs): # noqa: E501
"""Update attributes on a VirtualVolume # noqa: E501
Settable attributes: 'name' # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.patch_virtual_volume(cluster_name, name, virtual_volume_patch_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:param list[JsonPatchOp] virtual_volume_patch_payload: (required)
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.patch_virtual_volume_with_http_info(cluster_name, name, virtual_volume_patch_payload, **kwargs) # noqa: E501
else:
(data) = self.patch_virtual_volume_with_http_info(cluster_name, name, virtual_volume_patch_payload, **kwargs) # noqa: E501
return data |
Python | def patch_virtual_volume_with_http_info(self, cluster_name, name, virtual_volume_patch_payload, **kwargs): # noqa: E501
"""Update attributes on a VirtualVolume # noqa: E501
Settable attributes: 'name' # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.patch_virtual_volume_with_http_info(cluster_name, name, virtual_volume_patch_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:param list[JsonPatchOp] virtual_volume_patch_payload: (required)
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'name', 'virtual_volume_patch_payload'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method patch_virtual_volume" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `patch_virtual_volume`") # noqa: E501
# verify the required parameter 'name' is set
if ('name' not in params or
params['name'] is None):
raise ValueError("Missing the required parameter `name` when calling `patch_virtual_volume`") # noqa: E501
# verify the required parameter 'virtual_volume_patch_payload' is set
if ('virtual_volume_patch_payload' not in params or
params['virtual_volume_patch_payload'] is None):
raise ValueError("Missing the required parameter `virtual_volume_patch_payload` when calling `patch_virtual_volume`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
if 'name' in params:
path_params['name'] = params['name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'virtual_volume_patch_payload' in params:
body_params = params['virtual_volume_patch_payload']
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/virtual_volumes/{name}', 'PATCH',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='VirtualVolume', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) | def patch_virtual_volume_with_http_info(self, cluster_name, name, virtual_volume_patch_payload, **kwargs): # noqa: E501
"""Update attributes on a VirtualVolume # noqa: E501
Settable attributes: 'name' # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.patch_virtual_volume_with_http_info(cluster_name, name, virtual_volume_patch_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:param list[JsonPatchOp] virtual_volume_patch_payload: (required)
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'name', 'virtual_volume_patch_payload'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method patch_virtual_volume" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `patch_virtual_volume`") # noqa: E501
# verify the required parameter 'name' is set
if ('name' not in params or
params['name'] is None):
raise ValueError("Missing the required parameter `name` when calling `patch_virtual_volume`") # noqa: E501
# verify the required parameter 'virtual_volume_patch_payload' is set
if ('virtual_volume_patch_payload' not in params or
params['virtual_volume_patch_payload'] is None):
raise ValueError("Missing the required parameter `virtual_volume_patch_payload` when calling `patch_virtual_volume`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
if 'name' in params:
path_params['name'] = params['name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
if 'virtual_volume_patch_payload' in params:
body_params = params['virtual_volume_patch_payload']
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/virtual_volumes/{name}', 'PATCH',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='VirtualVolume', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) |
Python | def virtual_volume_cache_invalidate(self, cluster_name, name, **kwargs): # noqa: E501
"""cache invalidate on virtual volume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.virtual_volume_cache_invalidate(cluster_name, name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.virtual_volume_cache_invalidate_with_http_info(cluster_name, name, **kwargs) # noqa: E501
else:
(data) = self.virtual_volume_cache_invalidate_with_http_info(cluster_name, name, **kwargs) # noqa: E501
return data | def virtual_volume_cache_invalidate(self, cluster_name, name, **kwargs): # noqa: E501
"""cache invalidate on virtual volume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.virtual_volume_cache_invalidate(cluster_name, name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.virtual_volume_cache_invalidate_with_http_info(cluster_name, name, **kwargs) # noqa: E501
else:
(data) = self.virtual_volume_cache_invalidate_with_http_info(cluster_name, name, **kwargs) # noqa: E501
return data |
Python | def virtual_volume_cache_invalidate_with_http_info(self, cluster_name, name, **kwargs): # noqa: E501
"""cache invalidate on virtual volume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.virtual_volume_cache_invalidate_with_http_info(cluster_name, name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'name'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method virtual_volume_cache_invalidate" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `virtual_volume_cache_invalidate`") # noqa: E501
# verify the required parameter 'name' is set
if ('name' not in params or
params['name'] is None):
raise ValueError("Missing the required parameter `name` when calling `virtual_volume_cache_invalidate`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
if 'name' in params:
path_params['name'] = params['name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/virtual_volumes/{name}/cache_invalidate', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='VirtualVolume', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) | def virtual_volume_cache_invalidate_with_http_info(self, cluster_name, name, **kwargs): # noqa: E501
"""cache invalidate on virtual volume # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.virtual_volume_cache_invalidate_with_http_info(cluster_name, name, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param str name: The name of a specific instance of the resource (required)
:return: VirtualVolume
If the method is called asynchronously,
returns the request thread.
"""
all_params = ['cluster_name', 'name'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
params = locals()
for key, val in six.iteritems(params['kwargs']):
if key not in all_params:
raise TypeError(
"Got an unexpected keyword argument '%s'"
" to method virtual_volume_cache_invalidate" % key
)
params[key] = val
del params['kwargs']
# verify the required parameter 'cluster_name' is set
if ('cluster_name' not in params or
params['cluster_name'] is None):
raise ValueError("Missing the required parameter `cluster_name` when calling `virtual_volume_cache_invalidate`") # noqa: E501
# verify the required parameter 'name' is set
if ('name' not in params or
params['name'] is None):
raise ValueError("Missing the required parameter `name` when calling `virtual_volume_cache_invalidate`") # noqa: E501
collection_formats = {}
path_params = {}
if 'cluster_name' in params:
path_params['cluster_name'] = params['cluster_name'] # noqa: E501
if 'name' in params:
path_params['name'] = params['name'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['application/json']) # noqa: E501
# Authentication setting
auth_settings = ['basicAuth', 'jwtAuth'] # noqa: E501
return self.api_client.call_api(
'/clusters/{cluster_name}/virtual_volumes/{name}/cache_invalidate', 'POST',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='VirtualVolume', # noqa: E501
auth_settings=auth_settings,
async_req=params.get('async_req'),
_return_http_data_only=params.get('_return_http_data_only'),
_preload_content=params.get('_preload_content', True),
_request_timeout=params.get('_request_timeout'),
collection_formats=collection_formats) |
Python | def create_backup_metadata(self, cluster_name, metadata_backup_payload, **kwargs): # noqa: E501
"""Create List of configured MetaData Backups Volume with their scheduled time # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_backup_metadata(cluster_name, metadata_backup_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param MetadataBackupPayload metadata_backup_payload: (required)
:param str x_include_object: When passed as part of a POST request, controls whether the representation of the newly created object is included in the response. Defaults to 'true' which will include the object in the response. This header is useful because refreshing the newly created object is usually the slowest part of a POST operation.
:return: InlineResponse2011
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.create_backup_metadata_with_http_info(cluster_name, metadata_backup_payload, **kwargs) # noqa: E501
else:
(data) = self.create_backup_metadata_with_http_info(cluster_name, metadata_backup_payload, **kwargs) # noqa: E501
return data | def create_backup_metadata(self, cluster_name, metadata_backup_payload, **kwargs): # noqa: E501
"""Create List of configured MetaData Backups Volume with their scheduled time # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_backup_metadata(cluster_name, metadata_backup_payload, async_req=True)
>>> result = thread.get()
:param async_req bool
:param str cluster_name: The name of the cluster (required)
:param MetadataBackupPayload metadata_backup_payload: (required)
:param str x_include_object: When passed as part of a POST request, controls whether the representation of the newly created object is included in the response. Defaults to 'true' which will include the object in the response. This header is useful because refreshing the newly created object is usually the slowest part of a POST operation.
:return: InlineResponse2011
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
if kwargs.get('async_req'):
return self.create_backup_metadata_with_http_info(cluster_name, metadata_backup_payload, **kwargs) # noqa: E501
else:
(data) = self.create_backup_metadata_with_http_info(cluster_name, metadata_backup_payload, **kwargs) # noqa: E501
return data |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.