# Source code for azure.mgmt.datalake.analytics.account.operations.compute_policies_operations

    # coding=utf-8
    # --------------------------------------------------------------------------
    # Copyright (c) Microsoft Corporation. All rights reserved.
    # Licensed under the MIT License. See License.txt in the project root for
    # license information.
    #
    # Code generated by Microsoft (R) AutoRest Code Generator.
    # Changes may cause incorrect behavior and will be lost if the code is
    # regenerated.
    # --------------------------------------------------------------------------

    import uuid
    from msrest.pipeline import ClientRawResponse
    from msrestazure.azure_exceptions import CloudError

    from .. import models

    class ComputePoliciesOperations(object):
        """ComputePoliciesOperations operations.

        :param client: Client for service requests.
        :param config: Configuration of service client.
        :param serializer: An object model serializer.
        :param deserializer: An object model deserializer.
        :ivar api_version: Client Api Version. Constant value: "2016-11-01".
        """

        models = models

        def __init__(self, client, config, serializer, deserializer):

            self._client = client
            self._serialize = serializer
            self._deserialize = deserializer
            self.api_version = "2016-11-01"

            self.config = config

        def list_by_account(
                self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):
            """Lists the Data Lake Analytics compute policies within the specified
            Data Lake Analytics account. An account supports, at most, 50 policies.

            :param resource_group_name: The name of the Azure resource group.
            :type resource_group_name: str
            :param account_name: The name of the Data Lake Analytics account.
            :type account_name: 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: An iterator like instance of ComputePolicy
            :rtype:
             ~azure.mgmt.datalake.analytics.account.models.ComputePolicyPaged[~azure.mgmt.datalake.analytics.account.models.ComputePolicy]
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            def internal_paging(next_link=None, raw=False):

                if not next_link:
                    # Construct URL
                    url = self.list_by_account.metadata['url']
                    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'),
                        'accountName': self._serialize.url("account_name", account_name, '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')

                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, stream=False, **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.ComputePolicyPaged(internal_paging, self._deserialize.dependencies)

            if raw:
                header_dict = {}
                client_raw_response = models.ComputePolicyPaged(internal_paging, self._deserialize.dependencies, header_dict)
                return client_raw_response

            return deserialized
        list_by_account.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/computePolicies'}

        def create_or_update(
                self, resource_group_name, account_name, compute_policy_name, parameters, custom_headers=None, raw=False, **operation_config):
            """Creates or updates the specified compute policy. During update, the
            compute policy with the specified name will be replaced with this new
            compute policy. An account supports, at most, 50 policies.

            :param resource_group_name: The name of the Azure resource group.
            :type resource_group_name: str
            :param account_name: The name of the Data Lake Analytics account.
            :type account_name: str
            :param compute_policy_name: The name of the compute policy to create
             or update.
            :type compute_policy_name: str
            :param parameters: Parameters supplied to create or update the compute
             policy. The max degree of parallelism per job property, min priority
             per job property, or both must be present.
            :type parameters:
             ~azure.mgmt.datalake.analytics.account.models.CreateOrUpdateComputePolicyParameters
            :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: ComputePolicy or ClientRawResponse if raw=true
            :rtype: ~azure.mgmt.datalake.analytics.account.models.ComputePolicy or
             ~msrest.pipeline.ClientRawResponse
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            # Construct URL
            url = self.create_or_update.metadata['url']
            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'),
                'accountName': self._serialize.url("account_name", account_name, 'str'),
                'computePolicyName': self._serialize.url("compute_policy_name", compute_policy_name, '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(parameters, 'CreateOrUpdateComputePolicyParameters')

            # 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]:
                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('ComputePolicy', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized
        create_or_update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/computePolicies/{computePolicyName}'}

        def get(
                self, resource_group_name, account_name, compute_policy_name, custom_headers=None, raw=False, **operation_config):
            """Gets the specified Data Lake Analytics compute policy.

            :param resource_group_name: The name of the Azure resource group.
            :type resource_group_name: str
            :param account_name: The name of the Data Lake Analytics account.
            :type account_name: str
            :param compute_policy_name: The name of the compute policy to
             retrieve.
            :type compute_policy_name: 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: ComputePolicy or ClientRawResponse if raw=true
            :rtype: ~azure.mgmt.datalake.analytics.account.models.ComputePolicy or
             ~msrest.pipeline.ClientRawResponse
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            # Construct URL
            url = self.get.metadata['url']
            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'),
                'accountName': self._serialize.url("account_name", account_name, 'str'),
                'computePolicyName': self._serialize.url("compute_policy_name", compute_policy_name, '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, stream=False, **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('ComputePolicy', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized
        get.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/computePolicies/{computePolicyName}'}

        def update(
                self, resource_group_name, account_name, compute_policy_name, parameters=None, custom_headers=None, raw=False, **operation_config):
            """Updates the specified compute policy.

            :param resource_group_name: The name of the Azure resource group.
            :type resource_group_name: str
            :param account_name: The name of the Data Lake Analytics account.
            :type account_name: str
            :param compute_policy_name: The name of the compute policy to update.
            :type compute_policy_name: str
            :param parameters: Parameters supplied to update the compute policy.
            :type parameters:
             ~azure.mgmt.datalake.analytics.account.models.UpdateComputePolicyParameters
            :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: ComputePolicy or ClientRawResponse if raw=true
            :rtype: ~azure.mgmt.datalake.analytics.account.models.ComputePolicy or
             ~msrest.pipeline.ClientRawResponse
            :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`
            """
            # Construct URL
            url = self.update.metadata['url']
            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'),
                'accountName': self._serialize.url("account_name", account_name, 'str'),
                'computePolicyName': self._serialize.url("compute_policy_name", compute_policy_name, '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
            if parameters is not None:
                body_content = self._serialize.body(parameters, 'UpdateComputePolicyParameters')
            else:
                body_content = None

            # Construct and send request
            request = self._client.patch(url, query_parameters)
            response = self._client.send(
                request, header_parameters, body_content, stream=False, **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('ComputePolicy', response)

            if raw:
                client_raw_response = ClientRawResponse(deserialized, response)
                return client_raw_response

            return deserialized
        update.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/computePolicies/{computePolicyName}'}

        def delete(
                self, resource_group_name, account_name, compute_policy_name, custom_headers=None, raw=False, **operation_config):
            """Deletes the specified compute policy from the specified Data Lake
            Analytics account.

            :param resource_group_name: The name of the Azure resource group.
            :type resource_group_name: str
            :param account_name: The name of the Data Lake Analytics account.
            :type account_name: str
            :param compute_policy_name: The name of the compute policy to delete.
            :type compute_policy_name: 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>`
            """
            # Construct URL
            url = self.delete.metadata['url']
            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'),
                'accountName': self._serialize.url("account_name", account_name, 'str'),
                'computePolicyName': self._serialize.url("compute_policy_name", compute_policy_name, '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.delete(url, query_parameters)
            response = self._client.send(request, header_parameters, stream=False, **operation_config)

            if response.status_code not in [200, 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
        delete.metadata = {'url': '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DataLakeAnalytics/accounts/{accountName}/computePolicies/{computePolicyName}'}