def add(<EOL>self, pool, pool_add_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if pool_add_options is not None:<EOL><INDENT>timeout = pool_add_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_add_options is not None:<EOL><INDENT>client_request_id = pool_add_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_add_options is not None:<EOL><INDENT>return_client_request_id = pool_add_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_add_options is not None:<EOL><INDENT>ocp_date = pool_add_options.ocp_date<EOL><DEDENT>url = self.add.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(pool, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Adds a pool to the specified account.

        When naming pools, avoid including sensitive information such as user
        names or secret project names. This information may appear in telemetry
        logs accessible to Microsoft Support engineers.

        :param pool: The pool to be added.
        :type pool: ~azure.batch.models.PoolAddParameter
        :param pool_add_options: Additional parameters for the operation
        :type pool_add_options: ~azure.batch.models.PoolAddOptions
        :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:`BatchErrorException<azure.batch.models.BatchErrorException>`


def list(<EOL>self, pool_list_options=None, custom_headers=None, raw=False, **operation_config):

filter = None<EOL>if pool_list_options is not None:<EOL><INDENT>filter = pool_list_options.filter<EOL><DEDENT>select = None<EOL>if pool_list_options is not None:<EOL><INDENT>select = pool_list_options.select<EOL><DEDENT>expand = None<EOL>if pool_list_options is not None:<EOL><INDENT>expand = pool_list_options.expand<EOL><DEDENT>max_results = None<EOL>if pool_list_options is not None:<EOL><INDENT>max_results = pool_list_options.max_results<EOL><DEDENT>timeout = None<EOL>if pool_list_options is not None:<EOL><INDENT>timeout = pool_list_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_list_options is not None:<EOL><INDENT>client_request_id = pool_list_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_list_options is not None:<EOL><INDENT>return_client_request_id = pool_list_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_list_options is not None:<EOL><INDENT>ocp_date = pool_list_options.ocp_date<EOL><DEDENT>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if filter is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", filter, '<STR_LIT:str>')<EOL><DEDENT>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", select, '<STR_LIT:str>')<EOL><DEDENT>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", expand, '<STR_LIT:str>')<EOL><DEDENT>if max_results is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", max_results, '<STR_LIT:int>', maximum=<NUM_LIT:1000>, minimum=<NUM_LIT:1>)<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.CloudPoolPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.CloudPoolPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Lists all of the pools in the specified account.

        :param pool_list_options: Additional parameters for the operation
        :type pool_list_options: ~azure.batch.models.PoolListOptions
        :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 CloudPool
        :rtype:
         ~azure.batch.models.CloudPoolPaged[~azure.batch.models.CloudPool]
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


