from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH

class MlClient(NamespacedClient):
    @query_params('from_', 'size')
    def get_filters(self, filter_id=None, params=None):
        """

        :arg filter_id: The ID of the filter to fetch
        :arg from_: skips a number of filters
        :arg size: specifies a max number of filters to get
        """
        return self.transport.perform_request('GET', _make_path('_xpack', 'ml',
            'filters', filter_id), params=params)

    @query_params()
    def get_datafeeds(self, datafeed_id=None, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-datafeed.html>`_

        :arg datafeed_id: The ID of the datafeeds to fetch
        """
        return self.transport.perform_request('GET', _make_path('_xpack', 'ml',
            'datafeeds', datafeed_id), params=params)

    @query_params()
    def get_datafeed_stats(self, datafeed_id=None, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-datafeed-stats.html>`_

        :arg datafeed_id: The ID of the datafeeds stats to fetch
        """
        return self.transport.perform_request('GET', _make_path('_xpack', 'ml',
            'datafeeds', datafeed_id, '_stats'), params=params)

    @query_params('anomaly_score', 'desc', 'end', 'exclude_interim', 'expand',
        'from_', 'size', 'sort', 'start')
    def get_buckets(self, job_id, timestamp=None, body=None, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-bucket.html>`_

        :arg job_id: ID of the job to get bucket results from
        :arg timestamp: The timestamp of the desired single bucket result
        :arg body: Bucket selection details if not provided in URI
        :arg anomaly_score: Filter for the most anomalous buckets
        :arg desc: Set the sort direction
        :arg end: End time filter for buckets
        :arg exclude_interim: Exclude interim results
        :arg expand: Include anomaly records
        :arg from_: skips a number of buckets
        :arg size: specifies a max number of buckets to get
        :arg sort: Sort buckets by a particular field
        :arg start: Start time filter for buckets
        """
        if job_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'job_id'.")
        return self.transport.perform_request('GET', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id, 'results', 'buckets', timestamp),
            params=params, body=body)

    @query_params('reset_end', 'reset_start')
    def post_data(self, job_id, body, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-post-data.html>`_

        :arg job_id: The name of the job receiving the data
        :arg body: The data to process
        :arg reset_end: Optional parameter to specify the end of the bucket
            resetting range
        :arg reset_start: Optional parameter to specify the start of the bucket
            resetting range
        """
        for param in (job_id, body):
            if param in SKIP_IN_PATH:
                raise ValueError("Empty value passed for a required argument.")
        return self.transport.perform_request('POST', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id, '_data'), params=params,
            body=self._bulk_body(body))

    @query_params('force', 'timeout')
    def stop_datafeed(self, datafeed_id, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-stop-datafeed.html>`_

        :arg datafeed_id: The ID of the datafeed to stop
        :arg force: True if the datafeed should be forcefully stopped.
        :arg timeout: Controls the time to wait until a datafeed has stopped.
            Default to 20 seconds
        """
        if datafeed_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'datafeed_id'.")
        return self.transport.perform_request('POST', _make_path('_xpack', 'ml',
            'datafeeds', datafeed_id, '_stop'), params=params)

    @query_params()
    def get_jobs(self, job_id=None, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-job.html>`_

        :arg job_id: The ID of the jobs to fetch
        """
        return self.transport.perform_request('GET', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id), params=params)

    @query_params()
    def delete_expired_data(self, params=None):
        """
        """
        return self.transport.perform_request('DELETE',
            '/_xpack/ml/_delete_expired_data', params=params)

    @query_params()
    def put_job(self, job_id, body, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-put-job.html>`_

        :arg job_id: The ID of the job to create
        :arg body: The job
        """
        for param in (job_id, body):
            if param in SKIP_IN_PATH:
                raise ValueError("Empty value passed for a required argument.")
        return self.transport.perform_request('PUT', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id), params=params, body=body)

    @query_params()
    def validate_detector(self, body, params=None):
        """

        :arg body: The detector
        """
        if body in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'body'.")
        return self.transport.perform_request('POST',
            '/_xpack/ml/anomaly_detectors/_validate/detector', params=params,
            body=body)

    @query_params('end', 'start', 'timeout')
    def start_datafeed(self, datafeed_id, body=None, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-start-datafeed.html>`_

        :arg datafeed_id: The ID of the datafeed to start
        :arg body: The start datafeed parameters
        :arg end: The end time when the datafeed should stop. When not set, the
            datafeed continues in real time
        :arg start: The start time from where the datafeed should begin
        :arg timeout: Controls the time to wait until a datafeed has started.
            Default to 20 seconds
        """
        if datafeed_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'datafeed_id'.")
        return self.transport.perform_request('POST', _make_path('_xpack', 'ml',
            'datafeeds', datafeed_id, '_start'), params=params, body=body)

    @query_params('desc', 'end', 'exclude_interim', 'from_', 'record_score',
        'size', 'sort', 'start')
    def get_records(self, job_id, body=None, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-record.html>`_

        :arg job_id: None
        :arg body: Record selection criteria
        :arg desc: Set the sort direction
        :arg end: End time filter for records
        :arg exclude_interim: Exclude interim results
        :arg from_: skips a number of records
        :arg record_score:
        :arg size: specifies a max number of records to get
        :arg sort: Sort records by a particular field
        :arg start: Start time filter for records
        """
        if job_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'job_id'.")
        return self.transport.perform_request('GET', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id, 'results', 'records'), params=params,
            body=body)

    @query_params()
    def update_job(self, job_id, body, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-update-job.html>`_

        :arg job_id: The ID of the job to create
        :arg body: The job update settings
        """
        for param in (job_id, body):
            if param in SKIP_IN_PATH:
                raise ValueError("Empty value passed for a required argument.")
        return self.transport.perform_request('POST', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id, '_update'), params=params, body=body)

    @query_params()
    def put_filter(self, filter_id, body, params=None):
        """

        :arg filter_id: The ID of the filter to create
        :arg body: The filter details
        """
        for param in (filter_id, body):
            if param in SKIP_IN_PATH:
                raise ValueError("Empty value passed for a required argument.")
        return self.transport.perform_request('PUT', _make_path('_xpack', 'ml',
            'filters', filter_id), params=params, body=body)

    @query_params()
    def update_datafeed(self, datafeed_id, body, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-update-datafeed.html>`_

        :arg datafeed_id: The ID of the datafeed to update
        :arg body: The datafeed update settings
        """
        for param in (datafeed_id, body):
            if param in SKIP_IN_PATH:
                raise ValueError("Empty value passed for a required argument.")
        return self.transport.perform_request('POST', _make_path('_xpack', 'ml',
            'datafeeds', datafeed_id, '_update'), params=params, body=body)

    @query_params()
    def preview_datafeed(self, datafeed_id, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-preview-datafeed.html>`_

        :arg datafeed_id: The ID of the datafeed to preview
        """
        if datafeed_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'datafeed_id'.")
        return self.transport.perform_request('GET', _make_path('_xpack', 'ml',
            'datafeeds', datafeed_id, '_preview'), params=params)

    @query_params('advance_time', 'calc_interim', 'end', 'skip_time', 'start')
    def flush_job(self, job_id, body=None, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-flush-job.html>`_

        :arg job_id: The name of the job to flush
        :arg body: Flush parameters
        :arg advance_time: Advances time to the given value generating results
            and updating the model for the advanced interval
        :arg calc_interim: Calculates interim results for the most recent bucket
            or all buckets within the latency period
        :arg end: When used in conjunction with calc_interim, specifies the
            range of buckets on which to calculate interim results
        :arg skip_time: Skips time to the given value without generating results
            or updating the model for the skipped interval
        :arg start: When used in conjunction with calc_interim, specifies the
            range of buckets on which to calculate interim results
        """
        if job_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'job_id'.")
        return self.transport.perform_request('POST', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id, '_flush'), params=params, body=body)

    @query_params('force', 'timeout')
    def close_job(self, job_id, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-close-job.html>`_

        :arg job_id: The name of the job to close
        :arg force: True if the job should be forcefully closed
        :arg timeout: Controls the time to wait until a job has closed. Default
            to 30 minutes
        """
        if job_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'job_id'.")
        return self.transport.perform_request('POST', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id, '_close'), params=params)

    @query_params()
    def open_job(self, job_id, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-open-job.html>`_

        :arg job_id: The ID of the job to open
        """
        if job_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'job_id'.")
        return self.transport.perform_request('POST', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id, '_open'), params=params)

    @query_params('force')
    def delete_job(self, job_id, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-delete-job.html>`_

        :arg job_id: The ID of the job to delete
        :arg force: True if the job should be forcefully deleted
        """
        if job_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'job_id'.")
        return self.transport.perform_request('DELETE', _make_path('_xpack',
            'ml', 'anomaly_detectors', job_id), params=params)

    @query_params()
    def update_model_snapshot(self, job_id, snapshot_id, body, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-update-snapshot.html>`_

        :arg job_id: The ID of the job to fetch
        :arg snapshot_id: The ID of the snapshot to update
        :arg body: The model snapshot properties to update
        """
        for param in (job_id, snapshot_id, body):
            if param in SKIP_IN_PATH:
                raise ValueError("Empty value passed for a required argument.")
        return self.transport.perform_request('POST', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id, 'model_snapshots', snapshot_id,
            '_update'), params=params, body=body)

    @query_params()
    def delete_filter(self, filter_id, params=None):
        """

        :arg filter_id: The ID of the filter to delete
        """
        if filter_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'filter_id'.")
        return self.transport.perform_request('DELETE', _make_path('_xpack',
            'ml', 'filters', filter_id), params=params)

    @query_params()
    def validate(self, body, params=None):
        """

        :arg body: The job config
        """
        if body in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'body'.")
        return self.transport.perform_request('POST',
            '/_xpack/ml/anomaly_detectors/_validate', params=params, body=body)

    @query_params('from_', 'size')
    def get_categories(self, job_id, category_id=None, body=None, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-category.html>`_

        :arg job_id: The name of the job
        :arg category_id: The identifier of the category definition of interest
        :arg body: Category selection details if not provided in URI
        :arg from_: skips a number of categories
        :arg size: specifies a max number of categories to get
        """
        if job_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'job_id'.")
        return self.transport.perform_request('GET', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id, 'results', 'categories', category_id),
            params=params, body=body)

    @query_params('desc', 'end', 'exclude_interim', 'from_', 'influencer_score',
        'size', 'sort', 'start')
    def get_influencers(self, job_id, body=None, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-influencer.html>`_

        :arg job_id: None
        :arg body: Influencer selection criteria
        :arg desc: whether the results should be sorted in decending order
        :arg end: end timestamp for the requested influencers
        :arg exclude_interim: Exclude interim results
        :arg from_: skips a number of influencers
        :arg influencer_score: influencer score threshold for the requested
            influencers
        :arg size: specifies a max number of influencers to get
        :arg sort: sort field for the requested influencers
        :arg start: start timestamp for the requested influencers
        """
        if job_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'job_id'.")
        return self.transport.perform_request('GET', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id, 'results', 'influencers'),
            params=params, body=body)

    @query_params()
    def put_datafeed(self, datafeed_id, body, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-put-datafeed.html>`_

        :arg datafeed_id: The ID of the datafeed to create
        :arg body: The datafeed config
        """
        for param in (datafeed_id, body):
            if param in SKIP_IN_PATH:
                raise ValueError("Empty value passed for a required argument.")
        return self.transport.perform_request('PUT', _make_path('_xpack', 'ml',
            'datafeeds', datafeed_id), params=params, body=body)

    @query_params('force')
    def delete_datafeed(self, datafeed_id, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-delete-datafeed.html>`_

        :arg datafeed_id: The ID of the datafeed to delete
        :arg force: True if the datafeed should be forcefully deleted
        """
        if datafeed_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'datafeed_id'.")
        return self.transport.perform_request('DELETE', _make_path('_xpack',
            'ml', 'datafeeds', datafeed_id), params=params)

    @query_params()
    def get_job_stats(self, job_id=None, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-job-stats.html>`_

        :arg job_id: The ID of the jobs stats to fetch
        """
        return self.transport.perform_request('GET', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id, '_stats'), params=params)

    @query_params('delete_intervening_results')
    def revert_model_snapshot(self, job_id, snapshot_id, body=None, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-revert-snapshot.html>`_

        :arg job_id: The ID of the job to fetch
        :arg snapshot_id: The ID of the snapshot to revert to
        :arg body: Reversion options
        :arg delete_intervening_results: Should we reset the results back to the
            time of the snapshot?
        """
        for param in (job_id, snapshot_id):
            if param in SKIP_IN_PATH:
                raise ValueError("Empty value passed for a required argument.")
        return self.transport.perform_request('POST', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id, 'model_snapshots', snapshot_id,
            '_revert'), params=params, body=body)

    @query_params('desc', 'end', 'from_', 'size', 'sort', 'start')
    def get_model_snapshots(self, job_id, snapshot_id=None, body=None, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-get-snapshot.html>`_

        :arg job_id: The ID of the job to fetch
        :arg snapshot_id: The ID of the snapshot to fetch
        :arg body: Model snapshot selection criteria
        :arg desc: True if the results should be sorted in descending order
        :arg end: The filter 'end' query parameter
        :arg from_: Skips a number of documents
        :arg size: The default number of documents returned in queries as a
            string.
        :arg sort: Name of the field to sort on
        :arg start: The filter 'start' query parameter
        """
        if job_id in SKIP_IN_PATH:
            raise ValueError("Empty value passed for a required argument 'job_id'.")
        return self.transport.perform_request('GET', _make_path('_xpack', 'ml',
            'anomaly_detectors', job_id, 'model_snapshots', snapshot_id),
            params=params, body=body)

    @query_params()
    def delete_model_snapshot(self, job_id, snapshot_id, params=None):
        """

        `<http://www.elastic.co/guide/en/elasticsearch/reference/current/ml-delete-snapshot.html>`_

        :arg job_id: The ID of the job to fetch
        :arg snapshot_id: The ID of the snapshot to delete
        """
        for param in (job_id, snapshot_id):
            if param in SKIP_IN_PATH:
                raise ValueError("Empty value passed for a required argument.")
        return self.transport.perform_request('DELETE', _make_path('_xpack',
            'ml', 'anomaly_detectors', job_id, 'model_snapshots', snapshot_id),
            params=params)


[((4, 5, 4, 34), 'elasticsearch.client.utils.query_params', 'query_params', ({(4, 18, 4, 25): '"""from_"""', (4, 27, 4, 33): '"""size"""'}, {}), "('from_', 'size')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((15, 5, 15, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((26, 5, 26, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((37, 5, 38, 41), 'elasticsearch.client.utils.query_params', 'query_params', ({(37, 18, 37, 33): '"""anomaly_score"""', (37, 35, 37, 41): '"""desc"""', (37, 43, 37, 48): '"""end"""', (37, 50, 37, 67): '"""exclude_interim"""', (37, 69, 37, 77): '"""expand"""', (38, 8, 38, 15): '"""from_"""', (38, 17, 38, 23): '"""size"""', (38, 25, 38, 31): '"""sort"""', (38, 33, 38, 40): '"""start"""'}, {}), "('anomaly_score', 'desc', 'end', 'exclude_interim', 'expand',\n    'from_', 'size', 'sort', 'start')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((63, 5, 63, 45), 'elasticsearch.client.utils.query_params', 'query_params', ({(63, 18, 63, 29): '"""reset_end"""', (63, 31, 63, 44): '"""reset_start"""'}, {}), "('reset_end', 'reset_start')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((83, 5, 83, 37), 'elasticsearch.client.utils.query_params', 'query_params', ({(83, 18, 83, 25): '"""force"""', (83, 27, 83, 36): '"""timeout"""'}, {}), "('force', 'timeout')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((99, 5, 99, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((110, 5, 110, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((117, 5, 117, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((132, 5, 132, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((144, 5, 144, 44), 'elasticsearch.client.utils.query_params', 'query_params', ({(144, 18, 144, 23): '"""end"""', (144, 25, 144, 32): '"""start"""', (144, 34, 144, 43): '"""timeout"""'}, {}), "('end', 'start', 'timeout')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((163, 5, 164, 32), 'elasticsearch.client.utils.query_params', 'query_params', ({(163, 18, 163, 24): '"""desc"""', (163, 26, 163, 31): '"""end"""', (163, 33, 163, 50): '"""exclude_interim"""', (163, 52, 163, 59): '"""from_"""', (163, 61, 163, 75): '"""record_score"""', (164, 8, 164, 14): '"""size"""', (164, 16, 164, 22): '"""sort"""', (164, 24, 164, 31): '"""start"""'}, {}), "('desc', 'end', 'exclude_interim', 'from_', 'record_score',\n    'size', 'sort', 'start')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((187, 5, 187, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((202, 5, 202, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((215, 5, 215, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((230, 5, 230, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((243, 5, 243, 78), 'elasticsearch.client.utils.query_params', 'query_params', ({(243, 18, 243, 32): '"""advance_time"""', (243, 34, 243, 48): '"""calc_interim"""', (243, 50, 243, 55): '"""end"""', (243, 57, 243, 68): '"""skip_time"""', (243, 70, 243, 77): '"""start"""'}, {}), "('advance_time', 'calc_interim', 'end', 'skip_time', 'start')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((267, 5, 267, 37), 'elasticsearch.client.utils.query_params', 'query_params', ({(267, 18, 267, 25): '"""force"""', (267, 27, 267, 36): '"""timeout"""'}, {}), "('force', 'timeout')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((283, 5, 283, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((296, 5, 296, 26), 'elasticsearch.client.utils.query_params', 'query_params', ({(296, 18, 296, 25): '"""force"""'}, {}), "('force')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((310, 5, 310, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((327, 5, 327, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((338, 5, 338, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((349, 5, 349, 34), 'elasticsearch.client.utils.query_params', 'query_params', ({(349, 18, 349, 25): '"""from_"""', (349, 27, 349, 33): '"""size"""'}, {}), "('from_', 'size')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((367, 5, 368, 32), 'elasticsearch.client.utils.query_params', 'query_params', ({(367, 18, 367, 24): '"""desc"""', (367, 26, 367, 31): '"""end"""', (367, 33, 367, 50): '"""exclude_interim"""', (367, 52, 367, 59): '"""from_"""', (367, 61, 367, 79): '"""influencer_score"""', (368, 8, 368, 14): '"""size"""', (368, 16, 368, 22): '"""sort"""', (368, 24, 368, 31): '"""start"""'}, {}), "('desc', 'end', 'exclude_interim', 'from_', 'influencer_score',\n    'size', 'sort', 'start')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((392, 5, 392, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((407, 5, 407, 26), 'elasticsearch.client.utils.query_params', 'query_params', ({(407, 18, 407, 25): '"""force"""'}, {}), "('force')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((421, 5, 421, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((432, 5, 432, 47), 'elasticsearch.client.utils.query_params', 'query_params', ({(432, 18, 432, 46): '"""delete_intervening_results"""'}, {}), "('delete_intervening_results')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((451, 5, 451, 66), 'elasticsearch.client.utils.query_params', 'query_params', ({(451, 18, 451, 24): '"""desc"""', (451, 26, 451, 31): '"""end"""', (451, 33, 451, 40): '"""from_"""', (451, 42, 451, 48): '"""size"""', (451, 50, 451, 56): '"""sort"""', (451, 58, 451, 65): '"""start"""'}, {}), "('desc', 'end', 'from_', 'size', 'sort', 'start')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((474, 5, 474, 19), 'elasticsearch.client.utils.query_params', 'query_params', ({}, {}), '()', False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((12, 53, 13, 33), 'elasticsearch.client.utils._make_path', '_make_path', ({(12, 64, 12, 72): '"""_xpack"""', (12, 74, 12, 78): '"""ml"""', (13, 12, 13, 21): '"""filters"""', (13, 23, 13, 32): 'filter_id'}, {}), "('_xpack', 'ml', 'filters', filter_id)", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((23, 53, 24, 37), 'elasticsearch.client.utils._make_path', '_make_path', ({(23, 64, 23, 72): '"""_xpack"""', (23, 74, 23, 78): '"""ml"""', (24, 12, 24, 23): '"""datafeeds"""', (24, 25, 24, 36): 'datafeed_id'}, {}), "('_xpack', 'ml', 'datafeeds', datafeed_id)", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((34, 53, 35, 47), 'elasticsearch.client.utils._make_path', '_make_path', ({(34, 64, 34, 72): '"""_xpack"""', (34, 74, 34, 78): '"""ml"""', (35, 12, 35, 23): '"""datafeeds"""', (35, 25, 35, 36): 'datafeed_id', (35, 38, 35, 46): '"""_stats"""'}, {}), "('_xpack', 'ml', 'datafeeds', datafeed_id, '_stats')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((59, 53, 60, 73), 'elasticsearch.client.utils._make_path', '_make_path', ({(59, 64, 59, 72): '"""_xpack"""', (59, 74, 59, 78): '"""ml"""', (60, 12, 60, 31): '"""anomaly_detectors"""', (60, 33, 60, 39): 'job_id', (60, 41, 60, 50): '"""results"""', (60, 52, 60, 61): '"""buckets"""', (60, 63, 60, 72): 'timestamp'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id, 'results',\n    'buckets', timestamp)", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((79, 54, 80, 49), 'elasticsearch.client.utils._make_path', '_make_path', ({(79, 65, 79, 73): '"""_xpack"""', (79, 75, 79, 79): '"""ml"""', (80, 12, 80, 31): '"""anomaly_detectors"""', (80, 33, 80, 39): 'job_id', (80, 41, 80, 48): '"""_data"""'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id, '_data')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((96, 54, 97, 46), 'elasticsearch.client.utils._make_path', '_make_path', ({(96, 65, 96, 73): '"""_xpack"""', (96, 75, 96, 79): '"""ml"""', (97, 12, 97, 23): '"""datafeeds"""', (97, 25, 97, 36): 'datafeed_id', (97, 38, 97, 45): '"""_stop"""'}, {}), "('_xpack', 'ml', 'datafeeds', datafeed_id, '_stop')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((107, 53, 108, 40), 'elasticsearch.client.utils._make_path', '_make_path', ({(107, 64, 107, 72): '"""_xpack"""', (107, 74, 107, 78): '"""ml"""', (108, 12, 108, 31): '"""anomaly_detectors"""', (108, 33, 108, 39): 'job_id'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id)", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((129, 53, 130, 40), 'elasticsearch.client.utils._make_path', '_make_path', ({(129, 64, 129, 72): '"""_xpack"""', (129, 74, 129, 78): '"""ml"""', (130, 12, 130, 31): '"""anomaly_detectors"""', (130, 33, 130, 39): 'job_id'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id)", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((160, 54, 161, 47), 'elasticsearch.client.utils._make_path', '_make_path', ({(160, 65, 160, 73): '"""_xpack"""', (160, 75, 160, 79): '"""ml"""', (161, 12, 161, 23): '"""datafeeds"""', (161, 25, 161, 36): 'datafeed_id', (161, 38, 161, 46): '"""_start"""'}, {}), "('_xpack', 'ml', 'datafeeds', datafeed_id, '_start')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((183, 53, 184, 62), 'elasticsearch.client.utils._make_path', '_make_path', ({(183, 64, 183, 72): '"""_xpack"""', (183, 74, 183, 78): '"""ml"""', (184, 12, 184, 31): '"""anomaly_detectors"""', (184, 33, 184, 39): 'job_id', (184, 41, 184, 50): '"""results"""', (184, 52, 184, 61): '"""records"""'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id, 'results', 'records')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((199, 54, 200, 51), 'elasticsearch.client.utils._make_path', '_make_path', ({(199, 65, 199, 73): '"""_xpack"""', (199, 75, 199, 79): '"""ml"""', (200, 12, 200, 31): '"""anomaly_detectors"""', (200, 33, 200, 39): 'job_id', (200, 41, 200, 50): '"""_update"""'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id, '_update')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((212, 53, 213, 33), 'elasticsearch.client.utils._make_path', '_make_path', ({(212, 64, 212, 72): '"""_xpack"""', (212, 74, 212, 78): '"""ml"""', (213, 12, 213, 21): '"""filters"""', (213, 23, 213, 32): 'filter_id'}, {}), "('_xpack', 'ml', 'filters', filter_id)", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((227, 54, 228, 48), 'elasticsearch.client.utils._make_path', '_make_path', ({(227, 65, 227, 73): '"""_xpack"""', (227, 75, 227, 79): '"""ml"""', (228, 12, 228, 23): '"""datafeeds"""', (228, 25, 228, 36): 'datafeed_id', (228, 38, 228, 47): '"""_update"""'}, {}), "('_xpack', 'ml', 'datafeeds', datafeed_id, '_update')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((240, 53, 241, 49), 'elasticsearch.client.utils._make_path', '_make_path', ({(240, 64, 240, 72): '"""_xpack"""', (240, 74, 240, 78): '"""ml"""', (241, 12, 241, 23): '"""datafeeds"""', (241, 25, 241, 36): 'datafeed_id', (241, 38, 241, 48): '"""_preview"""'}, {}), "('_xpack', 'ml', 'datafeeds', datafeed_id, '_preview')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((264, 54, 265, 50), 'elasticsearch.client.utils._make_path', '_make_path', ({(264, 65, 264, 73): '"""_xpack"""', (264, 75, 264, 79): '"""ml"""', (265, 12, 265, 31): '"""anomaly_detectors"""', (265, 33, 265, 39): 'job_id', (265, 41, 265, 49): '"""_flush"""'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id, '_flush')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((280, 54, 281, 50), 'elasticsearch.client.utils._make_path', '_make_path', ({(280, 65, 280, 73): '"""_xpack"""', (280, 75, 280, 79): '"""ml"""', (281, 12, 281, 31): '"""anomaly_detectors"""', (281, 33, 281, 39): 'job_id', (281, 41, 281, 49): '"""_close"""'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id, '_close')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((293, 54, 294, 49), 'elasticsearch.client.utils._make_path', '_make_path', ({(293, 65, 293, 73): '"""_xpack"""', (293, 75, 293, 79): '"""ml"""', (294, 12, 294, 31): '"""anomaly_detectors"""', (294, 33, 294, 39): 'job_id', (294, 41, 294, 48): '"""_open"""'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id, '_open')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((307, 56, 308, 46), 'elasticsearch.client.utils._make_path', '_make_path', ({(307, 67, 307, 75): '"""_xpack"""', (308, 12, 308, 16): '"""ml"""', (308, 18, 308, 37): '"""anomaly_detectors"""', (308, 39, 308, 45): 'job_id'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id)", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((323, 54, 325, 22), 'elasticsearch.client.utils._make_path', '_make_path', ({(323, 65, 323, 73): '"""_xpack"""', (323, 75, 323, 79): '"""ml"""', (324, 12, 324, 31): '"""anomaly_detectors"""', (324, 33, 324, 39): 'job_id', (324, 41, 324, 58): '"""model_snapshots"""', (324, 60, 324, 71): 'snapshot_id', (325, 12, 325, 21): '"""_update"""'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id, 'model_snapshots',\n    snapshot_id, '_update')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((335, 56, 336, 39), 'elasticsearch.client.utils._make_path', '_make_path', ({(335, 67, 335, 75): '"""_xpack"""', (336, 12, 336, 16): '"""ml"""', (336, 18, 336, 27): '"""filters"""', (336, 29, 336, 38): 'filter_id'}, {}), "('_xpack', 'ml', 'filters', filter_id)", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((363, 53, 364, 78), 'elasticsearch.client.utils._make_path', '_make_path', ({(363, 64, 363, 72): '"""_xpack"""', (363, 74, 363, 78): '"""ml"""', (364, 12, 364, 31): '"""anomaly_detectors"""', (364, 33, 364, 39): 'job_id', (364, 41, 364, 50): '"""results"""', (364, 52, 364, 64): '"""categories"""', (364, 66, 364, 77): 'category_id'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id, 'results',\n    'categories', category_id)", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((388, 53, 389, 66), 'elasticsearch.client.utils._make_path', '_make_path', ({(388, 64, 388, 72): '"""_xpack"""', (388, 74, 388, 78): '"""ml"""', (389, 12, 389, 31): '"""anomaly_detectors"""', (389, 33, 389, 39): 'job_id', (389, 41, 389, 50): '"""results"""', (389, 52, 389, 65): '"""influencers"""'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id, 'results',\n    'influencers')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((404, 53, 405, 37), 'elasticsearch.client.utils._make_path', '_make_path', ({(404, 64, 404, 72): '"""_xpack"""', (404, 74, 404, 78): '"""ml"""', (405, 12, 405, 23): '"""datafeeds"""', (405, 25, 405, 36): 'datafeed_id'}, {}), "('_xpack', 'ml', 'datafeeds', datafeed_id)", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((418, 56, 419, 43), 'elasticsearch.client.utils._make_path', '_make_path', ({(418, 67, 418, 75): '"""_xpack"""', (419, 12, 419, 16): '"""ml"""', (419, 18, 419, 29): '"""datafeeds"""', (419, 31, 419, 42): 'datafeed_id'}, {}), "('_xpack', 'ml', 'datafeeds', datafeed_id)", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((429, 53, 430, 50), 'elasticsearch.client.utils._make_path', '_make_path', ({(429, 64, 429, 72): '"""_xpack"""', (429, 74, 429, 78): '"""ml"""', (430, 12, 430, 31): '"""anomaly_detectors"""', (430, 33, 430, 39): 'job_id', (430, 41, 430, 49): '"""_stats"""'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id, '_stats')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((447, 54, 449, 22), 'elasticsearch.client.utils._make_path', '_make_path', ({(447, 65, 447, 73): '"""_xpack"""', (447, 75, 447, 79): '"""ml"""', (448, 12, 448, 31): '"""anomaly_detectors"""', (448, 33, 448, 39): 'job_id', (448, 41, 448, 58): '"""model_snapshots"""', (448, 60, 448, 71): 'snapshot_id', (449, 12, 449, 21): '"""_revert"""'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id, 'model_snapshots',\n    snapshot_id, '_revert')", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((470, 53, 471, 72), 'elasticsearch.client.utils._make_path', '_make_path', ({(470, 64, 470, 72): '"""_xpack"""', (470, 74, 470, 78): '"""ml"""', (471, 12, 471, 31): '"""anomaly_detectors"""', (471, 33, 471, 39): 'job_id', (471, 41, 471, 58): '"""model_snapshots"""', (471, 60, 471, 71): 'snapshot_id'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id, 'model_snapshots',\n    snapshot_id)", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n'), ((486, 56, 487, 78), 'elasticsearch.client.utils._make_path', '_make_path', ({(486, 67, 486, 75): '"""_xpack"""', (487, 12, 487, 16): '"""ml"""', (487, 18, 487, 37): '"""anomaly_detectors"""', (487, 39, 487, 45): 'job_id', (487, 47, 487, 64): '"""model_snapshots"""', (487, 66, 487, 77): 'snapshot_id'}, {}), "('_xpack', 'ml', 'anomaly_detectors', job_id, 'model_snapshots',\n    snapshot_id)", False, 'from elasticsearch.client.utils import NamespacedClient, query_params, _make_path, SKIP_IN_PATH\n')]