def run_example():
credentials = get_credentials()
config = AzureConfiguration('https://management.azure.com')
service_client = ServiceClient(credentials, config)
query_parameters = {}
query_parameters['api-version'] = API_VERSION
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
operation_config = {}
request = service_client.put(
"/subscriptions/" + SUBSCRIPTION_ID + "/resourceGroups/" +
RESOURCE_GROUP + "/providers/Microsoft.Storage/storageAccounts/" +
STORAGE_ACCOUNT_NAME + "/blobServices/" + BLOB_SERVICE_NAME +
"/containers/" + CONTAINER_NAME, query_parameters)
response = service_client.send(request, header_parameters, BODY,
**operation_config)
if response.status_code == 202:
response = wait_poller(service_client, operation_config, response)
print(response.text)
class GenericRestClient(object):
def __init__(self, credentials, subscription_id, base_url=None):
self.config = GenericRestClientConfiguration(credentials,
subscription_id, base_url)
self._client = ServiceClient(self.config.credentials, self.config)
self.models = None
def query(self, url, method, query_parameters, header_parameters, body,
expected_status_codes, polling_timeout, polling_interval):
# Construct and send request
operation_config = {}
request = None
if header_parameters is None:
header_parameters = {}
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if method == 'GET':
request = self._client.get(url, query_parameters)
elif method == 'PUT':
request = self._client.put(url, query_parameters)
elif method == 'POST':
request = self._client.post(url, query_parameters)
elif method == 'HEAD':
request = self._client.head(url, query_parameters)
elif method == 'PATCH':
request = self._client.patch(url, query_parameters)
elif method == 'DELETE':
request = self._client.delete(url, query_parameters)
elif method == 'MERGE':
request = self._client.merge(url, query_parameters)
response = self._client.send(request, header_parameters, body,
**operation_config)
if response.status_code not in expected_status_codes:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
elif response.status_code == 202 and polling_timeout > 0:
def get_long_running_output(response):
return response
poller = LROPoller(
self._client, ClientRawResponse(None, response),
get_long_running_output,
ARMPolling(polling_interval, **operation_config))
response = self.get_poller_result(poller, polling_timeout)
return response
def get_poller_result(self, poller, timeout):
try:
poller.wait(timeout=timeout)
return poller.result()
except Exception as exc:
raise
def run_example():
credentials = get_credentials()
config = AzureConfiguration('https://management.azure.com')
service_client = ServiceClient(credentials, config)
query_parameters = {}
query_parameters['api-version'] = API_VERSION
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
operation_config = {}
request = service_client.put("/subscriptions/" + SUBSCRIPTION_ID + "/resourceGroups/" + RESOURCE_GROUP, query_parameters)
response = service_client.send(request, header_parameters, BODY, **operation_config)
print(response.text)
def run_example():
credentials = get_credentials()
config = AzureConfiguration('https://management.azure.com')
service_client = ServiceClient(credentials, config)
query_parameters = {}
query_parameters['api-version'] = API_VERSION
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
operation_config = {}
request = service_client.put("/subscriptions/" + SUBSCRIPTION_ID + "/resourceGroups/" + RESOURCE_GROUP + "/providers/Microsoft.DataFactory/factories/" + FACTORY_NAME + "/pipelines/" + PIPELINE_NAME,query_parameters)
# request = service_client.post("/subscriptions/" + SUBSCRIPTION_ID + "/resourceGroups/" + RESOURCE_GROUP + "/providers/Microsoft.DataFactory/factories/" + FACTORY_NAME + "/pipelines/" + PIPELINE_NAME + "/createRun", query_parameters)
response = service_client.send(request, header_parameters, BODY, **operation_config)
print(response.text)
class GenericRestClient(object):
def __init__(self, credentials, subscription_id, base_url=None):
self.config = GenericRestClientConfiguration(credentials,
subscription_id, base_url)
self._client = ServiceClient(self.config.credentials, self.config)
self.models = None
def query(self, url, method, query_parameters, header_parameters, body,
expected_status_codes):
# Construct and send request
operation_config = {}
request = None
if method == 'GET':
request = self._client.get(url, query_parameters)
elif method == 'PUT':
request = self._client.put(url, query_parameters)
elif method == 'POST':
request = self._client.post(url, query_parameters)
elif method == 'HEAD':
request = self._client.head(url, query_parameters)
elif method == 'PATCH':
request = self._client.patch(url, query_parameters)
elif method == 'DELETE':
request = self._client.delete(url, query_parameters)
elif method == 'MERGE':
request = self._client.merge(url, query_parameters)
response = self._client.send(request, header_parameters, body,
**operation_config)
if response.status_code not in expected_status_codes:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
return response
def run_example():
credentials = get_credentials()
config = AzureConfiguration('https://management.azure.com')
service_client = ServiceClient(credentials, config)
query_parameters = {}
query_parameters['api-version'] = API_VERSION
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
operation_config = {}
request = service_client.put(
"/subscriptions/" + SUBSCRIPTION_ID + "/resourceGroups/" +
RESOURCE_GROUP + "/providers/Microsoft.Databricks/workspaces/" +
WORKSPACE_NAME, query_parameters)
response = service_client.send(request, header_parameters, BODY,
**operation_config)
# if response.status_code == 202:
# response = wait_poller(service_client, operation_config, response)
print(response.text)
class AutoRestResourceFlatteningTestService(object):
"""Resource Flattening for AutoRest
:param config: Configuration for client.
:type config: AutoRestResourceFlatteningTestServiceConfiguration
"""
def __init__(self, config):
self._client = ServiceClient(None, config)
client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
self._serialize = Serializer()
self._deserialize = Deserializer(client_models)
self.config = config
def put_array(
self, resource_array=None, custom_headers={}, raw=False, **operation_config):
"""
Put External Resource as an Array
:param resource_array: External Resource as an Array to put
:type resource_array: list of :class:`Resource
<fixtures.acceptancetestsmodelflattening.models.Resource>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/model-flatten/array'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if resource_array is not None:
body_content = self._serialize.body(resource_array, '[Resource]')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_array(
self, custom_headers={}, raw=False, **operation_config):
"""
Get External Resource as an Array
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: list of :class:`FlattenedProduct
<fixtures.acceptancetestsmodelflattening.models.FlattenedProduct>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/model-flatten/array'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[FlattenedProduct]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_dictionary(
self, resource_dictionary=None, custom_headers={}, raw=False, **operation_config):
"""
Put External Resource as a Dictionary
:param resource_dictionary: External Resource as a Dictionary to put
:type resource_dictionary: dict
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/model-flatten/dictionary'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if resource_dictionary is not None:
body_content = self._serialize.body(resource_dictionary, '{FlattenedProduct}')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_dictionary(
self, custom_headers={}, raw=False, **operation_config):
"""
Get External Resource as a Dictionary
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: dict
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/model-flatten/dictionary'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('{FlattenedProduct}', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_resource_collection(
self, resource_complex_object=None, custom_headers={}, raw=False, **operation_config):
"""
Put External Resource as a ResourceCollection
:param resource_complex_object: External Resource as a
ResourceCollection to put
:type resource_complex_object: :class:`ResourceCollection
<fixtures.acceptancetestsmodelflattening.models.ResourceCollection>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/model-flatten/resourcecollection'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if resource_complex_object is not None:
body_content = self._serialize.body(resource_complex_object, 'ResourceCollection')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_resource_collection(
self, custom_headers={}, raw=False, **operation_config):
"""
Get External Resource as a ResourceCollection
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`ResourceCollection
<fixtures.acceptancetestsmodelflattening.models.ResourceCollection>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/model-flatten/resourcecollection'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('ResourceCollection', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_simple_product(
self, simple_body_product=None, custom_headers={}, raw=False, **operation_config):
"""
Put Simple Product with client flattening true on the model
:param simple_body_product: Simple body product to put
:type simple_body_product: :class:`SimpleProduct
<fixtures.acceptancetestsmodelflattening.models.SimpleProduct>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`SimpleProduct
<fixtures.acceptancetestsmodelflattening.models.SimpleProduct>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/model-flatten/customFlattening'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if simple_body_product is not None:
body_content = self._serialize.body(simple_body_product, 'SimpleProduct')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('SimpleProduct', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def post_flattened_simple_product(
self, product_id, max_product_display_name, description=None, odatavalue=None, custom_headers={}, raw=False, **operation_config):
"""
Put Flattened Simple Product with client flattening true on the
parameter
:param product_id: Unique identifier representing a specific product
for a given latitude & longitude. For example, uberX in San
Francisco will have a different product_id than uberX in Los Angeles.
:type product_id: str
:param max_product_display_name: Display name of product.
:type max_product_display_name: str
:param description: Description of product.
:type description: str
:param odatavalue: URL value.
:type odatavalue: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`SimpleProduct
<fixtures.acceptancetestsmodelflattening.models.SimpleProduct>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
simple_body_product = models.SimpleProduct(product_id=product_id, description=description, max_product_display_name=max_product_display_name, odatavalue=odatavalue)
# Construct URL
url = '/model-flatten/customFlattening'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if simple_body_product is not None:
body_content = self._serialize.body(simple_body_product, 'SimpleProduct')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('SimpleProduct', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_simple_product_with_grouping(
self, flatten_parameter_group, custom_headers={}, raw=False, **operation_config):
"""
Put Simple Product with client flattening true on the model
:param flatten_parameter_group: Additional parameters for the
operation
:type flatten_parameter_group: :class:`FlattenParameterGroup
<fixtures.acceptancetestsmodelflattening.models.FlattenParameterGroup>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`SimpleProduct
<fixtures.acceptancetestsmodelflattening.models.SimpleProduct>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
name = None
if flatten_parameter_group is not None:
name = flatten_parameter_group.name
product_id = None
if flatten_parameter_group is not None:
product_id = flatten_parameter_group.product_id
description = None
if flatten_parameter_group is not None:
description = flatten_parameter_group.description
max_product_display_name = None
if flatten_parameter_group is not None:
max_product_display_name = flatten_parameter_group.max_product_display_name
odatavalue = None
if flatten_parameter_group is not None:
odatavalue = flatten_parameter_group.odatavalue
simple_body_product = models.SimpleProduct(product_id=product_id, description=description, max_product_display_name=max_product_display_name, odatavalue=odatavalue)
# Construct URL
url = '/model-flatten/customFlattening/parametergrouping/{name}/'
path_format_arguments = {
'name': self._serialize.url("name", name, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if simple_body_product is not None:
body_content = self._serialize.body(simple_body_product, 'SimpleProduct')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('SimpleProduct', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
class AutoRestValidationTest(object):
"""Test Infrastructure for AutoRest. No server backend exists for these tests.
:ivar config: Configuration for client.
:vartype config: AutoRestValidationTestConfiguration
:param subscription_id: Subscription ID.
:type subscription_id: str
:param api_version: Required string following pattern \\d{2}-\\d{2}-\\d{4}
:type api_version: str
:param str base_url: Service URL
:param str filepath: Existing config
"""
def __init__(self,
subscription_id,
api_version,
base_url=None,
filepath=None):
self.config = AutoRestValidationTestConfiguration(
subscription_id, api_version, base_url, filepath)
self._client = ServiceClient(None, self.config)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def validation_of_method_parameters(self,
resource_group_name,
id,
custom_headers=None,
raw=False,
**operation_config):
"""Validates input parameters on the method. See swagger for details.
:param resource_group_name: Required string between 3 and 10 chars
with pattern [a-zA-Z0-9]+.
:type resource_group_name: str
:param id: Required int multiple of 10 from 100 to 1000.
:type id: int
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`Product
<Fixtures.AcceptanceTestsValidation.models.Product>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`ErrorException<Fixtures.AcceptanceTestsValidation.models.ErrorException>`
"""
# Construct URL
url = '/fakepath/{subscriptionId}/{resourceGroupName}/{id}'
path_format_arguments = {
'subscriptionId':
self._serialize.url("self.config.subscription_id",
self.config.subscription_id, 'str'),
'resourceGroupName':
self._serialize.url("resource_group_name",
resource_group_name,
'str',
max_length=10,
min_length=3,
pattern='[a-zA-Z0-9]+'),
'id':
self._serialize.url("id",
id,
'int',
maximum=1000,
minimum=100,
multiple=10)
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['apiVersion'] = self._serialize.query(
"self.config.api_version",
self.config.api_version,
'str',
pattern='\d{2}-\d{2}-\d{4}')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Product', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def validation_of_body(self,
resource_group_name,
id,
body=None,
custom_headers=None,
raw=False,
**operation_config):
"""Validates body parameters on the method. See swagger for details.
:param resource_group_name: Required string between 3 and 10 chars
with pattern [a-zA-Z0-9]+.
:type resource_group_name: str
:param id: Required int multiple of 10 from 100 to 1000.
:type id: int
:param body:
:type body: :class:`Product
<Fixtures.AcceptanceTestsValidation.models.Product>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`Product
<Fixtures.AcceptanceTestsValidation.models.Product>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`ErrorException<Fixtures.AcceptanceTestsValidation.models.ErrorException>`
"""
# Construct URL
url = '/fakepath/{subscriptionId}/{resourceGroupName}/{id}'
path_format_arguments = {
'subscriptionId':
self._serialize.url("self.config.subscription_id",
self.config.subscription_id, 'str'),
'resourceGroupName':
self._serialize.url("resource_group_name",
resource_group_name,
'str',
max_length=10,
min_length=3,
pattern='[a-zA-Z0-9]+'),
'id':
self._serialize.url("id",
id,
'int',
maximum=1000,
minimum=100,
multiple=10)
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['apiVersion'] = self._serialize.query(
"self.config.api_version",
self.config.api_version,
'str',
pattern='\d{2}-\d{2}-\d{4}')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'Product')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Product', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def get_with_constant_in_path(self,
custom_headers=None,
raw=False,
**operation_config):
"""
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
constant_param = "constant"
# Construct URL
url = '/validation/constantsInPath/{constantParam}/value'
path_format_arguments = {
'constantParam':
self._serialize.url("constant_param", constant_param, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def post_with_constant_in_body(self,
body=None,
custom_headers=None,
raw=False,
**operation_config):
"""
:param body:
:type body: :class:`Product
<Fixtures.AcceptanceTestsValidation.models.Product>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`Product
<Fixtures.AcceptanceTestsValidation.models.Product>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
constant_param = "constant"
# Construct URL
url = '/validation/constantsInPath/{constantParam}/value'
path_format_arguments = {
'constantParam':
self._serialize.url("constant_param", constant_param, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'Product')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Product', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
class AutoRestValidationTest(object):
"""Test Infrastructure for AutoRest. No server backend exists for these tests.
:param config: Configuration for client.
:type config: AutoRestValidationTestConfiguration
"""
def __init__(self, config):
self._client = ServiceClient(None, config)
client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
self._serialize = Serializer()
self._deserialize = Deserializer(client_models)
self.config = config
def validation_of_method_parameters(
self, resource_group_name, id, custom_headers={}, raw=False, **operation_config):
"""
Validates input parameters on the method. See swagger for details.
:param resource_group_name: Required string between 3 and 10 chars
with pattern [a-zA-Z0-9]+.
:type resource_group_name: str
:param id: Required int multiple of 10 from 100 to 1000.
:type id: int
:param dict custom_headers: headers that will be added to the request
:param boolean raw: returns the direct response alongside the
deserialized response
:rtype: Product or msrest.pipeline.ClientRawResponse
"""
# Construct URL
url = '/fakepath/{subscriptionId}/{resourceGroupName}/{id}'
path_format_arguments = {
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'id': self._serialize.url("id", id, 'int')
}
url = url.format(**path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['apiVersion'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Product', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def validation_of_body(
self, resource_group_name, id, body=None, custom_headers={}, raw=False, **operation_config):
"""
Validates body parameters on the method. See swagger for details.
:param resource_group_name: Required string between 3 and 10 chars
with pattern [a-zA-Z0-9]+.
:type resource_group_name: str
:param id: Required int multiple of 10 from 100 to 1000.
:type id: int
:param body:
:type body: Product or None
:param dict custom_headers: headers that will be added to the request
:param boolean raw: returns the direct response alongside the
deserialized response
:rtype: Product or msrest.pipeline.ClientRawResponse
"""
# Construct URL
url = '/fakepath/{subscriptionId}/{resourceGroupName}/{id}'
path_format_arguments = {
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str'),
'id': self._serialize.url("id", id, 'int')
}
url = url.format(**path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['apiVersion'] = self._serialize.query("self.config.api_version", self.config.api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'Product')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Product', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def get_with_constant_in_path(
self, constant_param, custom_headers={}, raw=False, **operation_config):
"""
:param constant_param:
:type constant_param: str
:param dict custom_headers: headers that will be added to the request
:param boolean raw: returns the direct response alongside the
deserialized response
:rtype: None or msrest.pipeline.ClientRawResponse
"""
# Construct URL
url = '/validation/constantsInPath/{constantParam}/value'
path_format_arguments = {
'constantParam': self._serialize.url("constant_param", constant_param, 'str')
}
url = url.format(**path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def post_with_constant_in_body(
self, constant_param, body=None, custom_headers={}, raw=False, **operation_config):
"""
:param constant_param:
:type constant_param: str
:param body:
:type body: Product or None
:param dict custom_headers: headers that will be added to the request
:param boolean raw: returns the direct response alongside the
deserialized response
:rtype: Product or msrest.pipeline.ClientRawResponse
"""
# Construct URL
url = '/validation/constantsInPath/{constantParam}/value'
path_format_arguments = {
'constantParam': self._serialize.url("constant_param", constant_param, 'str')
}
url = url.format(**path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'Product')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Product', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
class AutoRestResourceFlatteningTestService(object):
"""Resource Flattening for AutoRest
:ivar config: Configuration for client.
:vartype config: AutoRestResourceFlatteningTestServiceConfiguration
:param str base_url: Service URL
:param str filepath: Existing config
"""
def __init__(self, base_url=None, filepath=None):
self.config = AutoRestResourceFlatteningTestServiceConfiguration(
base_url, filepath)
self._client = ServiceClient(None, self.config)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def put_array(self,
resource_array=None,
custom_headers=None,
raw=False,
**operation_config):
"""
Put External Resource as an Array
:param resource_array: External Resource as an Array to put
:type resource_array: list of :class:`Resource
<fixtures.acceptancetestsmodelflattening.models.Resource>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/model-flatten/array'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if resource_array is not None:
body_content = self._serialize.body(resource_array, '[Resource]')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_array(self, custom_headers=None, raw=False, **operation_config):
"""
Get External Resource as an Array
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: list of :class:`FlattenedProduct
<fixtures.acceptancetestsmodelflattening.models.FlattenedProduct>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/model-flatten/array'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[FlattenedProduct]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_dictionary(self,
resource_dictionary=None,
custom_headers=None,
raw=False,
**operation_config):
"""
Put External Resource as a Dictionary
:param resource_dictionary: External Resource as a Dictionary to put
:type resource_dictionary: dict
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/model-flatten/dictionary'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if resource_dictionary is not None:
body_content = self._serialize.body(resource_dictionary,
'{FlattenedProduct}')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_dictionary(self,
custom_headers=None,
raw=False,
**operation_config):
"""
Get External Resource as a Dictionary
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: dict
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/model-flatten/dictionary'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('{FlattenedProduct}', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_resource_collection(self,
resource_complex_object=None,
custom_headers=None,
raw=False,
**operation_config):
"""
Put External Resource as a ResourceCollection
:param resource_complex_object: External Resource as a
ResourceCollection to put
:type resource_complex_object: :class:`ResourceCollection
<fixtures.acceptancetestsmodelflattening.models.ResourceCollection>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/model-flatten/resourcecollection'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if resource_complex_object is not None:
body_content = self._serialize.body(resource_complex_object,
'ResourceCollection')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_resource_collection(self,
custom_headers=None,
raw=False,
**operation_config):
"""
Get External Resource as a ResourceCollection
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`ResourceCollection
<fixtures.acceptancetestsmodelflattening.models.ResourceCollection>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/model-flatten/resourcecollection'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('ResourceCollection', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_simple_product(self,
simple_body_product=None,
custom_headers=None,
raw=False,
**operation_config):
"""
Put Simple Product with client flattening true on the model
:param simple_body_product: Simple body product to put
:type simple_body_product: :class:`SimpleProduct
<fixtures.acceptancetestsmodelflattening.models.SimpleProduct>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`SimpleProduct
<fixtures.acceptancetestsmodelflattening.models.SimpleProduct>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/model-flatten/customFlattening'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if simple_body_product is not None:
body_content = self._serialize.body(simple_body_product,
'SimpleProduct')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('SimpleProduct', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def post_flattened_simple_product(self,
product_id,
max_product_display_name,
description=None,
generic_value=None,
odatavalue=None,
custom_headers=None,
raw=False,
**operation_config):
"""
Put Flattened Simple Product with client flattening true on the
parameter
:param product_id: Unique identifier representing a specific product
for a given latitude & longitude. For example, uberX in San
Francisco will have a different product_id than uberX in Los Angeles.
:type product_id: str
:param max_product_display_name: Display name of product.
:type max_product_display_name: str
:param description: Description of product.
:type description: str
:param generic_value: Generic URL value.
:type generic_value: str
:param odatavalue: URL value.
:type odatavalue: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`SimpleProduct
<fixtures.acceptancetestsmodelflattening.models.SimpleProduct>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
simple_body_product = None
if product_id is not None or description is not None or max_product_display_name is not None or generic_value is not None or odatavalue is not None:
simple_body_product = models.SimpleProduct(
product_id=product_id,
description=description,
max_product_display_name=max_product_display_name,
generic_value=generic_value,
odatavalue=odatavalue)
# Construct URL
url = '/model-flatten/customFlattening'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if simple_body_product is not None:
body_content = self._serialize.body(simple_body_product,
'SimpleProduct')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('SimpleProduct', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_simple_product_with_grouping(self,
flatten_parameter_group,
custom_headers=None,
raw=False,
**operation_config):
"""
Put Simple Product with client flattening true on the model
:param flatten_parameter_group: Additional parameters for the
operation
:type flatten_parameter_group: :class:`FlattenParameterGroup
<fixtures.acceptancetestsmodelflattening.models.FlattenParameterGroup>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`SimpleProduct
<fixtures.acceptancetestsmodelflattening.models.SimpleProduct>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
name = None
if flatten_parameter_group is not None:
name = flatten_parameter_group.name
product_id = None
if flatten_parameter_group is not None:
product_id = flatten_parameter_group.product_id
description = None
if flatten_parameter_group is not None:
description = flatten_parameter_group.description
max_product_display_name = None
if flatten_parameter_group is not None:
max_product_display_name = flatten_parameter_group.max_product_display_name
generic_value = None
if flatten_parameter_group is not None:
generic_value = flatten_parameter_group.generic_value
odatavalue = None
if flatten_parameter_group is not None:
odatavalue = flatten_parameter_group.odatavalue
simple_body_product = None
if product_id is not None or description is not None or max_product_display_name is not None or generic_value is not None or odatavalue is not None:
simple_body_product = models.SimpleProduct(
product_id=product_id,
description=description,
max_product_display_name=max_product_display_name,
generic_value=generic_value,
odatavalue=odatavalue)
# Construct URL
url = '/model-flatten/customFlattening/parametergrouping/{name}/'
path_format_arguments = {
'name': self._serialize.url("name", name, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if simple_body_product is not None:
body_content = self._serialize.body(simple_body_product,
'SimpleProduct')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('SimpleProduct', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
class AutoRestResourceFlatteningTestService(object):
"""Resource Flattening for AutoRest
:param config: Configuration for client.
:type config: AutoRestResourceFlatteningTestServiceConfiguration
"""
def __init__(self, config):
self._client = ServiceClient(config.credentials, config)
client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
self._serialize = Serializer()
self._deserialize = Deserializer(client_models)
self.config = config
def put_array(
self, resource_array=None, custom_headers={}, raw=False, **operation_config):
"""
Put External Resource as an Array
:param resource_array: External Resource as an Array to put
:type resource_array: list or None
:param dict custom_headers: headers that will be added to the request
:param boolean raw: returns the direct response alongside the
deserialized response
:rtype: None or msrest.pipeline.ClientRawResponse
"""
# Construct URL
url = '/azure/resource-flatten/array'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct body
if resource_array is not None:
body_content = self._serialize.body(resource_array, '[Resource]')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_array(
self, custom_headers={}, raw=False, **operation_config):
"""
Get External Resource as an Array
:param dict custom_headers: headers that will be added to the request
:param boolean raw: returns the direct response alongside the
deserialized response
:rtype: list or msrest.pipeline.ClientRawResponse
"""
# Construct URL
url = '/azure/resource-flatten/array'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[FlattenedProduct]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_dictionary(
self, resource_dictionary=None, custom_headers={}, raw=False, **operation_config):
"""
Put External Resource as a Dictionary
:param resource_dictionary: External Resource as a Dictionary to put
:type resource_dictionary: dict or None
:param dict custom_headers: headers that will be added to the request
:param boolean raw: returns the direct response alongside the
deserialized response
:rtype: None or msrest.pipeline.ClientRawResponse
"""
# Construct URL
url = '/azure/resource-flatten/dictionary'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct body
if resource_dictionary is not None:
body_content = self._serialize.body(resource_dictionary, '{FlattenedProduct}')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_dictionary(
self, custom_headers={}, raw=False, **operation_config):
"""
Get External Resource as a Dictionary
:param dict custom_headers: headers that will be added to the request
:param boolean raw: returns the direct response alongside the
deserialized response
:rtype: dict or msrest.pipeline.ClientRawResponse
"""
# Construct URL
url = '/azure/resource-flatten/dictionary'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('{FlattenedProduct}', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_resource_collection(
self, resource_complex_object=None, custom_headers={}, raw=False, **operation_config):
"""
Put External Resource as a ResourceCollection
:param resource_complex_object: External Resource as a
ResourceCollection to put
:type resource_complex_object: ResourceCollection or None
:param dict custom_headers: headers that will be added to the request
:param boolean raw: returns the direct response alongside the
deserialized response
:rtype: None or msrest.pipeline.ClientRawResponse
"""
# Construct URL
url = '/azure/resource-flatten/resourcecollection'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct body
if resource_complex_object is not None:
body_content = self._serialize.body(resource_complex_object, 'ResourceCollection')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_resource_collection(
self, custom_headers={}, raw=False, **operation_config):
"""
Get External Resource as a ResourceCollection
:param dict custom_headers: headers that will be added to the request
:param boolean raw: returns the direct response alongside the
deserialized response
:rtype: ResourceCollection or msrest.pipeline.ClientRawResponse
"""
# Construct URL
url = '/azure/resource-flatten/resourcecollection'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('ResourceCollection', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
class SoftheonSwitchboard(object):
"""SoftheonSwitchboard
:ivar config: Configuration for client.
:vartype config: SoftheonSwitchboardConfiguration
:param str base_url: Service URL
"""
def __init__(
self, base_url=None):
self.config = SoftheonSwitchboardConfiguration(base_url)
self._client = ServiceClient(None, self.config)
client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
self.api_version = '1'
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def get_board_by_id(
self, id, custom_headers=None, raw=False, **operation_config):
"""Gets a board by the board id.
:param id: The identifier.
:type id: int
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: BoardModel or ClientRawResponse if raw=true
:rtype: ~swagger.models.BoardModel or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_board_by_id.metadata['url']
path_format_arguments = {
'id': self._serialize.url("id", id, 'int')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, stream=False, **operation_config)
if response.status_code not in [200, 400, 401, 403]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('BoardModel', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_board_by_id.metadata = {'url': '/v1/Board/{id}'}
def update_board(
self, id, model=None, custom_headers=None, raw=False, **operation_config):
"""Puts the specified model.
:param id: The identifier.
:type id: int
:param model: The model.
:type model: ~swagger.models.BoardPutModel
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.update_board.metadata['url']
path_format_arguments = {
'id': self._serialize.url("id", id, 'int')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json-patch+json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if model is not None:
body_content = self._serialize.body(model, 'BoardPutModel')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, stream=False, **operation_config)
if response.status_code not in [204, 400, 401, 403, 404]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
update_board.metadata = {'url': '/v1/Board/{id}'}
def delete_board(
self, id, custom_headers=None, raw=False, **operation_config):
"""Deletes the specified identifier.
:param id: The identifier.
:type id: int
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.delete_board.metadata['url']
path_format_arguments = {
'id': self._serialize.url("id", id, 'int')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.delete(url, query_parameters)
response = self._client.send(request, header_parameters, stream=False, **operation_config)
if response.status_code not in [204, 400, 401, 403, 404]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
delete_board.metadata = {'url': '/v1/Board/{id}'}
def get_all_boards(
self, custom_headers=None, raw=False, **operation_config):
"""Gets all boards.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: list or ClientRawResponse if raw=true
:rtype: list[~swagger.models.BoardModel] or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_all_boards.metadata['url']
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, stream=False, **operation_config)
if response.status_code not in [200, 400, 401, 403, 404]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[BoardModel]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_all_boards.metadata = {'url': '/v1/Board'}
def create_board(
self, model=None, custom_headers=None, raw=False, **operation_config):
"""Posts the specified model.
:param model: The model.
:type model: ~swagger.models.BoardPostModel
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: BoardModel or ClientRawResponse if raw=true
:rtype: ~swagger.models.BoardModel or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.create_board.metadata['url']
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json-patch+json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if model is not None:
body_content = self._serialize.body(model, 'BoardPostModel')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, stream=False, **operation_config)
if response.status_code not in [201, 400, 401, 403]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 201:
deserialized = self._deserialize('BoardModel', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
create_board.metadata = {'url': '/v1/Board'}
def get_all_board_history_for_the_account(
self, custom_headers=None, raw=False, **operation_config):
"""Gets all board history for account.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: list or ClientRawResponse if raw=true
:rtype: list[~swagger.models.BoardHistoryModel] or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_all_board_history_for_the_account.metadata['url']
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, stream=False, **operation_config)
if response.status_code not in [200, 400, 401, 403, 404]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[BoardHistoryModel]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_all_board_history_for_the_account.metadata = {'url': '/v1/Board/History'}
def get_board_history_by_id(
self, id, custom_headers=None, raw=False, **operation_config):
"""Gets the board history.
:param id: The identifier.
:type id: int
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: BoardHistoryModel or ClientRawResponse if raw=true
:rtype: ~swagger.models.BoardHistoryModel or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_board_history_by_id.metadata['url']
path_format_arguments = {
'id': self._serialize.url("id", id, 'int')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, stream=False, **operation_config)
if response.status_code not in [200, 400, 401, 403]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('BoardHistoryModel', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_board_history_by_id.metadata = {'url': '/v1/Board/History/{id}'}
def get_boards_by_filter(
self, model=None, custom_headers=None, raw=False, **operation_config):
"""Gets the boards by filter.
:param model: The model.
:type model: ~swagger.models.BoardFilterModel
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: list or ClientRawResponse if raw=true
:rtype: list[~swagger.models.BoardModel] or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_boards_by_filter.metadata['url']
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json-patch+json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if model is not None:
body_content = self._serialize.body(model, 'BoardFilterModel')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, stream=False, **operation_config)
if response.status_code not in [200, 401, 403]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[BoardModel]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_boards_by_filter.metadata = {'url': '/v1/Board/search'}
def get_switches_by_board_id(
self, board_id, custom_headers=None, raw=False, **operation_config):
"""Gets all switches associated with a specific board Id.
:param board_id: The board identifier.
:type board_id: int
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: list or ClientRawResponse if raw=true
:rtype: list[~swagger.models.SwitchModel] or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_switches_by_board_id.metadata['url']
path_format_arguments = {
'boardId': self._serialize.url("board_id", board_id, 'int')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, stream=False, **operation_config)
if response.status_code not in [200, 401, 403]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[SwitchModel]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_switches_by_board_id.metadata = {'url': '/v1/Board/{boardId}/Switch'}
def create_switch(
self, board_id, switch_post_model=None, custom_headers=None, raw=False, **operation_config):
"""Creates a new switch.
:param board_id: The board identifier.
:type board_id: int
:param switch_post_model: The switch model.
:type switch_post_model: ~swagger.models.SwitchPostModel
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: SwitchModel or ClientRawResponse if raw=true
:rtype: ~swagger.models.SwitchModel or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.create_switch.metadata['url']
path_format_arguments = {
'boardId': self._serialize.url("board_id", board_id, 'int')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json-patch+json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if switch_post_model is not None:
body_content = self._serialize.body(switch_post_model, 'SwitchPostModel')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, stream=False, **operation_config)
if response.status_code not in [201, 401, 403]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 201:
deserialized = self._deserialize('SwitchModel', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
create_switch.metadata = {'url': '/v1/Board/{boardId}/Switch'}
def get_switch(
self, id, board_id, custom_headers=None, raw=False, **operation_config):
"""Gets a specific switch by the switch Id.
:param id: The identifier.
:type id: int
:param board_id:
:type board_id: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: SwitchModel or ClientRawResponse if raw=true
:rtype: ~swagger.models.SwitchModel or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_switch.metadata['url']
path_format_arguments = {
'id': self._serialize.url("id", id, 'int'),
'boardId': self._serialize.url("board_id", board_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, stream=False, **operation_config)
if response.status_code not in [200, 401, 403, 404]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('SwitchModel', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_switch.metadata = {'url': '/v1/Board/{boardId}/Switch/{id}'}
def update_switch(
self, id, board_id, switch_put_model=None, custom_headers=None, raw=False, **operation_config):
"""Updates the switch and places the old version in the history table.
:param id: The identifier.
:type id: int
:param board_id:
:type board_id: str
:param switch_put_model: The switch model.
:type switch_put_model: ~swagger.models.SwitchPutModel
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.update_switch.metadata['url']
path_format_arguments = {
'id': self._serialize.url("id", id, 'int'),
'boardId': self._serialize.url("board_id", board_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json-patch+json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if switch_put_model is not None:
body_content = self._serialize.body(switch_put_model, 'SwitchPutModel')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, stream=False, **operation_config)
if response.status_code not in [204, 401, 403, 404]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
update_switch.metadata = {'url': '/v1/Board/{boardId}/Switch/{id}'}
def delete_switch_version(
self, id, board_id, custom_headers=None, raw=False, **operation_config):
"""Deletes a switch and place it in the history table.
:param id: The identifier.
:type id: int
:param board_id:
:type board_id: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.delete_switch_version.metadata['url']
path_format_arguments = {
'id': self._serialize.url("id", id, 'int'),
'boardId': self._serialize.url("board_id", board_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.delete(url, query_parameters)
response = self._client.send(request, header_parameters, stream=False, **operation_config)
if response.status_code not in [204, 401, 403, 404]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
delete_switch_version.metadata = {'url': '/v1/Board/{boardId}/Switch/{id}'}
def get_switch_history(
self, id, board_id, custom_headers=None, raw=False, **operation_config):
"""Gets a specific previous switch version.
:param id: The identifier.
:type id: int
:param board_id:
:type board_id: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: SwitchHistoryModel or ClientRawResponse if raw=true
:rtype: ~swagger.models.SwitchHistoryModel or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_switch_history.metadata['url']
path_format_arguments = {
'id': self._serialize.url("id", id, 'int'),
'boardId': self._serialize.url("board_id", board_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, stream=False, **operation_config)
if response.status_code not in [200, 401, 403, 404]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('SwitchHistoryModel', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_switch_history.metadata = {'url': '/v1/Board/{boardId}/Switch/History/{id}'}
def get_all_switch_history_by_board(
self, board_id, custom_headers=None, raw=False, **operation_config):
"""Gets all of the previous switches for a board.
:param board_id: The board identifier.
:type board_id: int
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: list or ClientRawResponse if raw=true
:rtype: list[~swagger.models.SwitchHistoryModel] or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_all_switch_history_by_board.metadata['url']
path_format_arguments = {
'boardId': self._serialize.url("board_id", board_id, 'int')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, stream=False, **operation_config)
if response.status_code not in [200, 401, 403]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[SwitchHistoryModel]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_all_switch_history_by_board.metadata = {'url': '/v1/Board/{boardId}/Switch/History'}
def get_all_switch_history_by_switch(
self, switch_id, board_id, custom_headers=None, raw=False, **operation_config):
"""Gets all of the previous switches for a switch.
:param switch_id: The switch identifier.
:type switch_id: int
:param board_id:
:type board_id: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: list or ClientRawResponse if raw=true
:rtype: list[~swagger.models.SwitchHistoryModel] or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_all_switch_history_by_switch.metadata['url']
path_format_arguments = {
'switchId': self._serialize.url("switch_id", switch_id, 'int'),
'boardId': self._serialize.url("board_id", board_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, stream=False, **operation_config)
if response.status_code not in [200, 401, 403]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[SwitchHistoryModel]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_all_switch_history_by_switch.metadata = {'url': '/v1/Board/{boardId}/Switch/{switchId}/History'}
def get_switches_by_filter(
self, board_id, model=None, custom_headers=None, raw=False, **operation_config):
"""Gets the users by filter.
:param board_id: The board identifier.
:type board_id: int
:param model: The model.
:type model: ~swagger.models.SwitchFilterModel
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: list or ClientRawResponse if raw=true
:rtype: list[~swagger.models.SwitchModel] or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_switches_by_filter.metadata['url']
path_format_arguments = {
'boardId': self._serialize.url("board_id", board_id, 'int')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json-patch+json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if model is not None:
body_content = self._serialize.body(model, 'SwitchFilterModel')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, stream=False, **operation_config)
if response.status_code not in [200, 401, 403]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[SwitchModel]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_switches_by_filter.metadata = {'url': '/v1/Board/{boardId}/Switch/search'}
def rollback_switch(
self, switch_id, switch_history_id, board_id, custom_headers=None, raw=False, **operation_config):
"""Rollback to a previous switch.
:param switch_id: The switch identifier.
:type switch_id: int
:param switch_history_id: The switch history identifier.
:type switch_history_id: int
:param board_id:
:type board_id: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.rollback_switch.metadata['url']
path_format_arguments = {
'switchId': self._serialize.url("switch_id", switch_id, 'int'),
'switchHistoryId': self._serialize.url("switch_history_id", switch_history_id, 'int'),
'boardId': self._serialize.url("board_id", board_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, stream=False, **operation_config)
if response.status_code not in [204, 401, 403, 404]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
rollback_switch.metadata = {'url': '/v1/Board/{boardId}/Switch/{switchId}/history/{switchHistoryId}'}
class SwaggerPetstore(object):
"""This is a sample server Petstore server. You can find out more about Swagger at <a href="http://swagger.io">http://swagger.io</a> or on irc.freenode.net, #swagger. For this sample, you can use the api key "special-key" to test the authorization filters
:ivar config: Configuration for client.
:vartype config: SwaggerPetstoreConfiguration
:param str base_url: Service URL
"""
def __init__(self, base_url=None):
self.config = SwaggerPetstoreConfiguration(base_url)
self._client = ServiceClient(None, self.config)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def add_pet_using_byte_array(self,
body=None,
custom_headers=None,
raw=False,
**operation_config):
"""Fake endpoint to test byte array in body parameter for adding a new pet
to the store.
:param body: Pet object in the form of byte array
:type body: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/pet'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'str')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [405]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def add_pet(self,
body=None,
custom_headers=None,
raw=False,
**operation_config):
"""Add a new pet to the store.
Adds a new pet to the store. You may receive an HTTP invalid input if
your pet is invalid.
:param body: Pet object that needs to be added to the store
:type body: :class:`Pet <petstore.models.Pet>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/pet'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'Pet')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [405]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def update_pet(self,
body=None,
custom_headers=None,
raw=False,
**operation_config):
"""Update an existing pet.
:param body: Pet object that needs to be added to the store
:type body: :class:`Pet <petstore.models.Pet>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/pet'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'Pet')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [405, 404, 400]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def find_pets_by_status(self,
status=None,
custom_headers=None,
raw=False,
**operation_config):
"""Finds Pets by status.
Multiple status values can be provided with comma seperated strings.
:param status: Status values that need to be considered for filter
:type status: list of str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: list of :class:`Pet <petstore.models.Pet>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/pet/findByStatus'
# Construct parameters
query_parameters = {}
if status is not None:
query_parameters['status'] = self._serialize.query("status",
status,
'[str]',
div=',')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[Pet]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def find_pets_by_tags(self,
tags=None,
custom_headers=None,
raw=False,
**operation_config):
"""Finds Pets by tags.
Muliple tags can be provided with comma seperated strings. Use tag1,
tag2, tag3 for testing.
:param tags: Tags to filter by
:type tags: list of str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: list of :class:`Pet <petstore.models.Pet>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/pet/findByTags'
# Construct parameters
query_parameters = {}
if tags is not None:
query_parameters['tags'] = self._serialize.query("tags",
tags,
'[str]',
div=',')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[Pet]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def find_pets_with_byte_array(self,
pet_id,
custom_headers=None,
raw=False,
**operation_config):
"""Fake endpoint to test byte array return by 'Find pet by ID'.
Returns a pet when ID < 10. ID > 10 or nonintegers will simulate API
error conditions.
:param pet_id: ID of pet that needs to be fetched
:type pet_id: long
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: str
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/pet/{petId}'
path_format_arguments = {
'petId': self._serialize.url("pet_id", pet_id, 'long')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [404, 200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('str', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def get_pet_by_id(self,
pet_id,
custom_headers=None,
raw=False,
**operation_config):
"""Find pet by ID.
Returns a pet when ID < 10. ID > 10 or nonintegers will simulate API
error conditions.
:param pet_id: ID of pet that needs to be fetched
:type pet_id: long
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`Pet <petstore.models.Pet>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/pet/{petId}'
path_format_arguments = {
'petId': self._serialize.url("pet_id", pet_id, 'long')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [404, 200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Pet', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def update_pet_with_form(self,
pet_id,
name=None,
status=None,
custom_headers=None,
raw=False,
**operation_config):
"""Updates a pet in the store with form data.
:param pet_id: ID of pet that needs to be updated
:type pet_id: str
:param name: Updated name of the pet
:type name: str
:param status: Updated status of the pet
:type status: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/pet/{petId}'
path_format_arguments = {
'petId': self._serialize.url("pet_id", pet_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/x-www-form-urlencoded'
if custom_headers:
header_parameters.update(custom_headers)
# Construct form data
form_data_content = {
'name': name,
'status': status,
}
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send_formdata(request, header_parameters,
form_data_content,
**operation_config)
if response.status_code not in [405]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def delete_pet(self,
pet_id,
api_key=None,
custom_headers=None,
raw=False,
**operation_config):
"""Deletes a pet.
:param pet_id: Pet id to delete
:type pet_id: long
:param api_key:
:type api_key: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/pet/{petId}'
path_format_arguments = {
'petId': self._serialize.url("pet_id", pet_id, 'long')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
if api_key is not None:
header_parameters['api_key'] = self._serialize.header(
"api_key", api_key, 'str')
# Construct and send request
request = self._client.delete(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [400]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def upload_file(self,
pet_id,
additional_metadata=None,
file=None,
custom_headers=None,
raw=False,
**operation_config):
"""uploads an image.
:param pet_id: ID of pet to update
:type pet_id: long
:param additional_metadata: Additional data to pass to server
:type additional_metadata: str
:param file: file to upload
:type file: Generator
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/pet/{petId}/uploadImage'
path_format_arguments = {
'petId': self._serialize.url("pet_id", pet_id, 'long')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'multipart/form-data'
if custom_headers:
header_parameters.update(custom_headers)
# Construct form data
form_data_content = {
'additionalMetadata': additional_metadata,
'file': file,
}
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send_formdata(request, header_parameters,
form_data_content,
**operation_config)
if response.status_code < 200 or response.status_code >= 300:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_inventory(self,
custom_headers=None,
raw=False,
**operation_config):
"""Returns pet inventories by status.
Returns a map of status codes to quantities.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: dict
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/store/inventory'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('{int}', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def place_order(self,
body=None,
custom_headers=None,
raw=False,
**operation_config):
"""Place an order for a pet.
:param body: order placed for purchasing the pet
:type body: :class:`Order <petstore.models.Order>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`Order <petstore.models.Order>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/store/order'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'Order')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Order', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def get_order_by_id(self,
order_id,
custom_headers=None,
raw=False,
**operation_config):
"""Find purchase order by ID.
For valid response try integer IDs with value <= 5 or > 10. Other
values will generated exceptions.
:param order_id: ID of pet that needs to be fetched
:type order_id: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`Order <petstore.models.Order>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/store/order/{orderId}'
path_format_arguments = {
'orderId': self._serialize.url("order_id", order_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [404, 200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Order', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def delete_order(self,
order_id,
custom_headers=None,
raw=False,
**operation_config):
"""Delete purchase order by ID.
For valid response try integer IDs with value < 1000. Anything above
1000 or nonintegers will generate API errors.
:param order_id: ID of the order that needs to be deleted
:type order_id: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/store/order/{orderId}'
path_format_arguments = {
'orderId': self._serialize.url("order_id", order_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.delete(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [404, 400]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def create_user(self,
body=None,
custom_headers=None,
raw=False,
**operation_config):
"""Create user.
This can only be done by the logged in user.
:param body: Created user object
:type body: :class:`User <petstore.models.User>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/user'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'User')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code < 200 or response.status_code >= 300:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def create_users_with_array_input(self,
body=None,
custom_headers=None,
raw=False,
**operation_config):
"""Creates list of users with given input array.
:param body: List of user object
:type body: list of :class:`User <petstore.models.User>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/user/createWithArray'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, '[User]')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code < 200 or response.status_code >= 300:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def create_users_with_list_input(self,
body=None,
custom_headers=None,
raw=False,
**operation_config):
"""Creates list of users with given input array.
:param body: List of user object
:type body: list of :class:`User <petstore.models.User>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/user/createWithList'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, '[User]')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code < 200 or response.status_code >= 300:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def login_user(self,
username=None,
password=None,
custom_headers=None,
raw=False,
**operation_config):
"""Logs user into the system.
:param username: The user name for login
:type username: str
:param password: The password for login in clear text
:type password: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: str
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/user/login'
# Construct parameters
query_parameters = {}
if username is not None:
query_parameters['username'] = self._serialize.query(
"username", username, 'str')
if password is not None:
query_parameters['password'] = self._serialize.query(
"password", password, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('str', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def logout_user(self, custom_headers=None, raw=False, **operation_config):
"""Logs out current logged in user session.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/user/logout'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code < 200 or response.status_code >= 300:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_user_by_name(self,
username,
custom_headers=None,
raw=False,
**operation_config):
"""Get user by user name.
:param username: The name that needs to be fetched. Use user1 for
testing.
:type username: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`User <petstore.models.User>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/user/{username}'
path_format_arguments = {
'username': self._serialize.url("username", username, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [404, 200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('User', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def update_user(self,
username,
body=None,
custom_headers=None,
raw=False,
**operation_config):
"""Updated user.
This can only be done by the logged in user.
:param username: name that need to be deleted
:type username: str
:param body: Updated user object
:type body: :class:`User <petstore.models.User>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/user/{username}'
path_format_arguments = {
'username': self._serialize.url("username", username, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'User')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [404, 400]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def delete_user(self,
username,
custom_headers=None,
raw=False,
**operation_config):
"""Delete user.
This can only be done by the logged in user.
:param username: The name that needs to be deleted
:type username: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = '/user/{username}'
path_format_arguments = {
'username': self._serialize.url("username", username, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.delete(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [404, 400]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
class SwaggerPetstore(object):
"""This is a sample server Petstore server. You can find out more about Swagger at <a href="http://swagger.io">http://swagger.io</a> or on irc.freenode.net, #swagger. For this sample, you can use the api key "special-key" to test the authorization filters
:ivar config: Configuration for client.
:vartype config: SwaggerPetstoreConfiguration
:param str base_url: Service URL
:param str filepath: Existing config
"""
def __init__(
self, base_url=None, filepath=None):
self.config = SwaggerPetstoreConfiguration(base_url, filepath)
self._client = ServiceClient(None, self.config)
client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def add_pet_using_byte_array(
self, body=None, custom_headers=None, raw=False, **operation_config):
"""Fake endpoint to test byte array in body parameter for adding a new
pet to the store.
:param body: Pet object in the form of byte array
:type body: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/pet'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'str')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [405]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def add_pet(
self, body=None, custom_headers=None, raw=False, **operation_config):
"""Add a new pet to the store.
Adds a new pet to the store. You may receive an HTTP invalid input if
your pet is invalid.
:param body: Pet object that needs to be added to the store
:type body: :class:`Pet <Petstore.models.Pet>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/pet'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'Pet')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [405]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def update_pet(
self, body=None, custom_headers=None, raw=False, **operation_config):
"""Update an existing pet.
:param body: Pet object that needs to be added to the store
:type body: :class:`Pet <Petstore.models.Pet>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/pet'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'Pet')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [405, 404, 400]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def find_pets_by_status(
self, status=None, custom_headers=None, raw=False, **operation_config):
"""Finds Pets by status.
Multiple status values can be provided with comma seperated strings.
:param status: Status values that need to be considered for filter
:type status: list of str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: list of :class:`Pet <Petstore.models.Pet>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/pet/findByStatus'
# Construct parameters
query_parameters = {}
if status is not None:
query_parameters['status'] = self._serialize.query("status", status, '[str]', div=',')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[Pet]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def find_pets_by_tags(
self, tags=None, custom_headers=None, raw=False, **operation_config):
"""Finds Pets by tags.
Muliple tags can be provided with comma seperated strings. Use tag1,
tag2, tag3 for testing.
:param tags: Tags to filter by
:type tags: list of str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: list of :class:`Pet <Petstore.models.Pet>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/pet/findByTags'
# Construct parameters
query_parameters = {}
if tags is not None:
query_parameters['tags'] = self._serialize.query("tags", tags, '[str]', div=',')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[Pet]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def find_pets_with_byte_array(
self, pet_id, custom_headers=None, raw=False, **operation_config):
"""Fake endpoint to test byte array return by 'Find pet by ID'.
Returns a pet when ID < 10. ID > 10 or nonintegers will simulate API
error conditions.
:param pet_id: ID of pet that needs to be fetched
:type pet_id: long
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: str
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/pet/{petId}'
path_format_arguments = {
'petId': self._serialize.url("pet_id", pet_id, 'long')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [404, 200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('str', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def get_pet_by_id(
self, pet_id, custom_headers=None, raw=False, **operation_config):
"""Find pet by ID.
Returns a pet when ID < 10. ID > 10 or nonintegers will simulate API
error conditions.
:param pet_id: ID of pet that needs to be fetched
:type pet_id: long
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`Pet <Petstore.models.Pet>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/pet/{petId}'
path_format_arguments = {
'petId': self._serialize.url("pet_id", pet_id, 'long')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [404, 200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Pet', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def update_pet_with_form(
self, pet_id, name=None, status=None, custom_headers=None, raw=False, **operation_config):
"""Updates a pet in the store with form data.
:param pet_id: ID of pet that needs to be updated
:type pet_id: str
:param name: Updated name of the pet
:type name: str
:param status: Updated status of the pet
:type status: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/pet/{petId}'
path_format_arguments = {
'petId': self._serialize.url("pet_id", pet_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/x-www-form-urlencoded'
if custom_headers:
header_parameters.update(custom_headers)
# Construct form data
form_data_content = {
'name': name,
'status': status,
}
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send_formdata(
request, header_parameters, form_data_content, **operation_config)
if response.status_code not in [405]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def delete_pet(
self, pet_id, api_key=None, custom_headers=None, raw=False, **operation_config):
"""Deletes a pet.
:param pet_id: Pet id to delete
:type pet_id: long
:param api_key:
:type api_key: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/pet/{petId}'
path_format_arguments = {
'petId': self._serialize.url("pet_id", pet_id, 'long')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
if api_key is not None:
header_parameters['api_key'] = self._serialize.header("api_key", api_key, 'str')
# Construct and send request
request = self._client.delete(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [400]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def upload_file(
self, pet_id, additional_metadata=None, file=None, custom_headers=None, raw=False, **operation_config):
"""uploads an image.
:param pet_id: ID of pet to update
:type pet_id: long
:param additional_metadata: Additional data to pass to server
:type additional_metadata: str
:param file: file to upload
:type file: Generator
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/pet/{petId}/uploadImage'
path_format_arguments = {
'petId': self._serialize.url("pet_id", pet_id, 'long')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'multipart/form-data'
if custom_headers:
header_parameters.update(custom_headers)
# Construct form data
form_data_content = {
'additionalMetadata': additional_metadata,
'file': file,
}
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send_formdata(
request, header_parameters, form_data_content, **operation_config)
if response.status_code < 200 or response.status_code >= 300:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_inventory(
self, custom_headers=None, raw=False, **operation_config):
"""Returns pet inventories by status.
Returns a map of status codes to quantities.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: dict
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/store/inventory'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('{int}', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def place_order(
self, body=None, custom_headers=None, raw=False, **operation_config):
"""Place an order for a pet.
:param body: order placed for purchasing the pet
:type body: :class:`Order <Petstore.models.Order>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`Order <Petstore.models.Order>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/store/order'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'Order')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Order', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def get_order_by_id(
self, order_id, custom_headers=None, raw=False, **operation_config):
"""Find purchase order by ID.
For valid response try integer IDs with value <= 5 or > 10. Other
values will generated exceptions.
:param order_id: ID of pet that needs to be fetched
:type order_id: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`Order <Petstore.models.Order>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/store/order/{orderId}'
path_format_arguments = {
'orderId': self._serialize.url("order_id", order_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [404, 200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Order', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def delete_order(
self, order_id, custom_headers=None, raw=False, **operation_config):
"""Delete purchase order by ID.
For valid response try integer IDs with value < 1000. Anything above
1000 or nonintegers will generate API errors.
:param order_id: ID of the order that needs to be deleted
:type order_id: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/store/order/{orderId}'
path_format_arguments = {
'orderId': self._serialize.url("order_id", order_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.delete(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [404, 400]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def create_user(
self, body=None, custom_headers=None, raw=False, **operation_config):
"""Create user.
This can only be done by the logged in user.
:param body: Created user object
:type body: :class:`User <Petstore.models.User>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/user'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'User')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code < 200 or response.status_code >= 300:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def create_users_with_array_input(
self, body=None, custom_headers=None, raw=False, **operation_config):
"""Creates list of users with given input array.
:param body: List of user object
:type body: list of :class:`User <Petstore.models.User>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/user/createWithArray'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, '[User]')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code < 200 or response.status_code >= 300:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def create_users_with_list_input(
self, body=None, custom_headers=None, raw=False, **operation_config):
"""Creates list of users with given input array.
:param body: List of user object
:type body: list of :class:`User <Petstore.models.User>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/user/createWithList'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, '[User]')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code < 200 or response.status_code >= 300:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def login_user(
self, username=None, password=None, custom_headers=None, raw=False, **operation_config):
"""Logs user into the system.
:param username: The user name for login
:type username: str
:param password: The password for login in clear text
:type password: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: str
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/user/login'
# Construct parameters
query_parameters = {}
if username is not None:
query_parameters['username'] = self._serialize.query("username", username, 'str')
if password is not None:
query_parameters['password'] = self._serialize.query("password", password, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('str', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def logout_user(
self, custom_headers=None, raw=False, **operation_config):
"""Logs out current logged in user session.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/user/logout'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code < 200 or response.status_code >= 300:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_user_by_name(
self, username, custom_headers=None, raw=False, **operation_config):
"""Get user by user name.
:param username: The name that needs to be fetched. Use user1 for
testing.
:type username: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`User <Petstore.models.User>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/user/{username}'
path_format_arguments = {
'username': self._serialize.url("username", username, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [404, 200, 400]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('User', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def update_user(
self, username, body=None, custom_headers=None, raw=False, **operation_config):
"""Updated user.
This can only be done by the logged in user.
:param username: name that need to be deleted
:type username: str
:param body: Updated user object
:type body: :class:`User <Petstore.models.User>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/user/{username}'
path_format_arguments = {
'username': self._serialize.url("username", username, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'User')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [404, 400]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def delete_user(
self, username, custom_headers=None, raw=False, **operation_config):
"""Delete user.
This can only be done by the logged in user.
:param username: The name that needs to be deleted
:type username: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/user/{username}'
path_format_arguments = {
'username': self._serialize.url("username", username, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.delete(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [404, 400]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
class AutoRestResourceFlatteningTestService(object):
"""Resource Flattening for AutoRest
:ivar config: Configuration for client.
:vartype config: AutoRestResourceFlatteningTestServiceConfiguration
:param credentials: Credentials needed for the client to connect to Azure.
:type credentials: :mod:`A msrestazure Credentials
object<msrestazure.azure_active_directory>`
:param str base_url: Service URL
"""
def __init__(self, credentials, base_url=None):
self.config = AutoRestResourceFlatteningTestServiceConfiguration(
credentials, base_url)
self._client = ServiceClient(self.config.credentials, self.config)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self.api_version = '1.0.0'
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def put_array(self,
resource_array=None,
custom_headers=None,
raw=False,
**operation_config):
"""Put External Resource as an Array.
:param resource_array: External Resource as an Array to put
:type resource_array: list[~azureresource.models.Resource]
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises: :class:`ErrorException<azureresource.models.ErrorException>`
"""
# Construct URL
url = self.put_array.metadata['url']
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
if resource_array is not None:
body_content = self._serialize.body(resource_array, '[Resource]')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request,
header_parameters,
body_content,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
put_array.metadata = {'url': '/azure/resource-flatten/array'}
def get_array(self, custom_headers=None, raw=False, **operation_config):
"""Get External Resource as an Array.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: list or ClientRawResponse if raw=true
:rtype: list[~azureresource.models.FlattenedProduct] or
~msrest.pipeline.ClientRawResponse
:raises: :class:`ErrorException<azureresource.models.ErrorException>`
"""
# Construct URL
url = self.get_array.metadata['url']
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[FlattenedProduct]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_array.metadata = {'url': '/azure/resource-flatten/array'}
def put_dictionary(self,
resource_dictionary=None,
custom_headers=None,
raw=False,
**operation_config):
"""Put External Resource as a Dictionary.
:param resource_dictionary: External Resource as a Dictionary to put
:type resource_dictionary: dict[str,
~azureresource.models.FlattenedProduct]
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises: :class:`ErrorException<azureresource.models.ErrorException>`
"""
# Construct URL
url = self.put_dictionary.metadata['url']
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
if resource_dictionary is not None:
body_content = self._serialize.body(resource_dictionary,
'{FlattenedProduct}')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request,
header_parameters,
body_content,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
put_dictionary.metadata = {'url': '/azure/resource-flatten/dictionary'}
def get_dictionary(self,
custom_headers=None,
raw=False,
**operation_config):
"""Get External Resource as a Dictionary.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: dict or ClientRawResponse if raw=true
:rtype: dict[str, ~azureresource.models.FlattenedProduct] or
~msrest.pipeline.ClientRawResponse
:raises: :class:`ErrorException<azureresource.models.ErrorException>`
"""
# Construct URL
url = self.get_dictionary.metadata['url']
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('{FlattenedProduct}', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_dictionary.metadata = {'url': '/azure/resource-flatten/dictionary'}
def put_resource_collection(self,
resource_complex_object=None,
custom_headers=None,
raw=False,
**operation_config):
"""Put External Resource as a ResourceCollection.
:param resource_complex_object: External Resource as a
ResourceCollection to put
:type resource_complex_object:
~azureresource.models.ResourceCollection
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises: :class:`ErrorException<azureresource.models.ErrorException>`
"""
# Construct URL
url = self.put_resource_collection.metadata['url']
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
if resource_complex_object is not None:
body_content = self._serialize.body(resource_complex_object,
'ResourceCollection')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request,
header_parameters,
body_content,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
put_resource_collection.metadata = {
'url': '/azure/resource-flatten/resourcecollection'
}
def get_resource_collection(self,
custom_headers=None,
raw=False,
**operation_config):
"""Get External Resource as a ResourceCollection.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: ResourceCollection or ClientRawResponse if raw=true
:rtype: ~azureresource.models.ResourceCollection or
~msrest.pipeline.ClientRawResponse
:raises: :class:`ErrorException<azureresource.models.ErrorException>`
"""
# Construct URL
url = self.get_resource_collection.metadata['url']
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('ResourceCollection', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_resource_collection.metadata = {
'url': '/azure/resource-flatten/resourcecollection'
}
class AutoRestValidationTest(object):
"""Test Infrastructure for AutoRest. No server backend exists for these tests.
:param config: Configuration for client.
:type config: AutoRestValidationTestConfiguration
"""
def __init__(self, config):
self._client = ServiceClient(None, config)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer()
self._deserialize = Deserializer(client_models)
self.config = config
def validation_of_method_parameters(self,
resource_group_name,
id,
custom_headers={},
raw=False,
**operation_config):
"""
Validates input parameters on the method. See swagger for details.
:param resource_group_name: Required string between 3 and 10 chars
with pattern [a-zA-Z0-9]+.
:type resource_group_name: str
:param id: Required int multiple of 10 from 100 to 1000.
:type id: int
:param dict custom_headers: headers that will be added to the request
:param boolean raw: returns the direct response alongside the
deserialized response
:rtype: Product or msrest.pipeline.ClientRawResponse
"""
# Construct URL
url = '/fakepath/{subscriptionId}/{resourceGroupName}/{id}'
path_format_arguments = {
'subscriptionId':
self._serialize.url("self.config.subscription_id",
self.config.subscription_id, 'str'),
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'id':
self._serialize.url("id", id, 'int')
}
url = url.format(**path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['apiVersion'] = self._serialize.query(
"self.config.api_version", self.config.api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Product', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def validation_of_body(self,
resource_group_name,
id,
body=None,
custom_headers={},
raw=False,
**operation_config):
"""
Validates body parameters on the method. See swagger for details.
:param resource_group_name: Required string between 3 and 10 chars
with pattern [a-zA-Z0-9]+.
:type resource_group_name: str
:param id: Required int multiple of 10 from 100 to 1000.
:type id: int
:param body:
:type body: Product or None
:param dict custom_headers: headers that will be added to the request
:param boolean raw: returns the direct response alongside the
deserialized response
:rtype: Product or msrest.pipeline.ClientRawResponse
"""
# Construct URL
url = '/fakepath/{subscriptionId}/{resourceGroupName}/{id}'
path_format_arguments = {
'subscriptionId':
self._serialize.url("self.config.subscription_id",
self.config.subscription_id, 'str'),
'resourceGroupName':
self._serialize.url("resource_group_name", resource_group_name,
'str'),
'id':
self._serialize.url("id", id, 'int')
}
url = url.format(**path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['apiVersion'] = self._serialize.query(
"self.config.api_version", self.config.api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'Product')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Product', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def get_with_constant_in_path(self,
constant_param,
custom_headers={},
raw=False,
**operation_config):
"""
:param constant_param:
:type constant_param: str
:param dict custom_headers: headers that will be added to the request
:param boolean raw: returns the direct response alongside the
deserialized response
:rtype: None or msrest.pipeline.ClientRawResponse
"""
# Construct URL
url = '/validation/constantsInPath/{constantParam}/value'
path_format_arguments = {
'constantParam':
self._serialize.url("constant_param", constant_param, 'str')
}
url = url.format(**path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def post_with_constant_in_body(self,
constant_param,
body=None,
custom_headers={},
raw=False,
**operation_config):
"""
:param constant_param:
:type constant_param: str
:param body:
:type body: Product or None
:param dict custom_headers: headers that will be added to the request
:param boolean raw: returns the direct response alongside the
deserialized response
:rtype: Product or msrest.pipeline.ClientRawResponse
"""
# Construct URL
url = '/validation/constantsInPath/{constantParam}/value'
path_format_arguments = {
'constantParam':
self._serialize.url("constant_param", constant_param, 'str')
}
url = url.format(**path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'Product')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Product', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
class AzureOpcPublisherClient(object):
"""Azure Industrial IoT OPC UA Publisher Service
:ivar config: Configuration for client.
:vartype config: AzureOpcPublisherClientConfiguration
:param credentials: Subscription credentials which uniquely identify
client subscription.
:type credentials: None
:param str base_url: Service URL
"""
def __init__(self, credentials, base_url=None):
self.config = AzureOpcPublisherClientConfiguration(
credentials, base_url)
self._client = ServiceClient(self.config.credentials, self.config)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self.api_version = 'v2'
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def subscribe(self,
endpoint_id,
body=None,
custom_headers=None,
raw=False,
**operation_config):
"""Subscribe to receive samples.
Register a client to receive publisher samples through SignalR.
:param endpoint_id: The endpoint to subscribe to
:type endpoint_id: str
:param body: The user id that will receive publisher samples.
:type body: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.subscribe.metadata['url']
path_format_arguments = {
'endpointId': self._serialize.url("endpoint_id", endpoint_id,
'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters[
'Content-Type'] = 'application/json-patch+json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'str')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request,
header_parameters,
body_content,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
subscribe.metadata = {'url': '/v2/monitor/{endpointId}/samples'}
def unsubscribe(self,
endpoint_id,
user_id,
custom_headers=None,
raw=False,
**operation_config):
"""Unsubscribe from receiving samples.
Unregister a client and stop it from receiving samples.
:param endpoint_id: The endpoint to unsubscribe from
:type endpoint_id: str
:param user_id: The user id that will not receive any more published
samples
:type user_id: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.unsubscribe.metadata['url']
path_format_arguments = {
'endpointId': self._serialize.url("endpoint_id", endpoint_id,
'str'),
'userId': self._serialize.url("user_id", user_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.delete(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
unsubscribe.metadata = {'url': '/v2/monitor/{endpointId}/samples/{userId}'}
def start_publishing_values(self,
endpoint_id,
body,
custom_headers=None,
raw=False,
**operation_config):
"""Start publishing node values.
Start publishing variable node values to IoT Hub. The endpoint must be
activated and connected and the module client and server must trust
each other.
:param endpoint_id: The identifier of the activated endpoint.
:type endpoint_id: str
:param body: The publish request
:type body:
~azure-iiot-opc-publisher.models.PublishStartRequestApiModel
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: PublishStartResponseApiModel or ClientRawResponse if raw=true
:rtype: ~azure-iiot-opc-publisher.models.PublishStartResponseApiModel
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.start_publishing_values.metadata['url']
path_format_arguments = {
'endpointId': self._serialize.url("endpoint_id", endpoint_id,
'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters[
'Content-Type'] = 'application/json-patch+json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
body_content = self._serialize.body(body,
'PublishStartRequestApiModel')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request,
header_parameters,
body_content,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('PublishStartResponseApiModel',
response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
start_publishing_values.metadata = {
'url': '/v2/publish/{endpointId}/start'
}
def stop_publishing_values(self,
endpoint_id,
body,
custom_headers=None,
raw=False,
**operation_config):
"""Stop publishing node values.
Stop publishing variable node values to IoT Hub. The endpoint must be
activated and connected and the module client and server must trust
each other.
:param endpoint_id: The identifier of the activated endpoint.
:type endpoint_id: str
:param body: The unpublish request
:type body:
~azure-iiot-opc-publisher.models.PublishStopRequestApiModel
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: PublishStopResponseApiModel or ClientRawResponse if raw=true
:rtype: ~azure-iiot-opc-publisher.models.PublishStopResponseApiModel
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.stop_publishing_values.metadata['url']
path_format_arguments = {
'endpointId': self._serialize.url("endpoint_id", endpoint_id,
'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters[
'Content-Type'] = 'application/json-patch+json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
body_content = self._serialize.body(body, 'PublishStopRequestApiModel')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request,
header_parameters,
body_content,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('PublishStopResponseApiModel',
response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
stop_publishing_values.metadata = {'url': '/v2/publish/{endpointId}/stop'}
def get_first_list_of_published_nodes(self,
endpoint_id,
body,
custom_headers=None,
raw=False,
**operation_config):
"""Get currently published nodes.
Returns currently published node ids for an endpoint. The endpoint must
be activated and connected and the module client and server must trust
each other.
:param endpoint_id: The identifier of the activated endpoint.
:type endpoint_id: str
:param body: The list request
:type body:
~azure-iiot-opc-publisher.models.PublishedItemListRequestApiModel
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: PublishedItemListResponseApiModel or ClientRawResponse if
raw=true
:rtype:
~azure-iiot-opc-publisher.models.PublishedItemListResponseApiModel or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_first_list_of_published_nodes.metadata['url']
path_format_arguments = {
'endpointId': self._serialize.url("endpoint_id", endpoint_id,
'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters[
'Content-Type'] = 'application/json-patch+json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
body_content = self._serialize.body(
body, 'PublishedItemListRequestApiModel')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request,
header_parameters,
body_content,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize(
'PublishedItemListResponseApiModel', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_first_list_of_published_nodes.metadata = {
'url': '/v2/publish/{endpointId}'
}
def get_next_list_of_published_nodes(self,
endpoint_id,
continuation_token,
custom_headers=None,
raw=False,
**operation_config):
"""Get next set of published nodes.
Returns next set of currently published node ids for an endpoint. The
endpoint must be activated and connected and the module client and
server must trust each other.
:param endpoint_id: The identifier of the activated endpoint.
:type endpoint_id: str
:param continuation_token: The continuation token to continue with
:type continuation_token: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: PublishedItemListResponseApiModel or ClientRawResponse if
raw=true
:rtype:
~azure-iiot-opc-publisher.models.PublishedItemListResponseApiModel or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_next_list_of_published_nodes.metadata['url']
path_format_arguments = {
'endpointId': self._serialize.url("endpoint_id", endpoint_id,
'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['continuationToken'] = self._serialize.query(
"continuation_token", continuation_token, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize(
'PublishedItemListResponseApiModel', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_next_list_of_published_nodes.metadata = {
'url': '/v2/publish/{endpointId}'
}
class DeviceTwinAPI(object):
"""Use this REST API to manage device twins in the identity registry of an IoT hub.
This API enables you to create and update device twins and invoke direct methods on devices.
Each API call must include the api-version query parameter as well the authorization header
containing a Shared Access Signature token with the appropriate permissions.
:ivar config: Configuration for client.
:vartype config: DeviceTwinAPIConfiguration
:param credentials: Credentials needed for the client to connect to Azure.
:type credentials: :mod:`A msrestazure Credentials
object<msrestazure.azure_active_directory>`
:param str base_url: Service URL
"""
def __init__(self, credentials, base_url=None):
self.config = DeviceTwinAPIConfiguration(credentials, base_url)
self._client = ServiceClient(self.config.credentials, self.config)
self.api_version = "2017-11-08-preview"
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def get_device_twin(self,
deviceid,
custom_headers=None,
raw=False,
**operation_config):
"""Get a device twin.
Get a device twin. See
https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-device-twins
for more information.
:param deviceid:
:type deviceid: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: :class:`DeviceTwinInfo <device_twin.models.DeviceTwinInfo>`
or :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>` if
raw=true
:rtype: :class:`DeviceTwinInfo <device_twin.models.DeviceTwinInfo>` or
:class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
# Construct URL
url = '/twins/{id}'
path_format_arguments = {
'id': self._serialize.url("id", deviceid, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"self.api_version", self.api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise models.error_details.ErrorDetailsException(
self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('object', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def update_device_twin(self,
deviceid,
device_twin_info,
custom_headers=None,
raw=False,
**operation_config):
"""Updates tags and desired properties of a device twin.
Update a device twin. See
https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-device-twins
for more information.
:param deviceid:
:type deviceid: str
:param device_twin_info:
:type device_twin_info: :class:`DeviceTwinInfo
<device_twin.models.DeviceTwinInfo>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: :class:`DeviceTwinInfo <device_twin.models.DeviceTwinInfo>`
or :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>` if
raw=true
:rtype: :class:`DeviceTwinInfo <device_twin.models.DeviceTwinInfo>` or
:class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
# Construct URL
url = '/twins/{id}'
path_format_arguments = {
'id': self._serialize.url("id", deviceid, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"self.api_version", self.api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
body_content = self._serialize.body(device_twin_info, 'object')
# Construct and send request
request = self._client.patch(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.error_details.ErrorDetailsException(
self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('object', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def replace_device_twin(self,
deviceid,
device_twin_info,
custom_headers=None,
raw=False,
**operation_config):
"""Updates tags and desired properties of a device twin.
Update a device twin. See
https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-device-twins
for more information.
:param deviceid:
:type deviceid: str
:param device_twin_info:
:type device_twin_info: :class:`DeviceTwinInfo
<device_twin.models.DeviceTwinInfo>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: :class:`DeviceTwinInfo <device_twin.models.DeviceTwinInfo>`
or :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>` if
raw=true
:rtype: :class:`DeviceTwinInfo <device_twin.models.DeviceTwinInfo>` or
:class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
# Construct URL
url = '/twins/{id}'
path_format_arguments = {
'id': self._serialize.url("id", deviceid, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"self.api_version", self.api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
body_content = self._serialize.body(device_twin_info, 'object')
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.error_details.ErrorDetailsException(
self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('object', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def invoke_device_method(self,
deviceid,
direct_method_request,
custom_headers=None,
raw=False,
**operation_config):
"""Invoke a direct method on a device.
Invoke a direct method on a device. See
https://docs.microsoft.com/azure/iot-hub/iot-hub-devguide-direct-methods
for more information.
:param deviceid:
:type deviceid: str
:param direct_method_request:
:type direct_method_request: :class:`CloudToDeviceMethod
<device_twin.models.CloudToDeviceMethod>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: :class:`CloudToDeviceMethodResult
<device_twin.models.CloudToDeviceMethodResult>` or
:class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>` if
raw=true
:rtype: :class:`CloudToDeviceMethodResult
<device_twin.models.CloudToDeviceMethodResult>` or
:class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
# Construct URL
url = '/twins/{id}/methods'
path_format_arguments = {
'id': self._serialize.url("id", deviceid, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = '2016-11-14'
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
body_content = self._serialize.body(direct_method_request,
'CloudToDeviceMethod')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.error_details.ErrorDetailsException(
self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('CloudToDeviceMethodResult',
response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
class AutoRestResourceFlatteningTestService(object):
"""Resource Flattening for AutoRest
:param config: Configuration for client.
:type config: AutoRestResourceFlatteningTestServiceConfiguration
"""
def __init__(self, config):
self._client = ServiceClient(config.credentials, config)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer()
self._deserialize = Deserializer(client_models)
self.config = config
def put_array(self,
resource_array=None,
custom_headers={},
raw=False,
**operation_config):
"""
Put External Resource as an Array
:param resource_array: External Resource as an Array to put
:type resource_array: list of :class:`Resource
<fixtures.acceptancetestsazureresource.models.Resource>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/azure/resource-flatten/array'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
if resource_array is not None:
body_content = self._serialize.body(resource_array, '[Resource]')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_array(self, custom_headers={}, raw=False, **operation_config):
"""
Get External Resource as an Array
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: list of :class:`FlattenedProduct
<fixtures.acceptancetestsazureresource.models.FlattenedProduct>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/azure/resource-flatten/array'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[FlattenedProduct]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_dictionary(self,
resource_dictionary=None,
custom_headers={},
raw=False,
**operation_config):
"""
Put External Resource as a Dictionary
:param resource_dictionary: External Resource as a Dictionary to put
:type resource_dictionary: dict
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/azure/resource-flatten/dictionary'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
if resource_dictionary is not None:
body_content = self._serialize.body(resource_dictionary,
'{FlattenedProduct}')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_dictionary(self, custom_headers={}, raw=False, **operation_config):
"""
Get External Resource as a Dictionary
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: dict
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/azure/resource-flatten/dictionary'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('{FlattenedProduct}', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_resource_collection(self,
resource_complex_object=None,
custom_headers={},
raw=False,
**operation_config):
"""
Put External Resource as a ResourceCollection
:param resource_complex_object: External Resource as a
ResourceCollection to put
:type resource_complex_object: :class:`ResourceCollection
<fixtures.acceptancetestsazureresource.models.ResourceCollection>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/azure/resource-flatten/resourcecollection'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
if resource_complex_object is not None:
body_content = self._serialize.body(resource_complex_object,
'ResourceCollection')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_resource_collection(self,
custom_headers={},
raw=False,
**operation_config):
"""
Get External Resource as a ResourceCollection
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`ResourceCollection
<fixtures.acceptancetestsazureresource.models.ResourceCollection>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
"""
# Construct URL
url = '/azure/resource-flatten/resourcecollection'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('ResourceCollection', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
class AutoRestResourceFlatteningTestService(object):
"""Resource Flattening for AutoRest
:ivar config: Configuration for client.
:vartype config: AutoRestResourceFlatteningTestServiceConfiguration
:param credentials: Credentials needed for the client to connect to Azure.
:type credentials: :mod:`A msrestazure Credentials
object<msrestazure.azure_active_directory>`
:param accept_language: Gets or sets the preferred language for the
response.
:type accept_language: str
:param long_running_operation_retry_timeout: Gets or sets the retry
timeout in seconds for Long Running Operations. Default value is 30.
:type long_running_operation_retry_timeout: int
:param generate_client_request_id: When set to true a unique
x-ms-client-request-id value is generated and included in each request.
Default is true.
:type generate_client_request_id: bool
:param str base_url: Service URL
:param str filepath: Existing config
"""
def __init__(self,
credentials,
accept_language='en-US',
long_running_operation_retry_timeout=30,
generate_client_request_id=True,
base_url=None,
filepath=None):
self.config = AutoRestResourceFlatteningTestServiceConfiguration(
credentials, accept_language, long_running_operation_retry_timeout,
generate_client_request_id, base_url, filepath)
self._client = ServiceClient(self.config.credentials, self.config)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def put_array(self,
resource_array=None,
custom_headers=None,
raw=False,
**operation_config):
"""Put External Resource as an Array.
:param resource_array: External Resource as an Array to put
:type resource_array: list of :class:`Resource
<fixtures.acceptancetestsazureresource.models.Resource>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`ErrorException<fixtures.acceptancetestsazureresource.models.ErrorException>`
"""
# Construct URL
url = '/azure/resource-flatten/array'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
if resource_array is not None:
body_content = self._serialize.body(resource_array, '[Resource]')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_array(self, custom_headers=None, raw=False, **operation_config):
"""Get External Resource as an Array.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: list of :class:`FlattenedProduct
<fixtures.acceptancetestsazureresource.models.FlattenedProduct>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`ErrorException<fixtures.acceptancetestsazureresource.models.ErrorException>`
"""
# Construct URL
url = '/azure/resource-flatten/array'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[FlattenedProduct]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_dictionary(self,
resource_dictionary=None,
custom_headers=None,
raw=False,
**operation_config):
"""Put External Resource as a Dictionary.
:param resource_dictionary: External Resource as a Dictionary to put
:type resource_dictionary: dict
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`ErrorException<fixtures.acceptancetestsazureresource.models.ErrorException>`
"""
# Construct URL
url = '/azure/resource-flatten/dictionary'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
if resource_dictionary is not None:
body_content = self._serialize.body(resource_dictionary,
'{FlattenedProduct}')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_dictionary(self,
custom_headers=None,
raw=False,
**operation_config):
"""Get External Resource as a Dictionary.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: dict
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`ErrorException<fixtures.acceptancetestsazureresource.models.ErrorException>`
"""
# Construct URL
url = '/azure/resource-flatten/dictionary'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('{FlattenedProduct}', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_resource_collection(self,
resource_complex_object=None,
custom_headers=None,
raw=False,
**operation_config):
"""Put External Resource as a ResourceCollection.
:param resource_complex_object: External Resource as a
ResourceCollection to put
:type resource_complex_object: :class:`ResourceCollection
<fixtures.acceptancetestsazureresource.models.ResourceCollection>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`ErrorException<fixtures.acceptancetestsazureresource.models.ErrorException>`
"""
# Construct URL
url = '/azure/resource-flatten/resourcecollection'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
if resource_complex_object is not None:
body_content = self._serialize.body(resource_complex_object,
'ResourceCollection')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_resource_collection(self,
custom_headers=None,
raw=False,
**operation_config):
"""Get External Resource as a ResourceCollection.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`ResourceCollection
<fixtures.acceptancetestsazureresource.models.ResourceCollection>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`ErrorException<fixtures.acceptancetestsazureresource.models.ErrorException>`
"""
# Construct URL
url = '/azure/resource-flatten/resourcecollection'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('ResourceCollection', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
class WebSiteManagementClient(object):
"""WebSite Management Client
:ivar config: Configuration for client.
:vartype config: WebSiteManagementClientConfiguration
:ivar app_service_certificate_orders: AppServiceCertificateOrders operations
:vartype app_service_certificate_orders: azure.mgmt.web.operations.AppServiceCertificateOrdersOperations
:ivar domains: Domains operations
:vartype domains: azure.mgmt.web.operations.DomainsOperations
:ivar top_level_domains: TopLevelDomains operations
:vartype top_level_domains: azure.mgmt.web.operations.TopLevelDomainsOperations
:ivar certificates: Certificates operations
:vartype certificates: azure.mgmt.web.operations.CertificatesOperations
:ivar deleted_web_apps: DeletedWebApps operations
:vartype deleted_web_apps: azure.mgmt.web.operations.DeletedWebAppsOperations
:ivar provider: Provider operations
:vartype provider: azure.mgmt.web.operations.ProviderOperations
:ivar recommendations: Recommendations operations
:vartype recommendations: azure.mgmt.web.operations.RecommendationsOperations
:ivar web_apps: WebApps operations
:vartype web_apps: azure.mgmt.web.operations.WebAppsOperations
:ivar app_service_environments: AppServiceEnvironments operations
:vartype app_service_environments: azure.mgmt.web.operations.AppServiceEnvironmentsOperations
:ivar app_service_plans: AppServicePlans operations
:vartype app_service_plans: azure.mgmt.web.operations.AppServicePlansOperations
:param credentials: Credentials needed for the client to connect to Azure.
:type credentials: :mod:`A msrestazure Credentials
object<msrestazure.azure_active_directory>`
:param subscription_id: Your Azure subscription ID. This is a
GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000).
:type subscription_id: str
:param str base_url: Service URL
"""
def __init__(self, credentials, subscription_id, base_url=None):
self.config = WebSiteManagementClientConfiguration(
credentials, subscription_id, base_url)
self._client = ServiceClient(self.config.credentials, self.config)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self.app_service_certificate_orders = AppServiceCertificateOrdersOperations(
self._client, self.config, self._serialize, self._deserialize)
self.domains = DomainsOperations(self._client, self.config,
self._serialize, self._deserialize)
self.top_level_domains = TopLevelDomainsOperations(
self._client, self.config, self._serialize, self._deserialize)
self.certificates = CertificatesOperations(self._client, self.config,
self._serialize,
self._deserialize)
self.deleted_web_apps = DeletedWebAppsOperations(
self._client, self.config, self._serialize, self._deserialize)
self.provider = ProviderOperations(self._client, self.config,
self._serialize, self._deserialize)
self.recommendations = RecommendationsOperations(
self._client, self.config, self._serialize, self._deserialize)
self.web_apps = WebAppsOperations(self._client, self.config,
self._serialize, self._deserialize)
self.app_service_environments = AppServiceEnvironmentsOperations(
self._client, self.config, self._serialize, self._deserialize)
self.app_service_plans = AppServicePlansOperations(
self._client, self.config, self._serialize, self._deserialize)
def get_publishing_user(self,
custom_headers=None,
raw=False,
**operation_config):
"""Gets publishing user.
Gets publishing user.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: User or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.User or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
# Construct URL
url = '/providers/Microsoft.Web/publishingUsers/web'
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('User', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def update_publishing_user(self,
user_details,
custom_headers=None,
raw=False,
**operation_config):
"""Updates publishing user.
Updates publishing user.
:param user_details: Details of publishing user
:type user_details: ~azure.mgmt.web.models.User
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: User or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.User or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
# Construct URL
url = '/providers/Microsoft.Web/publishingUsers/web'
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
body_content = self._serialize.body(user_details, 'User')
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('User', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def list_source_controls(self,
custom_headers=None,
raw=False,
**operation_config):
"""Gets the source controls available for Azure websites.
Gets the source controls available for Azure websites.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: An iterator like instance of SourceControl
:rtype:
~azure.mgmt.web.models.SourceControlPaged[~azure.mgmt.web.models.SourceControl]
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
def internal_paging(next_link=None, raw=False):
if not next_link:
# Construct URL
url = '/providers/Microsoft.Web/sourcecontrols'
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
else:
url = next_link
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters[
'Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
return response
# Deserialize response
deserialized = models.SourceControlPaged(
internal_paging, self._deserialize.dependencies)
if raw:
header_dict = {}
client_raw_response = models.SourceControlPaged(
internal_paging, self._deserialize.dependencies, header_dict)
return client_raw_response
return deserialized
def update_source_control(self,
source_control_type,
request_message,
custom_headers=None,
raw=False,
**operation_config):
"""Updates source control token.
Updates source control token.
:param source_control_type: Type of source control
:type source_control_type: str
:param request_message: Source control token information
:type request_message: ~azure.mgmt.web.models.SourceControl
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: SourceControl or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.SourceControl or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
# Construct URL
url = '/providers/Microsoft.Web/sourcecontrols/{sourceControlType}'
path_format_arguments = {
'sourceControlType':
self._serialize.url("source_control_type", source_control_type,
'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
body_content = self._serialize.body(request_message, 'SourceControl')
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('SourceControl', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def check_name_availability(self,
name,
type,
is_fqdn=None,
custom_headers=None,
raw=False,
**operation_config):
"""Check if a resource name is available.
Check if a resource name is available.
:param name: Resource name to verify.
:type name: str
:param type: Resource type used for verification. Possible values
include: 'Site', 'Slot', 'HostingEnvironment'
:type type: str or ~azure.mgmt.web.models.CheckNameResourceTypes
:param is_fqdn: Is fully qualified domain name.
:type is_fqdn: bool
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: ResourceNameAvailability or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.ResourceNameAvailability or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
request = models.ResourceNameAvailabilityRequest(name=name,
type=type,
is_fqdn=is_fqdn)
api_version = "2016-03-01"
# Construct URL
url = '/subscriptions/{subscriptionId}/providers/Microsoft.Web/checknameavailability'
path_format_arguments = {
'subscriptionId':
self._serialize.url("self.config.subscription_id",
self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
body_content = self._serialize.body(request,
'ResourceNameAvailabilityRequest')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('ResourceNameAvailability',
response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def list_geo_regions(self,
sku=None,
linux_workers_enabled=None,
custom_headers=None,
raw=False,
**operation_config):
"""Get a list of available geographical regions.
Get a list of available geographical regions.
:param sku: Name of SKU used to filter the regions. Possible values
include: 'Free', 'Shared', 'Basic', 'Standard', 'Premium',
'PremiumV2', 'Dynamic', 'Isolated'
:type sku: str or ~azure.mgmt.web.models.SkuName
:param linux_workers_enabled: Specify <code>true</code> if you want to
filter to only regions that support Linux workers.
:type linux_workers_enabled: bool
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: An iterator like instance of GeoRegion
:rtype:
~azure.mgmt.web.models.GeoRegionPaged[~azure.mgmt.web.models.GeoRegion]
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
def internal_paging(next_link=None, raw=False):
if not next_link:
# Construct URL
url = '/subscriptions/{subscriptionId}/providers/Microsoft.Web/geoRegions'
path_format_arguments = {
'subscriptionId':
self._serialize.url("self.config.subscription_id",
self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
if sku is not None:
query_parameters['sku'] = self._serialize.query(
"sku", sku, 'str')
if linux_workers_enabled is not None:
query_parameters[
'linuxWorkersEnabled'] = self._serialize.query(
"linux_workers_enabled", linux_workers_enabled,
'bool')
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
else:
url = next_link
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters[
'Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
return response
# Deserialize response
deserialized = models.GeoRegionPaged(internal_paging,
self._deserialize.dependencies)
if raw:
header_dict = {}
client_raw_response = models.GeoRegionPaged(
internal_paging, self._deserialize.dependencies, header_dict)
return client_raw_response
return deserialized
def list_premier_add_on_offers(self,
custom_headers=None,
raw=False,
**operation_config):
"""List all premier add-on offers.
List all premier add-on offers.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: An iterator like instance of PremierAddOnOffer
:rtype:
~azure.mgmt.web.models.PremierAddOnOfferPaged[~azure.mgmt.web.models.PremierAddOnOffer]
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
def internal_paging(next_link=None, raw=False):
if not next_link:
# Construct URL
url = '/subscriptions/{subscriptionId}/providers/Microsoft.Web/premieraddonoffers'
path_format_arguments = {
'subscriptionId':
self._serialize.url("self.config.subscription_id",
self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
else:
url = next_link
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters[
'Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
return response
# Deserialize response
deserialized = models.PremierAddOnOfferPaged(
internal_paging, self._deserialize.dependencies)
if raw:
header_dict = {}
client_raw_response = models.PremierAddOnOfferPaged(
internal_paging, self._deserialize.dependencies, header_dict)
return client_raw_response
return deserialized
def list_skus(self, custom_headers=None, raw=False, **operation_config):
"""List all SKUs.
List all SKUs.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: SkuInfos or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.SkuInfos or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
# Construct URL
url = '/subscriptions/{subscriptionId}/providers/Microsoft.Web/skus'
path_format_arguments = {
'subscriptionId':
self._serialize.url("self.config.subscription_id",
self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters,
**operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('SkuInfos', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def verify_hosting_environment_vnet(self,
parameters,
custom_headers=None,
raw=False,
**operation_config):
"""Verifies if this VNET is compatible with an App Service Environment.
Verifies if this VNET is compatible with an App Service Environment by
analyzing the Network Security Group rules.
:param parameters: VNET information
:type parameters: ~azure.mgmt.web.models.VnetParameters
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: VnetValidationFailureDetails or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.VnetValidationFailureDetails or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
# Construct URL
url = '/subscriptions/{subscriptionId}/providers/Microsoft.Web/verifyHostingEnvironmentVnet'
path_format_arguments = {
'subscriptionId':
self._serialize.url("self.config.subscription_id",
self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
body_content = self._serialize.body(parameters, 'VnetParameters')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('VnetValidationFailureDetails',
response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def move(self,
resource_group_name,
target_resource_group=None,
resources=None,
custom_headers=None,
raw=False,
**operation_config):
"""Move resources between resource groups.
Move resources between resource groups.
:param resource_group_name: Name of the resource group to which the
resource belongs.
:type resource_group_name: str
:param target_resource_group:
:type target_resource_group: str
:param resources:
:type resources: list[str]
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
move_resource_envelope = models.CsmMoveResourceEnvelope(
target_resource_group=target_resource_group, resources=resources)
api_version = "2016-03-01"
# Construct URL
url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/moveResources'
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name",
resource_group_name,
'str',
max_length=90,
min_length=1,
pattern=r'^[-\w\._\(\)]+[^\.]$'),
'subscriptionId':
self._serialize.url("self.config.subscription_id",
self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
body_content = self._serialize.body(move_resource_envelope,
'CsmMoveResourceEnvelope')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [204]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def validate(self,
resource_group_name,
validate_request,
custom_headers=None,
raw=False,
**operation_config):
"""Validate if a resource can be created.
Validate if a resource can be created.
:param resource_group_name: Name of the resource group to which the
resource belongs.
:type resource_group_name: str
:param validate_request: Request with the resources to validate.
:type validate_request: ~azure.mgmt.web.models.ValidateRequest
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: ValidateResponse or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.ValidateResponse or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
# Construct URL
url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/validate'
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name",
resource_group_name,
'str',
max_length=90,
min_length=1,
pattern=r'^[-\w\._\(\)]+[^\.]$'),
'subscriptionId':
self._serialize.url("self.config.subscription_id",
self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
body_content = self._serialize.body(validate_request,
'ValidateRequest')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('ValidateResponse', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def validate_move(self,
resource_group_name,
target_resource_group=None,
resources=None,
custom_headers=None,
raw=False,
**operation_config):
"""Validate whether a resource can be moved.
Validate whether a resource can be moved.
:param resource_group_name: Name of the resource group to which the
resource belongs.
:type resource_group_name: str
:param target_resource_group:
:type target_resource_group: str
:param resources:
:type resources: list[str]
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
move_resource_envelope = models.CsmMoveResourceEnvelope(
target_resource_group=target_resource_group, resources=resources)
api_version = "2016-03-01"
# Construct URL
url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/validateMoveResources'
path_format_arguments = {
'resourceGroupName':
self._serialize.url("resource_group_name",
resource_group_name,
'str',
max_length=90,
min_length=1,
pattern=r'^[-\w\._\(\)]+[^\.]$'),
'subscriptionId':
self._serialize.url("self.config.subscription_id",
self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header(
"self.config.accept_language", self.config.accept_language,
'str')
# Construct body
body_content = self._serialize.body(move_resource_envelope,
'CsmMoveResourceEnvelope')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request, header_parameters, body_content,
**operation_config)
if response.status_code not in [204]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
class DigitalTwinRepositoryProvisioningService(object):
"""DigitalTwin Repository Control Plane Service. Provisions Repository and Access keys to a repository.
:ivar config: Configuration for client.
:vartype config: DigitalTwinRepositoryProvisioningServiceConfiguration
:param str base_url: Service URL
"""
def __init__(self, base_url=None):
self.config = DigitalTwinRepositoryProvisioningServiceConfiguration(
base_url)
self._client = ServiceClient(None, self.config)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self.api_version = '2019-07-01-Preview'
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def get_keys_async(self,
repository_id,
api_version,
custom_headers=None,
raw=False,
**operation_config):
"""Gets all the keys associated to a repository.
Connection String format:
HostName=repository svc endpoint;RepositoryId=repository
id(GUID);SharedAccessKeyName =access key id/name;SharedAccessKey=shared
access key;.
:param repository_id: Repository id
:type repository_id: str
:param api_version: API version.
:type api_version: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: list or ClientRawResponse if raw=true
:rtype:
list[~digitaltwinrepositoryprovisioningservice.models.KeyMetadata] or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_keys_async.metadata['url']
path_format_arguments = {
'repositoryId':
self._serialize.url("repository_id", repository_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise CloudError(response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[KeyMetadata]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_keys_async.metadata = {'url': '/repositories/{repositoryId}/authKeys'}
def create_or_update_key_async(self,
repository_id,
api_version,
properties=None,
custom_headers=None,
raw=False,
**operation_config):
"""Creates or updates a key for the given repository.
If Id present in the RepositoryKeyRequest's properties, it will update
the key with new key.
Otherwise return a new key.
:param repository_id: Repository id
:type repository_id: str
:param api_version: API version.
:type api_version: str
:param properties:
:type properties:
~digitaltwinrepositoryprovisioningservice.models.RepositoryKeyRequestProperties
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: KeyMetadata or ClientRawResponse if raw=true
:rtype: ~digitaltwinrepositoryprovisioningservice.models.KeyMetadata
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
repository_key_request = None
if properties is not None:
repository_key_request = models.RepositoryKeyRequest(
properties=properties)
# Construct URL
url = self.create_or_update_key_async.metadata['url']
path_format_arguments = {
'repositoryId':
self._serialize.url("repository_id", repository_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters[
'Content-Type'] = 'application/json-patch+json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if repository_key_request is not None:
body_content = self._serialize.body(repository_key_request,
'RepositoryKeyRequest')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request,
header_parameters,
body_content,
stream=False,
**operation_config)
if response.status_code not in [200, 404]:
raise CloudError(response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('KeyMetadata', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
create_or_update_key_async.metadata = {
'url': '/repositories/{repositoryId}/authKeys'
}
def get_key_async(self,
repository_id,
id,
api_version,
custom_headers=None,
raw=False,
**operation_config):
"""Gets a key metadata information for the given key.
Connection String format:
HostName=repository svc endpoint;RepositoryId=repository
id(GUID);SharedAccessKeyName =access key id/name;SharedAccessKey=shared
access key;.
:param repository_id: Repository Id
:type repository_id: str
:param id: Key Id.
:type id: str
:param api_version: API version.
:type api_version: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: KeyMetadata or ClientRawResponse if raw=true
:rtype: ~digitaltwinrepositoryprovisioningservice.models.KeyMetadata
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_key_async.metadata['url']
path_format_arguments = {
'repositoryId':
self._serialize.url("repository_id", repository_id, 'str'),
'id':
self._serialize.url("id", id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200, 404]:
raise CloudError(response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('KeyMetadata', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_key_async.metadata = {
'url': '/repositories/{repositoryId}/authKeys/{id}'
}
def delete_key_async(self,
id,
repository_id,
api_version,
custom_headers=None,
raw=False,
**operation_config):
"""Deletes a key from the given repository.
:param id: Key id.
:type id: str
:param repository_id: Repository id.
:type repository_id: str
:param api_version: API version.
:type api_version: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.delete_key_async.metadata['url']
path_format_arguments = {
'id':
self._serialize.url("id", id, 'str'),
'repositoryId':
self._serialize.url("repository_id", repository_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.delete(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [204]:
raise CloudError(response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
delete_key_async.metadata = {
'url': '/repositories/{repositoryId}/authKeys/{id}'
}
def get_repositories_async(self,
api_version,
custom_headers=None,
raw=False,
**operation_config):
"""Gets all the repositories metadata belong to the user's tenant.
:param api_version: API version.
:type api_version: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: list or ClientRawResponse if raw=true
:rtype:
list[~digitaltwinrepositoryprovisioningservice.models.RepositoryMetadata]
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_repositories_async.metadata['url']
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise CloudError(response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[RepositoryMetadata]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_repositories_async.metadata = {'url': '/repositories'}
def create_or_update_repository_async(self,
api_version,
properties=None,
custom_headers=None,
raw=False,
**operation_config):
"""Create or updates a repository.
If Id is present in the RepositoryRequest properties object, service
tries to update the repository.
otherwise it will try to create repository.
:param api_version: API version.
:type api_version: str
:param properties:
:type properties:
~digitaltwinrepositoryprovisioningservice.models.RepositoryUpsertRequestProperties
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: RepositoryProvisionResponseBase or ClientRawResponse if
raw=true
:rtype:
~digitaltwinrepositoryprovisioningservice.models.RepositoryProvisionResponseBase
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
repository_upsert_request = None
if properties is not None:
repository_upsert_request = models.RepositoryUpsertRequest(
properties=properties)
# Construct URL
url = self.create_or_update_repository_async.metadata['url']
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters[
'Content-Type'] = 'application/json-patch+json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if repository_upsert_request is not None:
body_content = self._serialize.body(repository_upsert_request,
'RepositoryUpsertRequest')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request,
header_parameters,
body_content,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise CloudError(response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('RepositoryProvisionResponseBase',
response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
create_or_update_repository_async.metadata = {'url': '/repositories'}
def get_repository_async(self,
repository_id,
api_version,
custom_headers=None,
raw=False,
**operation_config):
"""Gets the repository metadata for the given repository id.
:param repository_id: Repository Id.
:type repository_id: str
:param api_version: API version.
:type api_version: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: RepositoryMetadata or ClientRawResponse if raw=true
:rtype:
~digitaltwinrepositoryprovisioningservice.models.RepositoryMetadata or
~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_repository_async.metadata['url']
path_format_arguments = {
'repositoryId':
self._serialize.url("repository_id", repository_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise CloudError(response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('RepositoryMetadata', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_repository_async.metadata = {'url': '/repositories/{repositoryId}'}
def delete_repository_async(self,
repository_id,
api_version,
custom_headers=None,
raw=False,
**operation_config):
"""Deletes the repository for given id.
:param repository_id: Repository Id
:type repository_id: str
:param api_version: API version.
:type api_version: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: RepositoryProvisionResponseBase or ClientRawResponse if
raw=true
:rtype:
~digitaltwinrepositoryprovisioningservice.models.RepositoryProvisionResponseBase
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.delete_repository_async.metadata['url']
path_format_arguments = {
'repositoryId':
self._serialize.url("repository_id", repository_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.delete(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise CloudError(response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('RepositoryProvisionResponseBase',
response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
delete_repository_async.metadata = {'url': '/repositories/{repositoryId}'}
def get_provision_status(self,
repository_id,
tracking_id,
api_version,
custom_headers=None,
raw=False,
**operation_config):
"""Returns the repository provisioning status.
:param repository_id: Repository id.
:type repository_id: str
:param tracking_id: Tracking id (provisioningState)
:type tracking_id: str
:param api_version: API version.
:type api_version: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: RepositoryProvisionResponseBase or ClientRawResponse if
raw=true
:rtype:
~digitaltwinrepositoryprovisioningservice.models.RepositoryProvisionResponseBase
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_provision_status.metadata['url']
path_format_arguments = {
'repositoryId':
self._serialize.url("repository_id", repository_id, 'str'),
'trackingId':
self._serialize.url("tracking_id", tracking_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query(
"api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200, 404]:
raise CloudError(response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('RepositoryProvisionResponseBase',
response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_provision_status.metadata = {
'url': '/repositories/{repositoryId}/status/{trackingId}'
}
class CiqsApi(object):
"""Deployment service backend for solutions on quickstart.azure.ai
:ivar config: Configuration for client.
:vartype config: CiqsApiConfiguration
:param str base_url: Service URL
"""
def __init__(self, creds=None, base_url=None):
self.config = CiqsApiConfiguration(base_url)
self._client = ServiceClient(creds, self.config)
client_models = {
k: v
for k, v in models.__dict__.items() if isinstance(v, type)
}
self.api_version = 'Build_air_cloudai_machinelearning_cloudintelligencequickstart'
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def get_api_gallery(self,
solution_storage_connection_string=None,
category=None,
partnername=None,
owneremail=None,
custom_headers=None,
raw=False,
**operation_config):
"""Get Gallery for current user.
:param solution_storage_connection_string: A connection string for a
private storage account.
:type solution_storage_connection_string: str
:param category: Category.
:type category: str
:param partnername: Partner Name.
:type partnername: str
:param owneremail: Owner Email.
:type owneremail: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: list or ClientRawResponse if raw=true
:rtype:
list[~microsoft.swagger.codegen.cloudintelligencequickstart.models.MicrosoftCiqsModelsGalleryTemplate]
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_api_gallery.metadata['url']
# Construct parameters
query_parameters = {}
if category is not None:
query_parameters['category'] = self._serialize.query(
"category", category, 'str')
if partnername is not None:
query_parameters['partnername'] = self._serialize.query(
"partnername", partnername, 'str')
if owneremail is not None:
query_parameters['owneremail'] = self._serialize.query(
"owneremail", owneremail, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
if solution_storage_connection_string is not None:
header_parameters[
'SolutionStorageConnectionString'] = self._serialize.header(
"solution_storage_connection_string",
solution_storage_connection_string, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize(
'[MicrosoftCiqsModelsGalleryTemplate]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_api_gallery.metadata = {'url': '/api/gallery'}
def get_api_gallery_by_template_id(self,
template_id,
solution_storage_connection_string=None,
custom_headers=None,
raw=False,
**operation_config):
"""Gets detailed information about a solution template. This includes:
- Solution metadata such as splash image, decsription, and owners.
- List of provisioning steps and deployments.
:param template_id: Id of the solution template.
:type template_id: str
:param solution_storage_connection_string: A connection string for a
private storage account.
:type solution_storage_connection_string: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: MicrosoftCiqsModelsGalleryTemplate or ClientRawResponse if
raw=true
:rtype:
~microsoft.swagger.codegen.cloudintelligencequickstart.models.MicrosoftCiqsModelsGalleryTemplate
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_api_gallery_by_template_id.metadata['url']
path_format_arguments = {
'templateId': self._serialize.url("template_id", template_id,
'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
if solution_storage_connection_string is not None:
header_parameters[
'SolutionStorageConnectionString'] = self._serialize.header(
"solution_storage_connection_string",
solution_storage_connection_string, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize(
'MicrosoftCiqsModelsGalleryTemplate', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_api_gallery_by_template_id.metadata = {
'url': '/api/gallery/{templateId}'
}
def get_api_deployments_by_subscription_id(self,
subscription_id,
custom_headers=None,
raw=False,
**operation_config):
"""Get a list of T:Microsoft.Ciqs.Models.Deployment.Deployment object
representing deployments a user made within the provided subscription
Id.
:param subscription_id: Id of the subscription within which to query
for existing deployments.
:type subscription_id: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: list or ClientRawResponse if raw=true
:rtype:
list[~microsoft.swagger.codegen.cloudintelligencequickstart.models.MicrosoftCiqsModelsDeploymentDeployment]
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_api_deployments_by_subscription_id.metadata['url']
path_format_arguments = {
'subscriptionId':
self._serialize.url("subscription_id", subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize(
'[MicrosoftCiqsModelsDeploymentDeployment]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_api_deployments_by_subscription_id.metadata = {
'url': '/api/deployments/{subscriptionId}'
}
def post_api_deployments_by_subscription_id_by_template_id(
self,
subscription_id,
template_id,
body,
ms_asm_refresh_token=None,
custom_headers=None,
raw=False,
**operation_config):
"""Creates a new deployment of the requested solution template within the
user's requested subscription and location.
As part of creating a new deployment, this creates a resource group
within the selected subscription of the same name as the deployment.
The deployment is provisioned asynchronously so this API call will
return before any
T:Microsoft.Ciqs.Models.Deployment.DeploymentProvisioningStep has begun
executing.
Therefore, the list of provisioning steps, and provsioning logs will
remain null until provisioning has begun.
:param subscription_id: Id of the subscription within which to query
for existing deployments.
:type subscription_id: str
:param template_id: Template Id.
:type template_id: str
:param body:
:type body:
~microsoft.swagger.codegen.cloudintelligencequickstart.models.MicrosoftCiqsModelsDeploymentCreateDeploymentRequest
:param ms_asm_refresh_token: The refresh token signed for a user in an
Azure tenant.
:type ms_asm_refresh_token: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: MicrosoftCiqsModelsDeploymentDeployment or ClientRawResponse
if raw=true
:rtype:
~microsoft.swagger.codegen.cloudintelligencequickstart.models.MicrosoftCiqsModelsDeploymentDeployment
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.post_api_deployments_by_subscription_id_by_template_id.metadata[
'url']
path_format_arguments = {
'subscriptionId':
self._serialize.url("subscription_id", subscription_id, 'str'),
'templateId':
self._serialize.url("template_id", template_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
if ms_asm_refresh_token is not None:
header_parameters['MS-AsmRefreshToken'] = self._serialize.header(
"ms_asm_refresh_token", ms_asm_refresh_token, 'str')
# Construct body
body_content = self._serialize.body(
body, 'MicrosoftCiqsModelsDeploymentCreateDeploymentRequest')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(request,
header_parameters,
body_content,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize(
'MicrosoftCiqsModelsDeploymentDeployment', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
post_api_deployments_by_subscription_id_by_template_id.metadata = {
'url': '/api/deployments/{subscriptionId}/{templateId}'
}
def get_api_deployments_by_subscription_id_by_deployment_id(
self,
subscription_id,
deployment_id,
custom_headers=None,
raw=False,
**operation_config):
"""Get detailed information of a
T:Microsoft.Ciqs.Models.Deployment.Deployment represented by the
T:Microsoft.Ciqs.Models.Deployment.DeploymentDetails object.
This details object contains information for each
T:Microsoft.Ciqs.Models.Deployment.DeploymentProvisioningStep within
the deployment.
:param subscription_id: Id of the subscription within which to query
for existing deployments.
:type subscription_id: str
:param deployment_id: A unique Id assigned to a deployment when it was
created.
:type deployment_id: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: MicrosoftCiqsModelsDeploymentDeploymentDetails or
ClientRawResponse if raw=true
:rtype:
~microsoft.swagger.codegen.cloudintelligencequickstart.models.MicrosoftCiqsModelsDeploymentDeploymentDetails
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_api_deployments_by_subscription_id_by_deployment_id.metadata[
'url']
path_format_arguments = {
'subscriptionId':
self._serialize.url("subscription_id", subscription_id, 'str'),
'deploymentId':
self._serialize.url("deployment_id", deployment_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize(
'MicrosoftCiqsModelsDeploymentDeploymentDetails', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_api_deployments_by_subscription_id_by_deployment_id.metadata = {
'url': '/api/deployments/{subscriptionId}/{deploymentId}'
}
def put_api_deployments_by_subscription_id_by_deployment_id(
self,
subscription_id,
deployment_id,
body,
ms_asm_refresh_token=None,
custom_headers=None,
raw=False,
**operation_config):
"""Resumes an already provisioning deployment. This can also be used to
retry an existing step if it has failed.
If the parameters provided are invalid, then the response status code
will be 400
and the response will contain and error code from
T:Microsoft.Ciqs.Models.ErrorCodes.
If the provisioning step fails asynchronously due to a dependency after
the provisioning had resumed,
the details of the error will be available via the deployment details
API.
:param subscription_id: Id of the subscription within which to query
for existing deployments.
:type subscription_id: str
:param deployment_id: A unique Id assigned to a deployment when it was
created.
:type deployment_id: str
:param body:
:type body: dict[str, str]
:param ms_asm_refresh_token: The refresh token signed for a user in an
Azure tenant.
:type ms_asm_refresh_token: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: MicrosoftCiqsApiModelsExecuteProvisioningStepResponse or
ClientRawResponse if raw=true
:rtype:
~microsoft.swagger.codegen.cloudintelligencequickstart.models.MicrosoftCiqsApiModelsExecuteProvisioningStepResponse
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.put_api_deployments_by_subscription_id_by_deployment_id.metadata[
'url']
path_format_arguments = {
'subscriptionId':
self._serialize.url("subscription_id", subscription_id, 'str'),
'deploymentId':
self._serialize.url("deployment_id", deployment_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
if ms_asm_refresh_token is not None:
header_parameters['MS-AsmRefreshToken'] = self._serialize.header(
"ms_asm_refresh_token", ms_asm_refresh_token, 'str')
# Construct body
body_content = json.dumps(body)
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(request,
header_parameters,
body_content,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize(
'MicrosoftCiqsApiModelsExecuteProvisioningStepResponse',
response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
put_api_deployments_by_subscription_id_by_deployment_id.metadata = {
'url': '/api/deployments/{subscriptionId}/{deploymentId}'
}
def delete_api_deployments_by_subscription_id_by_deployment_id(
self,
subscription_id,
deployment_id,
custom_headers=None,
raw=False,
**operation_config):
"""Initiates the deletion of a deployment. This essentially removes the
resource group that was created when the deployment was done.
Note: Any changes made to the resources post deployment will also be
lost because all resources within the provisioning resource group will
be deleted.
If the deletion fails, the deplyoment details response will contain the
details.
:param subscription_id: Id of the subscription within which the
deployment was done.
:type subscription_id: str
:param deployment_id: A unique Id assigned to a deployment when it was
created.
:type deployment_id: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: MicrosoftCiqsApiModelsDeleteDeploymentResult or
ClientRawResponse if raw=true
:rtype:
~microsoft.swagger.codegen.cloudintelligencequickstart.models.MicrosoftCiqsApiModelsDeleteDeploymentResult
or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.delete_api_deployments_by_subscription_id_by_deployment_id.metadata[
'url']
path_format_arguments = {
'subscriptionId':
self._serialize.url("subscription_id", subscription_id, 'str'),
'deploymentId':
self._serialize.url("deployment_id", deployment_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.delete(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize(
'MicrosoftCiqsApiModelsDeleteDeploymentResult', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
delete_api_deployments_by_subscription_id_by_deployment_id.metadata = {
'url': '/api/deployments/{subscriptionId}/{deploymentId}'
}
def get_api_locations_by_subscription_id_by_template_id(
self,
template_id,
subscription_id,
solution_storage_connection_string=None,
custom_headers=None,
raw=False,
**operation_config):
"""Returns valid locations for a specific subscription and a template.
It does so by validating availability of resources required by a
solution template's ARM deployments
and user's quota and picking the lowest common denominators.
:param template_id: Id of the solution template for which the
locations should be fetched.
:type template_id: str
:param subscription_id: The subscription the user intends to deploy
the template into.
:type subscription_id: str
:param solution_storage_connection_string: A connection string for a
private storage account.
:type solution_storage_connection_string: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: list or ClientRawResponse if raw=true
:rtype: list[str] or ~msrest.pipeline.ClientRawResponse
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
# Construct URL
url = self.get_api_locations_by_subscription_id_by_template_id.metadata[
'url']
path_format_arguments = {
'templateId':
self._serialize.url("template_id", template_id, 'str'),
'subscriptionId':
self._serialize.url("subscription_id", subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
if solution_storage_connection_string is not None:
header_parameters[
'SolutionStorageConnectionString'] = self._serialize.header(
"solution_storage_connection_string",
solution_storage_connection_string, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request,
header_parameters,
stream=False,
**operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[str]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
get_api_locations_by_subscription_id_by_template_id.metadata = {
'url': '/api/locations/{subscriptionId}/{templateId}'
}
class WebSiteManagementClient(object):
"""WebSite Management Client
:ivar config: Configuration for client.
:vartype config: WebSiteManagementClientConfiguration
:ivar app_service_certificate_orders: AppServiceCertificateOrders operations
:vartype app_service_certificate_orders: azure.mgmt.web.operations.AppServiceCertificateOrdersOperations
:ivar domains: Domains operations
:vartype domains: azure.mgmt.web.operations.DomainsOperations
:ivar top_level_domains: TopLevelDomains operations
:vartype top_level_domains: azure.mgmt.web.operations.TopLevelDomainsOperations
:ivar certificates: Certificates operations
:vartype certificates: azure.mgmt.web.operations.CertificatesOperations
:ivar deleted_web_apps: DeletedWebApps operations
:vartype deleted_web_apps: azure.mgmt.web.operations.DeletedWebAppsOperations
:ivar provider: Provider operations
:vartype provider: azure.mgmt.web.operations.ProviderOperations
:ivar recommendations: Recommendations operations
:vartype recommendations: azure.mgmt.web.operations.RecommendationsOperations
:ivar web_apps: WebApps operations
:vartype web_apps: azure.mgmt.web.operations.WebAppsOperations
:ivar app_service_environments: AppServiceEnvironments operations
:vartype app_service_environments: azure.mgmt.web.operations.AppServiceEnvironmentsOperations
:ivar app_service_plans: AppServicePlans operations
:vartype app_service_plans: azure.mgmt.web.operations.AppServicePlansOperations
:param credentials: Credentials needed for the client to connect to Azure.
:type credentials: :mod:`A msrestazure Credentials
object<msrestazure.azure_active_directory>`
:param subscription_id: Your Azure subscription ID. This is a
GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000).
:type subscription_id: str
:param str base_url: Service URL
"""
def __init__(
self, credentials, subscription_id, base_url=None):
self.config = WebSiteManagementClientConfiguration(credentials, subscription_id, base_url)
self._client = ServiceClient(self.config.credentials, self.config)
client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
self.app_service_certificate_orders = AppServiceCertificateOrdersOperations(
self._client, self.config, self._serialize, self._deserialize)
self.domains = DomainsOperations(
self._client, self.config, self._serialize, self._deserialize)
self.top_level_domains = TopLevelDomainsOperations(
self._client, self.config, self._serialize, self._deserialize)
self.certificates = CertificatesOperations(
self._client, self.config, self._serialize, self._deserialize)
self.deleted_web_apps = DeletedWebAppsOperations(
self._client, self.config, self._serialize, self._deserialize)
self.provider = ProviderOperations(
self._client, self.config, self._serialize, self._deserialize)
self.recommendations = RecommendationsOperations(
self._client, self.config, self._serialize, self._deserialize)
self.web_apps = WebAppsOperations(
self._client, self.config, self._serialize, self._deserialize)
self.app_service_environments = AppServiceEnvironmentsOperations(
self._client, self.config, self._serialize, self._deserialize)
self.app_service_plans = AppServicePlansOperations(
self._client, self.config, self._serialize, self._deserialize)
def get_publishing_user(
self, custom_headers=None, raw=False, **operation_config):
"""Gets publishing user.
Gets publishing user.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: User or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.User or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
# Construct URL
url = '/providers/Microsoft.Web/publishingUsers/web'
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('User', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def update_publishing_user(
self, user_details, custom_headers=None, raw=False, **operation_config):
"""Updates publishing user.
Updates publishing user.
:param user_details: Details of publishing user
:type user_details: ~azure.mgmt.web.models.User
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: User or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.User or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
# Construct URL
url = '/providers/Microsoft.Web/publishingUsers/web'
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct body
body_content = self._serialize.body(user_details, 'User')
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('User', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def list_source_controls(
self, custom_headers=None, raw=False, **operation_config):
"""Gets the source controls available for Azure websites.
Gets the source controls available for Azure websites.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: An iterator like instance of SourceControl
:rtype:
~azure.mgmt.web.models.SourceControlPaged[~azure.mgmt.web.models.SourceControl]
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
def internal_paging(next_link=None, raw=False):
if not next_link:
# Construct URL
url = '/providers/Microsoft.Web/sourcecontrols'
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
else:
url = next_link
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(
request, header_parameters, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
return response
# Deserialize response
deserialized = models.SourceControlPaged(internal_paging, self._deserialize.dependencies)
if raw:
header_dict = {}
client_raw_response = models.SourceControlPaged(internal_paging, self._deserialize.dependencies, header_dict)
return client_raw_response
return deserialized
def get_source_control(
self, source_control_type, custom_headers=None, raw=False, **operation_config):
"""Gets source control token.
Gets source control token.
:param source_control_type: Type of source control
:type source_control_type: str
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: SourceControl or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.SourceControl or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
# Construct URL
url = '/providers/Microsoft.Web/sourcecontrols/{sourceControlType}'
path_format_arguments = {
'sourceControlType': self._serialize.url("source_control_type", source_control_type, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('SourceControl', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def update_source_control(
self, source_control_type, request_message, custom_headers=None, raw=False, **operation_config):
"""Updates source control token.
Updates source control token.
:param source_control_type: Type of source control
:type source_control_type: str
:param request_message: Source control token information
:type request_message: ~azure.mgmt.web.models.SourceControl
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: SourceControl or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.SourceControl or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
# Construct URL
url = '/providers/Microsoft.Web/sourcecontrols/{sourceControlType}'
path_format_arguments = {
'sourceControlType': self._serialize.url("source_control_type", source_control_type, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct body
body_content = self._serialize.body(request_message, 'SourceControl')
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('SourceControl', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def check_name_availability(
self, name, type, is_fqdn=None, custom_headers=None, raw=False, **operation_config):
"""Check if a resource name is available.
Check if a resource name is available.
:param name: Resource name to verify.
:type name: str
:param type: Resource type used for verification. Possible values
include: 'Site', 'Slot', 'HostingEnvironment'
:type type: str or ~azure.mgmt.web.models.CheckNameResourceTypes
:param is_fqdn: Is fully qualified domain name.
:type is_fqdn: bool
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: ResourceNameAvailability or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.ResourceNameAvailability or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
request = models.ResourceNameAvailabilityRequest(name=name, type=type, is_fqdn=is_fqdn)
api_version = "2016-03-01"
# Construct URL
url = '/subscriptions/{subscriptionId}/providers/Microsoft.Web/checknameavailability'
path_format_arguments = {
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct body
body_content = self._serialize.body(request, 'ResourceNameAvailabilityRequest')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('ResourceNameAvailability', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def get_subscription_deployment_locations(
self, custom_headers=None, raw=False, **operation_config):
"""Gets list of available geo regions plus ministamps.
Gets list of available geo regions plus ministamps.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: DeploymentLocations or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.DeploymentLocations or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
# Construct URL
url = '/subscriptions/{subscriptionId}/providers/Microsoft.Web/deploymentLocations'
path_format_arguments = {
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('DeploymentLocations', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def list_geo_regions(
self, sku=None, linux_workers_enabled=None, custom_headers=None, raw=False, **operation_config):
"""Get a list of available geographical regions.
Get a list of available geographical regions.
:param sku: Name of SKU used to filter the regions. Possible values
include: 'Free', 'Shared', 'Basic', 'Standard', 'Premium',
'PremiumV2', 'Dynamic', 'Isolated'
:type sku: str or ~azure.mgmt.web.models.SkuName
:param linux_workers_enabled: Specify <code>true</code> if you want to
filter to only regions that support Linux workers.
:type linux_workers_enabled: bool
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: An iterator like instance of GeoRegion
:rtype:
~azure.mgmt.web.models.GeoRegionPaged[~azure.mgmt.web.models.GeoRegion]
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
def internal_paging(next_link=None, raw=False):
if not next_link:
# Construct URL
url = '/subscriptions/{subscriptionId}/providers/Microsoft.Web/geoRegions'
path_format_arguments = {
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
if sku is not None:
query_parameters['sku'] = self._serialize.query("sku", sku, 'str')
if linux_workers_enabled is not None:
query_parameters['linuxWorkersEnabled'] = self._serialize.query("linux_workers_enabled", linux_workers_enabled, 'bool')
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
else:
url = next_link
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(
request, header_parameters, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
return response
# Deserialize response
deserialized = models.GeoRegionPaged(internal_paging, self._deserialize.dependencies)
if raw:
header_dict = {}
client_raw_response = models.GeoRegionPaged(internal_paging, self._deserialize.dependencies, header_dict)
return client_raw_response
return deserialized
def list_premier_add_on_offers(
self, custom_headers=None, raw=False, **operation_config):
"""List all premier add-on offers.
List all premier add-on offers.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: An iterator like instance of PremierAddOnOffer
:rtype:
~azure.mgmt.web.models.PremierAddOnOfferPaged[~azure.mgmt.web.models.PremierAddOnOffer]
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
def internal_paging(next_link=None, raw=False):
if not next_link:
# Construct URL
url = '/subscriptions/{subscriptionId}/providers/Microsoft.Web/premieraddonoffers'
path_format_arguments = {
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
else:
url = next_link
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(
request, header_parameters, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
return response
# Deserialize response
deserialized = models.PremierAddOnOfferPaged(internal_paging, self._deserialize.dependencies)
if raw:
header_dict = {}
client_raw_response = models.PremierAddOnOfferPaged(internal_paging, self._deserialize.dependencies, header_dict)
return client_raw_response
return deserialized
def list_skus(
self, custom_headers=None, raw=False, **operation_config):
"""List all SKUs.
List all SKUs.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: SkuInfos or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.SkuInfos or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
# Construct URL
url = '/subscriptions/{subscriptionId}/providers/Microsoft.Web/skus'
path_format_arguments = {
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('SkuInfos', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def verify_hosting_environment_vnet(
self, parameters, custom_headers=None, raw=False, **operation_config):
"""Verifies if this VNET is compatible with an App Service Environment by
analyzing the Network Security Group rules.
Verifies if this VNET is compatible with an App Service Environment by
analyzing the Network Security Group rules.
:param parameters: VNET information
:type parameters: ~azure.mgmt.web.models.VnetParameters
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: VnetValidationFailureDetails or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.VnetValidationFailureDetails or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
# Construct URL
url = '/subscriptions/{subscriptionId}/providers/Microsoft.Web/verifyHostingEnvironmentVnet'
path_format_arguments = {
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct body
body_content = self._serialize.body(parameters, 'VnetParameters')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('VnetValidationFailureDetails', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def move(
self, resource_group_name, target_resource_group=None, resources=None, custom_headers=None, raw=False, **operation_config):
"""Move resources between resource groups.
Move resources between resource groups.
:param resource_group_name: Name of the resource group to which the
resource belongs.
:type resource_group_name: str
:param target_resource_group:
:type target_resource_group: str
:param resources:
:type resources: list[str]
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
move_resource_envelope = models.CsmMoveResourceEnvelope(target_resource_group=target_resource_group, resources=resources)
api_version = "2016-03-01"
# Construct URL
url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/moveResources'
path_format_arguments = {
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct body
body_content = self._serialize.body(move_resource_envelope, 'CsmMoveResourceEnvelope')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [204]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def validate(
self, resource_group_name, validate_request, custom_headers=None, raw=False, **operation_config):
"""Validate if a resource can be created.
Validate if a resource can be created.
:param resource_group_name: Name of the resource group to which the
resource belongs.
:type resource_group_name: str
:param validate_request: Request with the resources to validate.
:type validate_request: ~azure.mgmt.web.models.ValidateRequest
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: ValidateResponse or ClientRawResponse if raw=true
:rtype: ~azure.mgmt.web.models.ValidateResponse or
~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
api_version = "2016-03-01"
# Construct URL
url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Web/validate'
path_format_arguments = {
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct body
body_content = self._serialize.body(validate_request, 'ValidateRequest')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('ValidateResponse', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def validate_move(
self, resource_group_name, target_resource_group=None, resources=None, custom_headers=None, raw=False, **operation_config):
"""Validate whether a resource can be moved.
Validate whether a resource can be moved.
:param resource_group_name: Name of the resource group to which the
resource belongs.
:type resource_group_name: str
:param target_resource_group:
:type target_resource_group: str
:param resources:
:type resources: list[str]
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or ClientRawResponse if raw=true
:rtype: None or ~msrest.pipeline.ClientRawResponse
:raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
"""
move_resource_envelope = models.CsmMoveResourceEnvelope(target_resource_group=target_resource_group, resources=resources)
api_version = "2016-03-01"
# Construct URL
url = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/validateMoveResources'
path_format_arguments = {
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=90, min_length=1, pattern=r'^[-\w\._\(\)]+[^\.]$'),
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct body
body_content = self._serialize.body(move_resource_envelope, 'CsmMoveResourceEnvelope')
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [204]:
exp = CloudError(response)
exp.request_id = response.headers.get('x-ms-request-id')
raise exp
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
class AutoRestResourceFlatteningTestService(object):
"""Resource Flattening for AutoRest
:ivar config: Configuration for client.
:vartype config: AutoRestResourceFlatteningTestServiceConfiguration
:param credentials: Credentials needed for the client to connect to Azure.
:type credentials: :mod:`A msrestazure Credentials
object<msrestazure.azure_active_directory>`
:param accept_language: Gets or sets the preferred language for the
response.
:type accept_language: str
:param long_running_operation_retry_timeout: Gets or sets the retry
timeout in seconds for Long Running Operations. Default value is 30.
:type long_running_operation_retry_timeout: int
:param generate_client_request_id: When set to true a unique
x-ms-client-request-id value is generated and included in each request.
Default is true.
:type generate_client_request_id: bool
:param str base_url: Service URL
:param str filepath: Existing config
"""
def __init__(
self, credentials, accept_language='en-US', long_running_operation_retry_timeout=30, generate_client_request_id=True, base_url=None, filepath=None):
self.config = AutoRestResourceFlatteningTestServiceConfiguration(credentials, accept_language, long_running_operation_retry_timeout, generate_client_request_id, base_url, filepath)
self._client = ServiceClient(self.config.credentials, self.config)
client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def put_array(
self, resource_array=None, custom_headers=None, raw=False, **operation_config):
"""Put External Resource as an Array.
:param resource_array: External Resource as an Array to put
:type resource_array: list of :class:`Resource
<fixtures.acceptancetestsazureresource.models.Resource>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`ErrorException<fixtures.acceptancetestsazureresource.models.ErrorException>`
"""
# Construct URL
url = '/azure/resource-flatten/array'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct body
if resource_array is not None:
body_content = self._serialize.body(resource_array, '[Resource]')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_array(
self, custom_headers=None, raw=False, **operation_config):
"""Get External Resource as an Array.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: list of :class:`FlattenedProduct
<fixtures.acceptancetestsazureresource.models.FlattenedProduct>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`ErrorException<fixtures.acceptancetestsazureresource.models.ErrorException>`
"""
# Construct URL
url = '/azure/resource-flatten/array'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('[FlattenedProduct]', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_dictionary(
self, resource_dictionary=None, custom_headers=None, raw=False, **operation_config):
"""Put External Resource as a Dictionary.
:param resource_dictionary: External Resource as a Dictionary to put
:type resource_dictionary: dict
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`ErrorException<fixtures.acceptancetestsazureresource.models.ErrorException>`
"""
# Construct URL
url = '/azure/resource-flatten/dictionary'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct body
if resource_dictionary is not None:
body_content = self._serialize.body(resource_dictionary, '{FlattenedProduct}')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_dictionary(
self, custom_headers=None, raw=False, **operation_config):
"""Get External Resource as a Dictionary.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: dict
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`ErrorException<fixtures.acceptancetestsazureresource.models.ErrorException>`
"""
# Construct URL
url = '/azure/resource-flatten/dictionary'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('{FlattenedProduct}', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def put_resource_collection(
self, resource_complex_object=None, custom_headers=None, raw=False, **operation_config):
"""Put External Resource as a ResourceCollection.
:param resource_complex_object: External Resource as a
ResourceCollection to put
:type resource_complex_object: :class:`ResourceCollection
<fixtures.acceptancetestsazureresource.models.ResourceCollection>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`ErrorException<fixtures.acceptancetestsazureresource.models.ErrorException>`
"""
# Construct URL
url = '/azure/resource-flatten/resourcecollection'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct body
if resource_complex_object is not None:
body_content = self._serialize.body(resource_complex_object, 'ResourceCollection')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def get_resource_collection(
self, custom_headers=None, raw=False, **operation_config):
"""Get External Resource as a ResourceCollection.
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`ResourceCollection
<fixtures.acceptancetestsazureresource.models.ResourceCollection>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`ErrorException<fixtures.acceptancetestsazureresource.models.ErrorException>`
"""
# Construct URL
url = '/azure/resource-flatten/resourcecollection'
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if self.config.generate_client_request_id:
header_parameters['x-ms-client-request-id'] = str(uuid.uuid1())
if custom_headers:
header_parameters.update(custom_headers)
if self.config.accept_language is not None:
header_parameters['accept-language'] = self._serialize.header("self.config.accept_language", self.config.accept_language, 'str')
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('ResourceCollection', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
class AutoRestValidationTest(object):
"""Test Infrastructure for AutoRest. No server backend exists for these tests.
:ivar config: Configuration for client.
:vartype config: AutoRestValidationTestConfiguration
:param subscription_id: Subscription ID.
:type subscription_id: str
:param str base_url: Service URL
"""
def __init__(
self, subscription_id, base_url=None):
self.config = AutoRestValidationTestConfiguration(subscription_id, base_url)
self._client = ServiceClient(None, self.config)
client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
self.api_version = '1.0.0'
self._serialize = Serializer(client_models)
self._deserialize = Deserializer(client_models)
def validation_of_method_parameters(
self, resource_group_name, id, custom_headers=None, raw=False, **operation_config):
"""Validates input parameters on the method. See swagger for details.
:param resource_group_name: Required string between 3 and 10 chars
with pattern [a-zA-Z0-9]+.
:type resource_group_name: str
:param id: Required int multiple of 10 from 100 to 1000.
:type id: int
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: :class:`Product
<fixtures.acceptancetestsvalidation.models.Product>` or
:class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>` if
raw=true
:rtype: :class:`Product
<fixtures.acceptancetestsvalidation.models.Product>` or
:class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
:raises:
:class:`ErrorException<fixtures.acceptancetestsvalidation.models.ErrorException>`
"""
# Construct URL
url = '/fakepath/{subscriptionId}/{resourceGroupName}/{id}'
path_format_arguments = {
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=10, min_length=3, pattern=r'[a-zA-Z0-9]+'),
'id': self._serialize.url("id", id, 'int', maximum=1000, minimum=100, multiple=10)
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['apiVersion'] = self._serialize.query("self.api_version", self.api_version, 'str', pattern=r'\d{2}-\d{2}-\d{4}')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Product', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def validation_of_body(
self, resource_group_name, id, body=None, custom_headers=None, raw=False, **operation_config):
"""Validates body parameters on the method. See swagger for details.
:param resource_group_name: Required string between 3 and 10 chars
with pattern [a-zA-Z0-9]+.
:type resource_group_name: str
:param id: Required int multiple of 10 from 100 to 1000.
:type id: int
:param body:
:type body: :class:`Product
<fixtures.acceptancetestsvalidation.models.Product>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: :class:`Product
<fixtures.acceptancetestsvalidation.models.Product>` or
:class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>` if
raw=true
:rtype: :class:`Product
<fixtures.acceptancetestsvalidation.models.Product>` or
:class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
:raises:
:class:`ErrorException<fixtures.acceptancetestsvalidation.models.ErrorException>`
"""
# Construct URL
url = '/fakepath/{subscriptionId}/{resourceGroupName}/{id}'
path_format_arguments = {
'subscriptionId': self._serialize.url("self.config.subscription_id", self.config.subscription_id, 'str'),
'resourceGroupName': self._serialize.url("resource_group_name", resource_group_name, 'str', max_length=10, min_length=3, pattern=r'[a-zA-Z0-9]+'),
'id': self._serialize.url("id", id, 'int', maximum=1000, minimum=100, multiple=10)
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
query_parameters['apiVersion'] = self._serialize.query("self.api_version", self.api_version, 'str', pattern=r'\d{2}-\d{2}-\d{4}')
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'Product')
else:
body_content = None
# Construct and send request
request = self._client.put(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise models.ErrorException(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Product', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
def get_with_constant_in_path(
self, custom_headers=None, raw=False, **operation_config):
"""
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: None or
:class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>` if
raw=true
:rtype: None or
:class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
constant_param = "constant"
# Construct URL
url = '/validation/constantsInPath/{constantParam}/value'
path_format_arguments = {
'constantParam': self._serialize.url("constant_param", constant_param, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct and send request
request = self._client.get(url, query_parameters)
response = self._client.send(request, header_parameters, **operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
if raw:
client_raw_response = ClientRawResponse(None, response)
return client_raw_response
def post_with_constant_in_body(
self, body=None, custom_headers=None, raw=False, **operation_config):
"""
:param body:
:type body: :class:`Product
<fixtures.acceptancetestsvalidation.models.Product>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:return: :class:`Product
<fixtures.acceptancetestsvalidation.models.Product>` or
:class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>` if
raw=true
:rtype: :class:`Product
<fixtures.acceptancetestsvalidation.models.Product>` or
:class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
:raises:
:class:`HttpOperationError<msrest.exceptions.HttpOperationError>`
"""
constant_param = "constant"
# Construct URL
url = '/validation/constantsInPath/{constantParam}/value'
path_format_arguments = {
'constantParam': self._serialize.url("constant_param", constant_param, 'str')
}
url = self._client.format_url(url, **path_format_arguments)
# Construct parameters
query_parameters = {}
# Construct headers
header_parameters = {}
header_parameters['Content-Type'] = 'application/json; charset=utf-8'
if custom_headers:
header_parameters.update(custom_headers)
# Construct body
if body is not None:
body_content = self._serialize.body(body, 'Product')
else:
body_content = None
# Construct and send request
request = self._client.post(url, query_parameters)
response = self._client.send(
request, header_parameters, body_content, **operation_config)
if response.status_code not in [200]:
raise HttpOperationError(self._deserialize, response)
deserialized = None
if response.status_code == 200:
deserialized = self._deserialize('Product', response)
if raw:
client_raw_response = ClientRawResponse(deserialized, response)
return client_raw_response
return deserialized