def delete(<EOL>self, pool_id, pool_delete_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if pool_delete_options is not None:<EOL><INDENT>timeout = pool_delete_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_delete_options is not None:<EOL><INDENT>client_request_id = pool_delete_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_delete_options is not None:<EOL><INDENT>return_client_request_id = pool_delete_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_delete_options is not None:<EOL><INDENT>ocp_date = pool_delete_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if pool_delete_options is not None:<EOL><INDENT>if_match = pool_delete_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if pool_delete_options is not None:<EOL><INDENT>if_none_match = pool_delete_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if pool_delete_options is not None:<EOL><INDENT>if_modified_since = pool_delete_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if pool_delete_options is not None:<EOL><INDENT>if_unmodified_since = pool_delete_options.if_unmodified_since<EOL><DEDENT>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", pool_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Deletes a pool from the specified account.

        When you request that a pool be deleted, the following actions occur:
        the pool state is set to deleting; any ongoing resize operation on the
        pool are stopped; the Batch service starts resizing the pool to zero
        nodes; any tasks running on existing nodes are terminated and requeued
        (as if a resize pool operation had been requested with the default
        requeue option); finally, the pool is removed from the system. Because
        running tasks are requeued, the user can rerun these tasks by updating
        their job to target a different pool. The tasks can then run on the new
        pool. If you want to override the requeue behavior, then you should
        call resize pool explicitly to shrink the pool to zero size before
        deleting the pool. If you call an Update, Patch or Delete API on a pool
        in the deleting state, it will fail with HTTP status code 409 with
        error code PoolBeingDeleted.

        :param pool_id: The ID of the pool to delete.
        :type pool_id: str
        :param pool_delete_options: Additional parameters for the operation
        :type pool_delete_options: ~azure.batch.models.PoolDeleteOptions
        :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:`BatchErrorException<azure.batch.models.BatchErrorException>`


def exists(<EOL>self, pool_id, pool_exists_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if pool_exists_options is not None:<EOL><INDENT>timeout = pool_exists_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_exists_options is not None:<EOL><INDENT>client_request_id = pool_exists_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_exists_options is not None:<EOL><INDENT>return_client_request_id = pool_exists_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_exists_options is not None:<EOL><INDENT>ocp_date = pool_exists_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if pool_exists_options is not None:<EOL><INDENT>if_match = pool_exists_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if pool_exists_options is not None:<EOL><INDENT>if_none_match = pool_exists_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if pool_exists_options is not None:<EOL><INDENT>if_modified_since = pool_exists_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if pool_exists_options is not None:<EOL><INDENT>if_unmodified_since = pool_exists_options.if_unmodified_since<EOL><DEDENT>url = self.exists.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", pool_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>request = self._client.head(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>, <NUM_LIT>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = (response.status_code == <NUM_LIT:200>)<EOL>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Gets basic properties of a pool.

        :param pool_id: The ID of the pool to get.
        :type pool_id: str
        :param pool_exists_options: Additional parameters for the operation
        :type pool_exists_options: ~azure.batch.models.PoolExistsOptions
        :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: bool or ClientRawResponse if raw=true
        :rtype: bool or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


def get(<EOL>self, pool_id, pool_get_options=None, custom_headers=None, raw=False, **operation_config):

select = None<EOL>if pool_get_options is not None:<EOL><INDENT>select = pool_get_options.select<EOL><DEDENT>expand = None<EOL>if pool_get_options is not None:<EOL><INDENT>expand = pool_get_options.expand<EOL><DEDENT>timeout = None<EOL>if pool_get_options is not None:<EOL><INDENT>timeout = pool_get_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_get_options is not None:<EOL><INDENT>client_request_id = pool_get_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_get_options is not None:<EOL><INDENT>return_client_request_id = pool_get_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_get_options is not None:<EOL><INDENT>ocp_date = pool_get_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if pool_get_options is not None:<EOL><INDENT>if_match = pool_get_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if pool_get_options is not None:<EOL><INDENT>if_none_match = pool_get_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if pool_get_options is not None:<EOL><INDENT>if_modified_since = pool_get_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if pool_get_options is not None:<EOL><INDENT>if_unmodified_since = pool_get_options.if_unmodified_since<EOL><DEDENT>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", pool_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", select, '<STR_LIT:str>')<EOL><DEDENT>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", expand, '<STR_LIT:str>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Gets information about the specified pool.

        :param pool_id: The ID of the pool to get.
        :type pool_id: str
        :param pool_get_options: Additional parameters for the operation
        :type pool_get_options: ~azure.batch.models.PoolGetOptions
        :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: CloudPool or ClientRawResponse if raw=true
        :rtype: ~azure.batch.models.CloudPool or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


def patch(<EOL>self, pool_id, pool_patch_parameter, pool_patch_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if pool_patch_options is not None:<EOL><INDENT>timeout = pool_patch_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_patch_options is not None:<EOL><INDENT>client_request_id = pool_patch_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_patch_options is not None:<EOL><INDENT>return_client_request_id = pool_patch_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_patch_options is not None:<EOL><INDENT>ocp_date = pool_patch_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if pool_patch_options is not None:<EOL><INDENT>if_match = pool_patch_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if pool_patch_options is not None:<EOL><INDENT>if_none_match = pool_patch_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if pool_patch_options is not None:<EOL><INDENT>if_modified_since = pool_patch_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if pool_patch_options is not None:<EOL><INDENT>if_unmodified_since = pool_patch_options.if_unmodified_since<EOL><DEDENT>url = self.patch.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", pool_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(pool_patch_parameter, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Updates the properties of the specified pool.

        This only replaces the pool properties specified in the request. For
        example, if the pool has a start task associated with it, and a request
        does not specify a start task element, then the pool keeps the existing
        start task.

        :param pool_id: The ID of the pool to update.
        :type pool_id: str
        :param pool_patch_parameter: The parameters for the request.
        :type pool_patch_parameter: ~azure.batch.models.PoolPatchParameter
        :param pool_patch_options: Additional parameters for the operation
        :type pool_patch_options: ~azure.batch.models.PoolPatchOptions
        :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:`BatchErrorException<azure.batch.models.BatchErrorException>`


def disable_auto_scale(<EOL>self, pool_id, pool_disable_auto_scale_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if pool_disable_auto_scale_options is not None:<EOL><INDENT>timeout = pool_disable_auto_scale_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_disable_auto_scale_options is not None:<EOL><INDENT>client_request_id = pool_disable_auto_scale_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_disable_auto_scale_options is not None:<EOL><INDENT>return_client_request_id = pool_disable_auto_scale_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_disable_auto_scale_options is not None:<EOL><INDENT>ocp_date = pool_disable_auto_scale_options.ocp_date<EOL><DEDENT>url = self.disable_auto_scale.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", pool_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Disables automatic scaling for a pool.

        :param pool_id: The ID of the pool on which to disable automatic
         scaling.
        :type pool_id: str
        :param pool_disable_auto_scale_options: Additional parameters for the
         operation
        :type pool_disable_auto_scale_options:
         ~azure.batch.models.PoolDisableAutoScaleOptions
        :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:`BatchErrorException<azure.batch.models.BatchErrorException>`


def enable_auto_scale(<EOL>self, pool_id, auto_scale_formula=None, auto_scale_evaluation_interval=None, pool_enable_auto_scale_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if pool_enable_auto_scale_options is not None:<EOL><INDENT>timeout = pool_enable_auto_scale_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_enable_auto_scale_options is not None:<EOL><INDENT>client_request_id = pool_enable_auto_scale_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_enable_auto_scale_options is not None:<EOL><INDENT>return_client_request_id = pool_enable_auto_scale_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_enable_auto_scale_options is not None:<EOL><INDENT>ocp_date = pool_enable_auto_scale_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if pool_enable_auto_scale_options is not None:<EOL><INDENT>if_match = pool_enable_auto_scale_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if pool_enable_auto_scale_options is not None:<EOL><INDENT>if_none_match = pool_enable_auto_scale_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if pool_enable_auto_scale_options is not None:<EOL><INDENT>if_modified_since = pool_enable_auto_scale_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if pool_enable_auto_scale_options is not None:<EOL><INDENT>if_unmodified_since = pool_enable_auto_scale_options.if_unmodified_since<EOL><DEDENT>pool_enable_auto_scale_parameter = models.PoolEnableAutoScaleParameter(auto_scale_formula=auto_scale_formula, auto_scale_evaluation_interval=auto_scale_evaluation_interval)<EOL>url = self.enable_auto_scale.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", pool_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(pool_enable_auto_scale_parameter, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Enables automatic scaling for a pool.

        You cannot enable automatic scaling on a pool if a resize operation is
        in progress on the pool. If automatic scaling of the pool is currently
        disabled, you must specify a valid autoscale formula as part of the
        request. If automatic scaling of the pool is already enabled, you may
        specify a new autoscale formula and/or a new evaluation interval. You
        cannot call this API for the same pool more than once every 30 seconds.

        :param pool_id: The ID of the pool on which to enable automatic
         scaling.
        :type pool_id: str
        :param auto_scale_formula: The formula for the desired number of
         compute nodes in the pool. The formula is checked for validity before
         it is applied to the pool. If the formula is not valid, the Batch
         service rejects the request with detailed error information. For more
         information about specifying this formula, see Automatically scale
         compute nodes in an Azure Batch pool
         (https://azure.microsoft.com/en-us/documentation/articles/batch-automatic-scaling).
        :type auto_scale_formula: str
        :param auto_scale_evaluation_interval: The time interval at which to
         automatically adjust the pool size according to the autoscale formula.
         The default value is 15 minutes. The minimum and maximum value are 5
         minutes and 168 hours respectively. If you specify a value less than 5
         minutes or greater than 168 hours, the Batch service rejects the
         request with an invalid property value error; if you are calling the
         REST API directly, the HTTP status code is 400 (Bad Request). If you
         specify a new interval, then the existing autoscale evaluation
         schedule will be stopped and a new autoscale evaluation schedule will
         be started, with its starting time being the time when this request
         was issued.
        :type auto_scale_evaluation_interval: timedelta
        :param pool_enable_auto_scale_options: Additional parameters for the
         operation
        :type pool_enable_auto_scale_options:
         ~azure.batch.models.PoolEnableAutoScaleOptions
        :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:`BatchErrorException<azure.batch.models.BatchErrorException>`


def evaluate_auto_scale(<EOL>self, pool_id, auto_scale_formula, pool_evaluate_auto_scale_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if pool_evaluate_auto_scale_options is not None:<EOL><INDENT>timeout = pool_evaluate_auto_scale_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_evaluate_auto_scale_options is not None:<EOL><INDENT>client_request_id = pool_evaluate_auto_scale_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_evaluate_auto_scale_options is not None:<EOL><INDENT>return_client_request_id = pool_evaluate_auto_scale_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_evaluate_auto_scale_options is not None:<EOL><INDENT>ocp_date = pool_evaluate_auto_scale_options.ocp_date<EOL><DEDENT>pool_evaluate_auto_scale_parameter = models.PoolEvaluateAutoScaleParameter(auto_scale_formula=auto_scale_formula)<EOL>url = self.evaluate_auto_scale.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", pool_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(pool_evaluate_auto_scale_parameter, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Gets the result of evaluating an automatic scaling formula on the pool.

        This API is primarily for validating an autoscale formula, as it simply
        returns the result without applying the formula to the pool. The pool
        must have auto scaling enabled in order to evaluate a formula.

        :param pool_id: The ID of the pool on which to evaluate the automatic
         scaling formula.
        :type pool_id: str
        :param auto_scale_formula: The formula for the desired number of
         compute nodes in the pool. The formula is validated and its results
         calculated, but it is not applied to the pool. To apply the formula to
         the pool, 'Enable automatic scaling on a pool'. For more information
         about specifying this formula, see Automatically scale compute nodes
         in an Azure Batch pool
         (https://azure.microsoft.com/en-us/documentation/articles/batch-automatic-scaling).
        :type auto_scale_formula: str
        :param pool_evaluate_auto_scale_options: Additional parameters for the
         operation
        :type pool_evaluate_auto_scale_options:
         ~azure.batch.models.PoolEvaluateAutoScaleOptions
        :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: AutoScaleRun or ClientRawResponse if raw=true
        :rtype: ~azure.batch.models.AutoScaleRun or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


def resize(<EOL>self, pool_id, pool_resize_parameter, pool_resize_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if pool_resize_options is not None:<EOL><INDENT>timeout = pool_resize_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_resize_options is not None:<EOL><INDENT>client_request_id = pool_resize_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_resize_options is not None:<EOL><INDENT>return_client_request_id = pool_resize_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_resize_options is not None:<EOL><INDENT>ocp_date = pool_resize_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if pool_resize_options is not None:<EOL><INDENT>if_match = pool_resize_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if pool_resize_options is not None:<EOL><INDENT>if_none_match = pool_resize_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if pool_resize_options is not None:<EOL><INDENT>if_modified_since = pool_resize_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if pool_resize_options is not None:<EOL><INDENT>if_unmodified_since = pool_resize_options.if_unmodified_since<EOL><DEDENT>url = self.resize.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", pool_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(pool_resize_parameter, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Changes the number of compute nodes that are assigned to a pool.

        You can only resize a pool when its allocation state is steady. If the
        pool is already resizing, the request fails with status code 409. When
        you resize a pool, the pool's allocation state changes from steady to
        resizing. You cannot resize pools which are configured for automatic
        scaling. If you try to do this, the Batch service returns an error 409.
        If you resize a pool downwards, the Batch service chooses which nodes
        to remove. To remove specific nodes, use the pool remove nodes API
        instead.

        :param pool_id: The ID of the pool to resize.
        :type pool_id: str
        :param pool_resize_parameter: The parameters for the request.
        :type pool_resize_parameter: ~azure.batch.models.PoolResizeParameter
        :param pool_resize_options: Additional parameters for the operation
        :type pool_resize_options: ~azure.batch.models.PoolResizeOptions
        :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:`BatchErrorException<azure.batch.models.BatchErrorException>`


def stop_resize(<EOL>self, pool_id, pool_stop_resize_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if pool_stop_resize_options is not None:<EOL><INDENT>timeout = pool_stop_resize_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_stop_resize_options is not None:<EOL><INDENT>client_request_id = pool_stop_resize_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_stop_resize_options is not None:<EOL><INDENT>return_client_request_id = pool_stop_resize_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_stop_resize_options is not None:<EOL><INDENT>ocp_date = pool_stop_resize_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if pool_stop_resize_options is not None:<EOL><INDENT>if_match = pool_stop_resize_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if pool_stop_resize_options is not None:<EOL><INDENT>if_none_match = pool_stop_resize_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if pool_stop_resize_options is not None:<EOL><INDENT>if_modified_since = pool_stop_resize_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if pool_stop_resize_options is not None:<EOL><INDENT>if_unmodified_since = pool_stop_resize_options.if_unmodified_since<EOL><DEDENT>url = self.stop_resize.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", pool_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>request = self._client.post(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Stops an ongoing resize operation on the pool.

        This does not restore the pool to its previous state before the resize
        operation: it only stops any further changes being made, and the pool
        maintains its current state. After stopping, the pool stabilizes at the
        number of nodes it was at when the stop operation was done. During the
        stop operation, the pool allocation state changes first to stopping and
        then to steady. A resize operation need not be an explicit resize pool
        request; this API can also be used to halt the initial sizing of the
        pool when it is created.

        :param pool_id: The ID of the pool whose resizing you want to stop.
        :type pool_id: str
        :param pool_stop_resize_options: Additional parameters for the
         operation
        :type pool_stop_resize_options:
         ~azure.batch.models.PoolStopResizeOptions
        :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:`BatchErrorException<azure.batch.models.BatchErrorException>`


def update_properties(<EOL>self, pool_id, pool_update_properties_parameter, pool_update_properties_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if pool_update_properties_options is not None:<EOL><INDENT>timeout = pool_update_properties_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_update_properties_options is not None:<EOL><INDENT>client_request_id = pool_update_properties_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_update_properties_options is not None:<EOL><INDENT>return_client_request_id = pool_update_properties_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_update_properties_options is not None:<EOL><INDENT>ocp_date = pool_update_properties_options.ocp_date<EOL><DEDENT>url = self.update_properties.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", pool_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(pool_update_properties_parameter, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Updates the properties of the specified pool.

        This fully replaces all the updateable properties of the pool. For
        example, if the pool has a start task associated with it and if start
        task is not specified with this request, then the Batch service will
        remove the existing start task.

        :param pool_id: The ID of the pool to update.
        :type pool_id: str
        :param pool_update_properties_parameter: The parameters for the
         request.
        :type pool_update_properties_parameter:
         ~azure.batch.models.PoolUpdatePropertiesParameter
        :param pool_update_properties_options: Additional parameters for the
         operation
        :type pool_update_properties_options:
         ~azure.batch.models.PoolUpdatePropertiesOptions
        :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:`BatchErrorException<azure.batch.models.BatchErrorException>`


def remove_nodes(<EOL>self, pool_id, node_remove_parameter, pool_remove_nodes_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if pool_remove_nodes_options is not None:<EOL><INDENT>timeout = pool_remove_nodes_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if pool_remove_nodes_options is not None:<EOL><INDENT>client_request_id = pool_remove_nodes_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if pool_remove_nodes_options is not None:<EOL><INDENT>return_client_request_id = pool_remove_nodes_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if pool_remove_nodes_options is not None:<EOL><INDENT>ocp_date = pool_remove_nodes_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if pool_remove_nodes_options is not None:<EOL><INDENT>if_match = pool_remove_nodes_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if pool_remove_nodes_options is not None:<EOL><INDENT>if_none_match = pool_remove_nodes_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if pool_remove_nodes_options is not None:<EOL><INDENT>if_modified_since = pool_remove_nodes_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if pool_remove_nodes_options is not None:<EOL><INDENT>if_unmodified_since = pool_remove_nodes_options.if_unmodified_since<EOL><DEDENT>url = self.remove_nodes.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", pool_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(node_remove_parameter, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Removes compute nodes from the specified pool.

        This operation can only run when the allocation state of the pool is
        steady. When this operation runs, the allocation state changes from
        steady to resizing.

        :param pool_id: The ID of the pool from which you want to remove
         nodes.
        :type pool_id: str
        :param node_remove_parameter: The parameters for the request.
        :type node_remove_parameter: ~azure.batch.models.NodeRemoveParameter
        :param pool_remove_nodes_options: Additional parameters for the
         operation
        :type pool_remove_nodes_options:
         ~azure.batch.models.PoolRemoveNodesOptions
        :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:`BatchErrorException<azure.batch.models.BatchErrorException>`


def list(<EOL>self, application_list_options=None, custom_headers=None, raw=False, **operation_config):

max_results = None<EOL>if application_list_options is not None:<EOL><INDENT>max_results = application_list_options.max_results<EOL><DEDENT>timeout = None<EOL>if application_list_options is not None:<EOL><INDENT>timeout = application_list_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if application_list_options is not None:<EOL><INDENT>client_request_id = application_list_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if application_list_options is not None:<EOL><INDENT>return_client_request_id = application_list_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if application_list_options is not None:<EOL><INDENT>ocp_date = application_list_options.ocp_date<EOL><DEDENT>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if max_results is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", max_results, '<STR_LIT:int>', maximum=<NUM_LIT:1000>, minimum=<NUM_LIT:1>)<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ApplicationSummaryPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ApplicationSummaryPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Lists all of the applications available in the specified account.

        This operation returns only applications and versions that are
        available for use on compute nodes; that is, that can be used in an
        application package reference. For administrator information about
        applications and versions that are not yet available to compute nodes,
        use the Azure portal or the Azure Resource Manager API.

        :param application_list_options: Additional parameters for the
         operation
        :type application_list_options:
         ~azure.batch.models.ApplicationListOptions
        :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 ApplicationSummary
        :rtype:
         ~azure.batch.models.ApplicationSummaryPaged[~azure.batch.models.ApplicationSummary]
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


def get(<EOL>self, application_id, application_get_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if application_get_options is not None:<EOL><INDENT>timeout = application_get_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if application_get_options is not None:<EOL><INDENT>client_request_id = application_get_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if application_get_options is not None:<EOL><INDENT>return_client_request_id = application_get_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if application_get_options is not None:<EOL><INDENT>ocp_date = application_get_options.ocp_date<EOL><DEDENT>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", application_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Gets information about the specified application.

        This operation returns only applications and versions that are
        available for use on compute nodes; that is, that can be used in an
        application package reference. For administrator information about
        applications and versions that are not yet available to compute nodes,
        use the Azure portal or the Azure Resource Manager API.

        :param application_id: The ID of the application.
        :type application_id: str
        :param application_get_options: Additional parameters for the
         operation
        :type application_get_options:
         ~azure.batch.models.ApplicationGetOptions
        :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: ApplicationSummary or ClientRawResponse if raw=true
        :rtype: ~azure.batch.models.ApplicationSummary or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


def get_all_lifetime_statistics(<EOL>self, job_get_all_lifetime_statistics_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if job_get_all_lifetime_statistics_options is not None:<EOL><INDENT>timeout = job_get_all_lifetime_statistics_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if job_get_all_lifetime_statistics_options is not None:<EOL><INDENT>client_request_id = job_get_all_lifetime_statistics_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if job_get_all_lifetime_statistics_options is not None:<EOL><INDENT>return_client_request_id = job_get_all_lifetime_statistics_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if job_get_all_lifetime_statistics_options is not None:<EOL><INDENT>ocp_date = job_get_all_lifetime_statistics_options.ocp_date<EOL><DEDENT>url = self.get_all_lifetime_statistics.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Gets lifetime summary statistics for all of the jobs in the specified
        account.

        Statistics are aggregated across all jobs that have ever existed in the
        account, from account creation to the last update time of the
        statistics. The statistics may not be immediately available. The Batch
        service performs periodic roll-up of statistics. The typical delay is
        about 30 minutes.

        :param job_get_all_lifetime_statistics_options: Additional parameters
         for the operation
        :type job_get_all_lifetime_statistics_options:
         ~azure.batch.models.JobGetAllLifetimeStatisticsOptions
        :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: JobStatistics or ClientRawResponse if raw=true
        :rtype: ~azure.batch.models.JobStatistics or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


def delete(<EOL>self, job_id, job_delete_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if job_delete_options is not None:<EOL><INDENT>timeout = job_delete_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if job_delete_options is not None:<EOL><INDENT>client_request_id = job_delete_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if job_delete_options is not None:<EOL><INDENT>return_client_request_id = job_delete_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if job_delete_options is not None:<EOL><INDENT>ocp_date = job_delete_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if job_delete_options is not None:<EOL><INDENT>if_match = job_delete_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if job_delete_options is not None:<EOL><INDENT>if_none_match = job_delete_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if job_delete_options is not None:<EOL><INDENT>if_modified_since = job_delete_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if job_delete_options is not None:<EOL><INDENT>if_unmodified_since = job_delete_options.if_unmodified_since<EOL><DEDENT>url = self.delete.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", job_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>request = self._client.delete(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Deletes a job.

        Deleting a job also deletes all tasks that are part of that job, and
        all job statistics. This also overrides the retention period for task
        data; that is, if the job contains tasks which are still retained on
        compute nodes, the Batch services deletes those tasks' working
        directories and all their contents.  When a Delete Job request is
        received, the Batch service sets the job to the deleting state. All
        update operations on a job that is in deleting state will fail with
        status code 409 (Conflict), with additional information indicating that
        the job is being deleted.

        :param job_id: The ID of the job to delete.
        :type job_id: str
        :param job_delete_options: Additional parameters for the operation
        :type job_delete_options: ~azure.batch.models.JobDeleteOptions
        :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:`BatchErrorException<azure.batch.models.BatchErrorException>`


def get(<EOL>self, job_id, job_get_options=None, custom_headers=None, raw=False, **operation_config):

select = None<EOL>if job_get_options is not None:<EOL><INDENT>select = job_get_options.select<EOL><DEDENT>expand = None<EOL>if job_get_options is not None:<EOL><INDENT>expand = job_get_options.expand<EOL><DEDENT>timeout = None<EOL>if job_get_options is not None:<EOL><INDENT>timeout = job_get_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if job_get_options is not None:<EOL><INDENT>client_request_id = job_get_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if job_get_options is not None:<EOL><INDENT>return_client_request_id = job_get_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if job_get_options is not None:<EOL><INDENT>ocp_date = job_get_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if job_get_options is not None:<EOL><INDENT>if_match = job_get_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if job_get_options is not None:<EOL><INDENT>if_none_match = job_get_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if job_get_options is not None:<EOL><INDENT>if_modified_since = job_get_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if job_get_options is not None:<EOL><INDENT>if_unmodified_since = job_get_options.if_unmodified_since<EOL><DEDENT>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", job_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if select is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", select, '<STR_LIT:str>')<EOL><DEDENT>if expand is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", expand, '<STR_LIT:str>')<EOL><DEDENT>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>header_dict = {}<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL>header_dict = {<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>}<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>client_raw_response.add_headers(header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Gets information about the specified job.

        :param job_id: The ID of the job.
        :type job_id: str
        :param job_get_options: Additional parameters for the operation
        :type job_get_options: ~azure.batch.models.JobGetOptions
        :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: CloudJob or ClientRawResponse if raw=true
        :rtype: ~azure.batch.models.CloudJob or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


def patch(<EOL>self, job_id, job_patch_parameter, job_patch_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if job_patch_options is not None:<EOL><INDENT>timeout = job_patch_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if job_patch_options is not None:<EOL><INDENT>client_request_id = job_patch_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if job_patch_options is not None:<EOL><INDENT>return_client_request_id = job_patch_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if job_patch_options is not None:<EOL><INDENT>ocp_date = job_patch_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if job_patch_options is not None:<EOL><INDENT>if_match = job_patch_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if job_patch_options is not None:<EOL><INDENT>if_none_match = job_patch_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if job_patch_options is not None:<EOL><INDENT>if_modified_since = job_patch_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if job_patch_options is not None:<EOL><INDENT>if_unmodified_since = job_patch_options.if_unmodified_since<EOL><DEDENT>url = self.patch.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.batch_url, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", job_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>if timeout is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", timeout, '<STR_LIT:int>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>if client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", client_request_id, '<STR_LIT:str>')<EOL><DEDENT>if return_client_request_id is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", return_client_request_id, '<STR_LIT:bool>')<EOL><DEDENT>if ocp_date is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_date, '<STR_LIT>')<EOL><DEDENT>if if_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_match, '<STR_LIT:str>')<EOL><DEDENT>if if_none_match is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_none_match, '<STR_LIT:str>')<EOL><DEDENT>if if_modified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_modified_since, '<STR_LIT>')<EOL><DEDENT>if if_unmodified_since is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", if_unmodified_since, '<STR_LIT>')<EOL><DEDENT>body_content = self._serialize.body(job_patch_parameter, '<STR_LIT>')<EOL>request = self._client.patch(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.BatchErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Updates the properties of the specified job.

        This replaces only the job properties specified in the request. For
        example, if the job has constraints, and a request does not specify the
        constraints element, then the job keeps the existing constraints.

        :param job_id: The ID of the job whose properties you want to update.
        :type job_id: str
        :param job_patch_parameter: The parameters for the request.
        :type job_patch_parameter: ~azure.batch.models.JobPatchParameter
        :param job_patch_options: Additional parameters for the operation
        :type job_patch_options: ~azure.batch.models.JobPatchOptions
        :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:`BatchErrorException<azure.batch.models.BatchErrorException>`