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

    timeout = None
    if (pool_enable_auto_scale_options is not None):
        timeout = pool_enable_auto_scale_options.timeout
    client_request_id = None
    if (pool_enable_auto_scale_options is not None):
        client_request_id = pool_enable_auto_scale_options.client_request_id
    return_client_request_id = None
    if (pool_enable_auto_scale_options is not None):
        return_client_request_id = pool_enable_auto_scale_options.return_client_request_id
    ocp_date = None
    if (pool_enable_auto_scale_options is not None):
        ocp_date = pool_enable_auto_scale_options.ocp_date
    if_match = None
    if (pool_enable_auto_scale_options is not None):
        if_match = pool_enable_auto_scale_options.if_match
    if_none_match = None
    if (pool_enable_auto_scale_options is not None):
        if_none_match = pool_enable_auto_scale_options.if_none_match
    if_modified_since = None
    if (pool_enable_auto_scale_options is not None):
        if_modified_since = pool_enable_auto_scale_options.if_modified_since
    if_unmodified_since = None
    if (pool_enable_auto_scale_options is not None):
        if_unmodified_since = pool_enable_auto_scale_options.if_unmodified_since
    pool_enable_auto_scale_parameter = models.PoolEnableAutoScaleParameter(auto_scale_formula=auto_scale_formula, auto_scale_evaluation_interval=auto_scale_evaluation_interval)
    url = '/pools/{poolId}/enableautoscale'
    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_enable_auto_scale_parameter, 'PoolEnableAutoScaleParameter')
    request = self._client.post(url, query_parameters)
    response = self._client.send(request, header_parameters, body_content, **operation_config)
    if (response.status_code not in [200]):
        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
