'Upgrades the operating system of the specified pool.
During an upgrade, the Batch service upgrades each compute node in the
pool. When a compute node is chosen for upgrade, any tasks running on
that node are removed from the node and returned to the queue to be
rerun later (or on a different compute node). The node will be
unavailable until the upgrade is complete. This operation results in
temporarily reduced pool capacity as nodes are taken out of service to
be upgraded. Although the Batch service tries to avoid upgrading all
compute nodes at the same time, it does not guarantee to do this
(particularly on small pools); therefore, the pool may be temporarily
unavailable to run tasks. When this operation runs, the pool state
changes to upgrading. When all compute nodes have finished upgrading,
the pool state returns to active.
:param pool_id: The ID of the pool to upgrade.
:type pool_id: str
:param target_os_version: The Azure Guest OS version to be installed
on the virtual machines in the pool.
:type target_os_version: str
:param pool_upgrade_os_options: Additional parameters for the
operation
:type pool_upgrade_os_options: :class:`PoolUpgradeOsOptions
<azure.batch.models.PoolUpgradeOsOptions>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`BatchErrorException<azure.batch.models.BatchErrorException>`'

def upgrade_os(self, pool_id, target_os_version, pool_upgrade_os_options=None, custom_headers=None, raw=False, **operation_config):

    timeout = None
    if (pool_upgrade_os_options is not None):
        timeout = pool_upgrade_os_options.timeout
    client_request_id = None
    if (pool_upgrade_os_options is not None):
        client_request_id = pool_upgrade_os_options.client_request_id
    return_client_request_id = None
    if (pool_upgrade_os_options is not None):
        return_client_request_id = pool_upgrade_os_options.return_client_request_id
    ocp_date = None
    if (pool_upgrade_os_options is not None):
        ocp_date = pool_upgrade_os_options.ocp_date
    if_match = None
    if (pool_upgrade_os_options is not None):
        if_match = pool_upgrade_os_options.if_match
    if_none_match = None
    if (pool_upgrade_os_options is not None):
        if_none_match = pool_upgrade_os_options.if_none_match
    if_modified_since = None
    if (pool_upgrade_os_options is not None):
        if_modified_since = pool_upgrade_os_options.if_modified_since
    if_unmodified_since = None
    if (pool_upgrade_os_options is not None):
        if_unmodified_since = pool_upgrade_os_options.if_unmodified_since
    pool_upgrade_os_parameter = models.PoolUpgradeOSParameter(target_os_version=target_os_version)
    url = '/pools/{poolId}/upgradeos'
    path_format_arguments = {'poolId': self._serialize.url('pool_id', pool_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 (timeout is not None):
        query_parameters['timeout'] = self._serialize.query('timeout', timeout, 'int')
    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')
    if (if_match is not None):
        header_parameters['If-Match'] = self._serialize.header('if_match', if_match, 'str')
    if (if_none_match is not None):
        header_parameters['If-None-Match'] = self._serialize.header('if_none_match', if_none_match, 'str')
    if (if_modified_since is not None):
        header_parameters['If-Modified-Since'] = self._serialize.header('if_modified_since', if_modified_since, 'rfc-1123')
    if (if_unmodified_since is not None):
        header_parameters['If-Unmodified-Since'] = self._serialize.header('if_unmodified_since', if_unmodified_since, 'rfc-1123')
    body_content = self._serialize.body(pool_upgrade_os_parameter, 'PoolUpgradeOSParameter')
    request = self._client.post(url, query_parameters)
    response = self._client.send(request, header_parameters, body_content, **operation_config)
    if (response.status_code not in [202]):
        raise models.BatchErrorException(self._deserialize, response)
    if raw:
        client_raw_response = ClientRawResponse(None, response)
        client_raw_response.add_headers({'client-request-id': 'str', 'request-id': 'str', 'ETag': 'str', 'Last-Modified': 'rfc-1123', 'DataServiceId': 'str'})
        return client_raw_response
