def upload_batch_service_logs(<EOL>self, pool_id, node_id, upload_batch_service_logs_configuration, compute_node_upload_batch_service_logs_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if compute_node_upload_batch_service_logs_options is not None:<EOL><INDENT>timeout = compute_node_upload_batch_service_logs_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if compute_node_upload_batch_service_logs_options is not None:<EOL><INDENT>client_request_id = compute_node_upload_batch_service_logs_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if compute_node_upload_batch_service_logs_options is not None:<EOL><INDENT>return_client_request_id = compute_node_upload_batch_service_logs_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if compute_node_upload_batch_service_logs_options is not None:<EOL><INDENT>ocp_date = compute_node_upload_batch_service_logs_options.ocp_date<EOL><DEDENT>url = self.upload_batch_service_logs.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>'<STR_LIT>': self._serialize.url("<STR_LIT>", node_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(upload_batch_service_logs_configuration, '<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>}<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>

Upload Azure Batch service log files from the specified compute node to
        Azure Blob Storage.

        This is for gathering Azure Batch service log files in an automated
        fashion from nodes if you are experiencing an error and wish to
        escalate to Azure support. The Azure Batch service log files should be
        shared with Azure support to aid in debugging issues with the Batch
        service.

        :param pool_id: The ID of the pool that contains the compute node.
        :type pool_id: str
        :param node_id: The ID of the compute node from which you want to
         upload the Azure Batch service log files.
        :type node_id: str
        :param upload_batch_service_logs_configuration: The Azure Batch
         service log files upload configuration.
        :type upload_batch_service_logs_configuration:
         ~azure.batch.models.UploadBatchServiceLogsConfiguration
        :param compute_node_upload_batch_service_logs_options: Additional
         parameters for the operation
        :type compute_node_upload_batch_service_logs_options:
         ~azure.batch.models.ComputeNodeUploadBatchServiceLogsOptions
        :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: UploadBatchServiceLogsResult or ClientRawResponse if raw=true
        :rtype: ~azure.batch.models.UploadBatchServiceLogsResult or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


def add_user(<EOL>self, pool_id, node_id, user, compute_node_add_user_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if compute_node_add_user_options is not None:<EOL><INDENT>timeout = compute_node_add_user_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if compute_node_add_user_options is not None:<EOL><INDENT>client_request_id = compute_node_add_user_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if compute_node_add_user_options is not None:<EOL><INDENT>return_client_request_id = compute_node_add_user_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if compute_node_add_user_options is not None:<EOL><INDENT>ocp_date = compute_node_add_user_options.ocp_date<EOL><DEDENT>url = self.add_user.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>'<STR_LIT>': self._serialize.url("<STR_LIT>", node_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(user, '<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 user account to the specified compute node.

        You can add a user account to a node only when it is in the idle or
        running state.

        :param pool_id: The ID of the pool that contains the compute node.
        :type pool_id: str
        :param node_id: The ID of the machine on which you want to create a
         user account.
        :type node_id: str
        :param user: The user account to be created.
        :type user: ~azure.batch.models.ComputeNodeUser
        :param compute_node_add_user_options: Additional parameters for the
         operation
        :type compute_node_add_user_options:
         ~azure.batch.models.ComputeNodeAddUserOptions
        :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_remote_desktop(<EOL>self, pool_id, node_id, compute_node_get_remote_desktop_options=None, custom_headers=None, raw=False, callback=None, **operation_config):

timeout = None<EOL>if compute_node_get_remote_desktop_options is not None:<EOL><INDENT>timeout = compute_node_get_remote_desktop_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if compute_node_get_remote_desktop_options is not None:<EOL><INDENT>client_request_id = compute_node_get_remote_desktop_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if compute_node_get_remote_desktop_options is not None:<EOL><INDENT>return_client_request_id = compute_node_get_remote_desktop_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if compute_node_get_remote_desktop_options is not None:<EOL><INDENT>ocp_date = compute_node_get_remote_desktop_options.ocp_date<EOL><DEDENT>url = self.get_remote_desktop.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>'<STR_LIT>': self._serialize.url("<STR_LIT>", node_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=True, **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._client.stream_download(response, callback)<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 the Remote Desktop Protocol file for the specified compute node.

        Before you can access a node by using the RDP file, you must create a
        user account on the node. This API can only be invoked on pools created
        with a cloud service configuration. For pools created with a virtual
        machine configuration, see the GetRemoteLoginSettings API.

        :param pool_id: The ID of the pool that contains the compute node.
        :type pool_id: str
        :param node_id: The ID of the compute node for which you want to get
         the Remote Desktop Protocol file.
        :type node_id: str
        :param compute_node_get_remote_desktop_options: Additional parameters
         for the operation
        :type compute_node_get_remote_desktop_options:
         ~azure.batch.models.ComputeNodeGetRemoteDesktopOptions
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param callback: When specified, will be called with each chunk of
         data that is streamed. The callback should take two arguments, the
         bytes of the current chunk of data and the response object. If the
         data is uploading, response will be None.
        :type callback: Callable[Bytes, response=None]
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: object or ClientRawResponse if raw=true
        :rtype: Generator or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


def update_user(<EOL>self, pool_id, node_id, user_name, node_update_user_parameter, compute_node_update_user_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if compute_node_update_user_options is not None:<EOL><INDENT>timeout = compute_node_update_user_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if compute_node_update_user_options is not None:<EOL><INDENT>client_request_id = compute_node_update_user_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if compute_node_update_user_options is not None:<EOL><INDENT>return_client_request_id = compute_node_update_user_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if compute_node_update_user_options is not None:<EOL><INDENT>ocp_date = compute_node_update_user_options.ocp_date<EOL><DEDENT>url = self.update_user.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>'<STR_LIT>': self._serialize.url("<STR_LIT>", node_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", user_name, '<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(node_update_user_parameter, '<STR_LIT>')<EOL>request = self._client.put(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 password and expiration time of a user account on the
        specified compute node.

        This operation replaces of all the updateable properties of the
        account. For example, if the expiryTime element is not specified, the
        current value is replaced with the default value, not left unmodified.
        You can update a user account on a node only when it is in the idle or
        running state.

        :param pool_id: The ID of the pool that contains the compute node.
        :type pool_id: str
        :param node_id: The ID of the machine on which you want to update a
         user account.
        :type node_id: str
        :param user_name: The name of the user account to update.
        :type user_name: str
        :param node_update_user_parameter: The parameters for the request.
        :type node_update_user_parameter:
         ~azure.batch.models.NodeUpdateUserParameter
        :param compute_node_update_user_options: Additional parameters for the
         operation
        :type compute_node_update_user_options:
         ~azure.batch.models.ComputeNodeUpdateUserOptions
        :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_properties_from_compute_node(<EOL>self, pool_id, node_id, file_path, file_get_properties_from_compute_node_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if file_get_properties_from_compute_node_options is not None:<EOL><INDENT>timeout = file_get_properties_from_compute_node_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if file_get_properties_from_compute_node_options is not None:<EOL><INDENT>client_request_id = file_get_properties_from_compute_node_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if file_get_properties_from_compute_node_options is not None:<EOL><INDENT>return_client_request_id = file_get_properties_from_compute_node_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if file_get_properties_from_compute_node_options is not None:<EOL><INDENT>ocp_date = file_get_properties_from_compute_node_options.ocp_date<EOL><DEDENT>if_modified_since = None<EOL>if file_get_properties_from_compute_node_options is not None:<EOL><INDENT>if_modified_since = file_get_properties_from_compute_node_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if file_get_properties_from_compute_node_options is not None:<EOL><INDENT>if_unmodified_since = file_get_properties_from_compute_node_options.if_unmodified_since<EOL><DEDENT>url = self.get_properties_from_compute_node.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>'<STR_LIT>': self._serialize.url("<STR_LIT>", node_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", file_path, '<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_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>]:<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>',<EOL>'<STR_LIT>': '<STR_LIT:bool>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT:Content-Type>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Gets the properties of the specified compute node file.

        :param pool_id: The ID of the pool that contains the compute node.
        :type pool_id: str
        :param node_id: The ID of the compute node that contains the file.
        :type node_id: str
        :param file_path: The path to the compute node file that you want to
         get the properties of.
        :type file_path: str
        :param file_get_properties_from_compute_node_options: Additional
         parameters for the operation
        :type file_get_properties_from_compute_node_options:
         ~azure.batch.models.FileGetPropertiesFromComputeNodeOptions
        :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_from_task(<EOL>self, job_id, task_id, file_path, file_get_from_task_options=None, custom_headers=None, raw=False, callback=None, **operation_config):

timeout = None<EOL>if file_get_from_task_options is not None:<EOL><INDENT>timeout = file_get_from_task_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if file_get_from_task_options is not None:<EOL><INDENT>client_request_id = file_get_from_task_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if file_get_from_task_options is not None:<EOL><INDENT>return_client_request_id = file_get_from_task_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if file_get_from_task_options is not None:<EOL><INDENT>ocp_date = file_get_from_task_options.ocp_date<EOL><DEDENT>ocp_range = None<EOL>if file_get_from_task_options is not None:<EOL><INDENT>ocp_range = file_get_from_task_options.ocp_range<EOL><DEDENT>if_modified_since = None<EOL>if file_get_from_task_options is not None:<EOL><INDENT>if_modified_since = file_get_from_task_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if file_get_from_task_options is not None:<EOL><INDENT>if_unmodified_since = file_get_from_task_options.if_unmodified_since<EOL><DEDENT>url = self.get_from_task.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>'<STR_LIT>': self._serialize.url("<STR_LIT>", task_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", file_path, '<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>if ocp_range is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", ocp_range, '<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=True, **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._client.stream_download(response, callback)<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>',<EOL>'<STR_LIT>': '<STR_LIT:bool>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>'<STR_LIT:Content-Type>': '<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>

Returns the content of the specified task file.

        :param job_id: The ID of the job that contains the task.
        :type job_id: str
        :param task_id: The ID of the task whose file you want to retrieve.
        :type task_id: str
        :param file_path: The path to the task file that you want to get the
         content of.
        :type file_path: str
        :param file_get_from_task_options: Additional parameters for the
         operation
        :type file_get_from_task_options:
         ~azure.batch.models.FileGetFromTaskOptions
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param callback: When specified, will be called with each chunk of
         data that is streamed. The callback should take two arguments, the
         bytes of the current chunk of data and the response object. If the
         data is uploading, response will be None.
        :type callback: Callable[Bytes, response=None]
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: object or ClientRawResponse if raw=true
        :rtype: Generator or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


def get(<EOL>self, thumbprint_algorithm, thumbprint, certificate_get_options=None, custom_headers=None, raw=False, **operation_config):

select = None<EOL>if certificate_get_options is not None:<EOL><INDENT>select = certificate_get_options.select<EOL><DEDENT>timeout = None<EOL>if certificate_get_options is not None:<EOL><INDENT>timeout = certificate_get_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if certificate_get_options is not None:<EOL><INDENT>client_request_id = certificate_get_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if certificate_get_options is not None:<EOL><INDENT>return_client_request_id = certificate_get_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if certificate_get_options is not None:<EOL><INDENT>ocp_date = certificate_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>", thumbprint_algorithm, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", thumbprint, '<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 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 certificate.

        :param thumbprint_algorithm: The algorithm used to derive the
         thumbprint parameter. This must be sha1.
        :type thumbprint_algorithm: str
        :param thumbprint: The thumbprint of the certificate to get.
        :type thumbprint: str
        :param certificate_get_options: Additional parameters for the
         operation
        :type certificate_get_options:
         ~azure.batch.models.CertificateGetOptions
        :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: Certificate or ClientRawResponse if raw=true
        :rtype: ~azure.batch.models.Certificate or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


def patch(<EOL>self, job_schedule_id, job_schedule_patch_parameter, job_schedule_patch_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>timeout = job_schedule_patch_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>client_request_id = job_schedule_patch_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>return_client_request_id = job_schedule_patch_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>ocp_date = job_schedule_patch_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>if_match = job_schedule_patch_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>if_none_match = job_schedule_patch_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>if_modified_since = job_schedule_patch_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if job_schedule_patch_options is not None:<EOL><INDENT>if_unmodified_since = job_schedule_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_schedule_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_schedule_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 schedule.

        This replaces only the job schedule properties specified in the
        request. For example, if the schedule property is not specified with
        this request, then the Batch service will keep the existing schedule.
        Changes to a job schedule only impact jobs created by the schedule
        after the update has taken place; currently running jobs are
        unaffected.

        :param job_schedule_id: The ID of the job schedule to update.
        :type job_schedule_id: str
        :param job_schedule_patch_parameter: The parameters for the request.
        :type job_schedule_patch_parameter:
         ~azure.batch.models.JobSchedulePatchParameter
        :param job_schedule_patch_options: Additional parameters for the
         operation
        :type job_schedule_patch_options:
         ~azure.batch.models.JobSchedulePatchOptions
        :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 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 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 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 list_from_job_schedule(<EOL>self, job_schedule_id, job_list_from_job_schedule_options=None, custom_headers=None, raw=False, **operation_config):

filter = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>filter = job_list_from_job_schedule_options.filter<EOL><DEDENT>select = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>select = job_list_from_job_schedule_options.select<EOL><DEDENT>expand = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>expand = job_list_from_job_schedule_options.expand<EOL><DEDENT>max_results = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>max_results = job_list_from_job_schedule_options.max_results<EOL><DEDENT>timeout = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>timeout = job_list_from_job_schedule_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>client_request_id = job_list_from_job_schedule_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>return_client_request_id = job_list_from_job_schedule_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if job_list_from_job_schedule_options is not None:<EOL><INDENT>ocp_date = job_list_from_job_schedule_options.ocp_date<EOL><DEDENT>def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list_from_job_schedule.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_schedule_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 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.CloudJobPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.CloudJobPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Lists the jobs that have been created under the specified job schedule.

        :param job_schedule_id: The ID of the job schedule from which you want
         to get a list of jobs.
        :type job_schedule_id: str
        :param job_list_from_job_schedule_options: Additional parameters for
         the operation
        :type job_list_from_job_schedule_options:
         ~azure.batch.models.JobListFromJobScheduleOptions
        :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 CloudJob
        :rtype:
         ~azure.batch.models.CloudJobPaged[~azure.batch.models.CloudJob]
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


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

filter = None<EOL>if task_list_options is not None:<EOL><INDENT>filter = task_list_options.filter<EOL><DEDENT>select = None<EOL>if task_list_options is not None:<EOL><INDENT>select = task_list_options.select<EOL><DEDENT>expand = None<EOL>if task_list_options is not None:<EOL><INDENT>expand = task_list_options.expand<EOL><DEDENT>max_results = None<EOL>if task_list_options is not None:<EOL><INDENT>max_results = task_list_options.max_results<EOL><DEDENT>timeout = None<EOL>if task_list_options is not None:<EOL><INDENT>timeout = task_list_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if task_list_options is not None:<EOL><INDENT>client_request_id = task_list_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if task_list_options is not None:<EOL><INDENT>return_client_request_id = task_list_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if task_list_options is not None:<EOL><INDENT>ocp_date = task_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>'<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 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.CloudTaskPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.CloudTaskPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Lists all of the tasks that are associated with the specified job.

        For multi-instance tasks, information such as affinityId, executionInfo
        and nodeInfo refer to the primary task. Use the list subtasks API to
        retrieve information about subtasks.

        :param job_id: The ID of the job.
        :type job_id: str
        :param task_list_options: Additional parameters for the operation
        :type task_list_options: ~azure.batch.models.TaskListOptions
        :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 CloudTask
        :rtype:
         ~azure.batch.models.CloudTaskPaged[~azure.batch.models.CloudTask]
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


def add(<EOL>self, job_id, task, task_add_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if task_add_options is not None:<EOL><INDENT>timeout = task_add_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if task_add_options is not None:<EOL><INDENT>client_request_id = task_add_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if task_add_options is not None:<EOL><INDENT>return_client_request_id = task_add_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if task_add_options is not None:<EOL><INDENT>ocp_date = task_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>'<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>body_content = self._serialize.body(task, '<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 task to the specified job.

        The maximum lifetime of a task from addition to completion is 180 days.
        If a task has not completed within 180 days of being added it will be
        terminated by the Batch service and left in whatever state it was in at
        that time.

        :param job_id: The ID of the job to which the task is to be added.
        :type job_id: str
        :param task: The task to be added.
        :type task: ~azure.batch.models.TaskAddParameter
        :param task_add_options: Additional parameters for the operation
        :type task_add_options: ~azure.batch.models.TaskAddOptions
        :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, task_id, task_get_options=None, custom_headers=None, raw=False, **operation_config):

select = None<EOL>if task_get_options is not None:<EOL><INDENT>select = task_get_options.select<EOL><DEDENT>expand = None<EOL>if task_get_options is not None:<EOL><INDENT>expand = task_get_options.expand<EOL><DEDENT>timeout = None<EOL>if task_get_options is not None:<EOL><INDENT>timeout = task_get_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if task_get_options is not None:<EOL><INDENT>client_request_id = task_get_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if task_get_options is not None:<EOL><INDENT>return_client_request_id = task_get_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if task_get_options is not None:<EOL><INDENT>ocp_date = task_get_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if task_get_options is not None:<EOL><INDENT>if_match = task_get_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if task_get_options is not None:<EOL><INDENT>if_none_match = task_get_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if task_get_options is not None:<EOL><INDENT>if_modified_since = task_get_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if task_get_options is not None:<EOL><INDENT>if_unmodified_since = task_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>'<STR_LIT>': self._serialize.url("<STR_LIT>", task_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>'<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 information about the specified task.

        For multi-instance tasks, information such as affinityId, executionInfo
        and nodeInfo refer to the primary task. Use the list subtasks API to
        retrieve information about subtasks.

        :param job_id: The ID of the job that contains the task.
        :type job_id: str
        :param task_id: The ID of the task to get information about.
        :type task_id: str
        :param task_get_options: Additional parameters for the operation
        :type task_get_options: ~azure.batch.models.TaskGetOptions
        :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: CloudTask or ClientRawResponse if raw=true
        :rtype: ~azure.batch.models.CloudTask or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`BatchErrorException<azure.batch.models.BatchErrorException>`


def update(<EOL>self, job_id, task_id, constraints=None, task_update_options=None, custom_headers=None, raw=False, **operation_config):

timeout = None<EOL>if task_update_options is not None:<EOL><INDENT>timeout = task_update_options.timeout<EOL><DEDENT>client_request_id = None<EOL>if task_update_options is not None:<EOL><INDENT>client_request_id = task_update_options.client_request_id<EOL><DEDENT>return_client_request_id = None<EOL>if task_update_options is not None:<EOL><INDENT>return_client_request_id = task_update_options.return_client_request_id<EOL><DEDENT>ocp_date = None<EOL>if task_update_options is not None:<EOL><INDENT>ocp_date = task_update_options.ocp_date<EOL><DEDENT>if_match = None<EOL>if task_update_options is not None:<EOL><INDENT>if_match = task_update_options.if_match<EOL><DEDENT>if_none_match = None<EOL>if task_update_options is not None:<EOL><INDENT>if_none_match = task_update_options.if_none_match<EOL><DEDENT>if_modified_since = None<EOL>if task_update_options is not None:<EOL><INDENT>if_modified_since = task_update_options.if_modified_since<EOL><DEDENT>if_unmodified_since = None<EOL>if task_update_options is not None:<EOL><INDENT>if_unmodified_since = task_update_options.if_unmodified_since<EOL><DEDENT>task_update_parameter = models.TaskUpdateParameter(constraints=constraints)<EOL>url = self.update.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>'<STR_LIT>': self._serialize.url("<STR_LIT>", task_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(task_update_parameter, '<STR_LIT>')<EOL>request = self._client.put(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 task.

        :param job_id: The ID of the job containing the task.
        :type job_id: str
        :param task_id: The ID of the task to update.
        :type task_id: str
        :param constraints: Constraints that apply to this task. If omitted,
         the task is given the default constraints. For multi-instance tasks,
         updating the retention time applies only to the primary task and not
         subtasks.
        :type constraints: ~azure.batch.models.TaskConstraints
        :param task_update_options: Additional parameters for the operation
        :type task_update_options: ~azure.batch.models.TaskUpdateOptions
        :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 check_dns_name_availability(<EOL>self, location, domain_name_label, custom_headers=None, raw=False, **operation_config):

api_version = "<STR_LIT>"<EOL>url = self.check_dns_name_availability.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT:location>': self._serialize.url("<STR_LIT:location>", location, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.subscription_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>", domain_name_label, '<STR_LIT:str>')<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", api_version, '<STR_LIT:str>')<EOL>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>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>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Checks whether a domain name in the cloudapp.azure.com zone is
        available for use.

        :param location: The location of the domain name.
        :type location: str
        :param domain_name_label: The domain name to be verified. It must
         conform to the following regular expression:
         ^[a-z][a-z0-9-]{1,61}[a-z0-9]$.
        :type domain_name_label: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: DnsNameAvailabilityResult or ClientRawResponse if raw=true
        :rtype:
         ~azure.mgmt.network.v2017_11_01.models.DnsNameAvailabilityResult or
         ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`


def get(<EOL>self, resource_group_name, load_balancer_name, backend_address_pool_name, custom_headers=None, raw=False, **operation_config):

<EOL>url = self.get.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", backend_address_pool_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.subscription_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>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>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>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Gets load balancer backend address pool.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param load_balancer_name: The name of the load balancer.
        :type load_balancer_name: str
        :param backend_address_pool_name: The name of the backend address
         pool.
        :type backend_address_pool_name: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: BackendAddressPool or ClientRawResponse if raw=true
        :rtype: ~azure.mgmt.network.v2017_11_01.models.BackendAddressPool or
         ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`


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

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>", resource_group_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", load_balancer_name, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.subscription_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><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>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>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.BackendAddressPoolPaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Gets all the load balancer backed address pools.

        :param resource_group_name: The name of the resource group.
        :type resource_group_name: str
        :param load_balancer_name: The name of the load balancer.
        :type load_balancer_name: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: An iterator like instance of BackendAddressPool
        :rtype:
         ~azure.mgmt.network.v2017_11_01.models.BackendAddressPoolPaged[~azure.mgmt.network.v2017_11_01.models.BackendAddressPool]
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`