'Lists the execution status of the Job Preparation and Job Release task
for the specified job across the compute nodes where the job has run.
This API returns the Job Preparation and Job Release task status on all
compute nodes that have run the Job Preparation or Job Release task.
This includes nodes which have since been removed from the pool. .
:param job_id: The ID of the job.
:type job_id: str
:param job_list_preparation_and_release_task_status_options:
Additional parameters for the operation
:type job_list_preparation_and_release_task_status_options:
:class:`JobListPreparationAndReleaseTaskStatusOptions
<azure.batch.models.JobListPreparationAndReleaseTaskStatusOptions>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`JobPreparationAndReleaseTaskExecutionInformationPaged
<azure.batch.models.JobPreparationAndReleaseTaskExecutionInformationPaged>`
:raises:
:class:`BatchErrorException<azure.batch.models.BatchErrorException>`'

def list_preparation_and_release_task_status(self, job_id, job_list_preparation_and_release_task_status_options=None, custom_headers=None, raw=False, **operation_config):

    filter = None
    if (job_list_preparation_and_release_task_status_options is not None):
        filter = job_list_preparation_and_release_task_status_options.filter
    select = None
    if (job_list_preparation_and_release_task_status_options is not None):
        select = job_list_preparation_and_release_task_status_options.select
    max_results = None
    if (job_list_preparation_and_release_task_status_options is not None):
        max_results = job_list_preparation_and_release_task_status_options.max_results
    timeout = None
    if (job_list_preparation_and_release_task_status_options is not None):
        timeout = job_list_preparation_and_release_task_status_options.timeout
    client_request_id = None
    if (job_list_preparation_and_release_task_status_options is not None):
        client_request_id = job_list_preparation_and_release_task_status_options.client_request_id
    return_client_request_id = None
    if (job_list_preparation_and_release_task_status_options is not None):
        return_client_request_id = job_list_preparation_and_release_task_status_options.return_client_request_id
    ocp_date = None
    if (job_list_preparation_and_release_task_status_options is not None):
        ocp_date = job_list_preparation_and_release_task_status_options.ocp_date
    def internal_paging(next_link=None, raw=False):
        if (not next_link):
            url = '/jobs/{jobId}/jobpreparationandreleasetaskstatus'
            path_format_arguments = {'jobId': self._serialize.url('job_id', job_id, 'str')}
            url = self._client.format_url(url, **path_format_arguments)
            query_parameters = {}
            query_parameters['api-version'] = self._serialize.query('self.api_version', self.api_version, 'str')
            if (filter is not None):
                query_parameters['$filter'] = self._serialize.query('filter', filter, 'str')
            if (select is not None):
                query_parameters['$select'] = self._serialize.query('select', select, 'str')
            if (max_results is not None):
                query_parameters['maxresults'] = self._serialize.query('max_results', max_results, 'int', maximum=1000, minimum=1)
            if (timeout is not None):
                query_parameters['timeout'] = self._serialize.query('timeout', timeout, 'int')
        else:
            url = next_link
            query_parameters = {}
        header_parameters = {}
        header_parameters['Content-Type'] = 'application/json;    odata=minimalmetadata;    charset=utf-8'
        if self.config.generate_client_request_id:
            header_parameters['client-request-id'] = str(uuid.uuid1())
        if custom_headers:
            header_parameters.update(custom_headers)
        if (self.config.accept_language is not None):
            header_parameters['accept-language'] = self._serialize.header('self.config.accept_language', self.config.accept_language, 'str')
        if (client_request_id is not None):
            header_parameters['client-request-id'] = self._serialize.header('client_request_id', client_request_id, 'str')
        if (return_client_request_id is not None):
            header_parameters['return-client-request-id'] = self._serialize.header('return_client_request_id', return_client_request_id, 'bool')
        if (ocp_date is not None):
            header_parameters['ocp-date'] = self._serialize.header('ocp_date', ocp_date, 'rfc-1123')
        request = self._client.get(url, query_parameters)
        response = self._client.send(request, header_parameters, **operation_config)
        if (response.status_code not in [200]):
            raise models.BatchErrorException(self._deserialize, response)
        return response
    deserialized = models.JobPreparationAndReleaseTaskExecutionInformationPaged(internal_paging, self._deserialize.dependencies)
    if raw:
        header_dict = {}
        client_raw_response = models.JobPreparationAndReleaseTaskExecutionInformationPaged(internal_paging, self._deserialize.dependencies, header_dict)
        return client_raw_response
    return deserialized
