Module: Elasticsearch::API::MachineLearning::Actions

Included in:
MachineLearningClient
Defined in:
lib/elasticsearch/api/namespace/machine_learning.rb,
lib/elasticsearch/api/actions/machine_learning/info.rb,
lib/elasticsearch/api/actions/machine_learning/put_job.rb,
lib/elasticsearch/api/actions/machine_learning/forecast.rb,
lib/elasticsearch/api/actions/machine_learning/get_jobs.rb,
lib/elasticsearch/api/actions/machine_learning/open_job.rb,
lib/elasticsearch/api/actions/machine_learning/validate.rb,
lib/elasticsearch/api/actions/machine_learning/close_job.rb,
lib/elasticsearch/api/actions/machine_learning/flush_job.rb,
lib/elasticsearch/api/actions/machine_learning/post_data.rb,
lib/elasticsearch/api/actions/machine_learning/reset_job.rb,
lib/elasticsearch/api/actions/machine_learning/delete_job.rb,
lib/elasticsearch/api/actions/machine_learning/put_filter.rb,
lib/elasticsearch/api/actions/machine_learning/update_job.rb,
lib/elasticsearch/api/actions/machine_learning/get_buckets.rb,
lib/elasticsearch/api/actions/machine_learning/get_filters.rb,
lib/elasticsearch/api/actions/machine_learning/get_records.rb,
lib/elasticsearch/api/actions/machine_learning/put_calendar.rb,
lib/elasticsearch/api/actions/machine_learning/put_datafeed.rb,
lib/elasticsearch/api/actions/machine_learning/delete_filter.rb,
lib/elasticsearch/api/actions/machine_learning/get_calendars.rb,
lib/elasticsearch/api/actions/machine_learning/get_datafeeds.rb,
lib/elasticsearch/api/actions/machine_learning/get_job_stats.rb,
lib/elasticsearch/api/actions/machine_learning/stop_datafeed.rb,
lib/elasticsearch/api/actions/machine_learning/update_filter.rb,
lib/elasticsearch/api/actions/machine_learning/get_categories.rb,
lib/elasticsearch/api/actions/machine_learning/start_datafeed.rb,
lib/elasticsearch/api/actions/machine_learning/delete_calendar.rb,
lib/elasticsearch/api/actions/machine_learning/delete_datafeed.rb,
lib/elasticsearch/api/actions/machine_learning/delete_forecast.rb,
lib/elasticsearch/api/actions/machine_learning/get_influencers.rb,
lib/elasticsearch/api/actions/machine_learning/update_datafeed.rb,
lib/elasticsearch/api/actions/machine_learning/get_memory_stats.rb,
lib/elasticsearch/api/actions/machine_learning/preview_datafeed.rb,
lib/elasticsearch/api/actions/machine_learning/put_calendar_job.rb,
lib/elasticsearch/api/actions/machine_learning/set_upgrade_mode.rb,
lib/elasticsearch/api/actions/machine_learning/put_trained_model.rb,
lib/elasticsearch/api/actions/machine_learning/validate_detector.rb,
lib/elasticsearch/api/actions/machine_learning/get_datafeed_stats.rb,
lib/elasticsearch/api/actions/machine_learning/get_trained_models.rb,
lib/elasticsearch/api/actions/machine_learning/delete_calendar_job.rb,
lib/elasticsearch/api/actions/machine_learning/delete_expired_data.rb,
lib/elasticsearch/api/actions/machine_learning/evaluate_data_frame.rb,
lib/elasticsearch/api/actions/machine_learning/get_calendar_events.rb,
lib/elasticsearch/api/actions/machine_learning/get_model_snapshots.rb,
lib/elasticsearch/api/actions/machine_learning/get_overall_buckets.rb,
lib/elasticsearch/api/actions/machine_learning/infer_trained_model.rb,
lib/elasticsearch/api/actions/machine_learning/delete_trained_model.rb,
lib/elasticsearch/api/actions/machine_learning/post_calendar_events.rb,
lib/elasticsearch/api/actions/machine_learning/upgrade_job_snapshot.rb,
lib/elasticsearch/api/actions/machine_learning/delete_calendar_event.rb,
lib/elasticsearch/api/actions/machine_learning/delete_model_snapshot.rb,
lib/elasticsearch/api/actions/machine_learning/estimate_model_memory.rb,
lib/elasticsearch/api/actions/machine_learning/revert_model_snapshot.rb,
lib/elasticsearch/api/actions/machine_learning/update_model_snapshot.rb,
lib/elasticsearch/api/actions/machine_learning/put_trained_model_alias.rb,
lib/elasticsearch/api/actions/machine_learning/get_data_frame_analytics.rb,
lib/elasticsearch/api/actions/machine_learning/get_trained_models_stats.rb,
lib/elasticsearch/api/actions/machine_learning/put_data_frame_analytics.rb,
lib/elasticsearch/api/actions/machine_learning/stop_data_frame_analytics.rb,
lib/elasticsearch/api/actions/machine_learning/delete_trained_model_alias.rb,
lib/elasticsearch/api/actions/machine_learning/start_data_frame_analytics.rb,
lib/elasticsearch/api/actions/machine_learning/delete_data_frame_analytics.rb,
lib/elasticsearch/api/actions/machine_learning/update_data_frame_analytics.rb,
lib/elasticsearch/api/actions/machine_learning/explain_data_frame_analytics.rb,
lib/elasticsearch/api/actions/machine_learning/preview_data_frame_analytics.rb,
lib/elasticsearch/api/actions/machine_learning/put_trained_model_vocabulary.rb,
lib/elasticsearch/api/actions/machine_learning/stop_trained_model_deployment.rb,
lib/elasticsearch/api/actions/machine_learning/get_data_frame_analytics_stats.rb,
lib/elasticsearch/api/actions/machine_learning/start_trained_model_deployment.rb,
lib/elasticsearch/api/actions/machine_learning/update_trained_model_deployment.rb,
lib/elasticsearch/api/actions/machine_learning/get_model_snapshot_upgrade_stats.rb,
lib/elasticsearch/api/actions/machine_learning/put_trained_model_definition_part.rb,
lib/elasticsearch/api/actions/machine_learning/clear_trained_model_deployment_cache.rb

Instance Method Summary collapse

Instance Method Details

#clear_trained_model_deployment_cache(arguments = {}) ⇒ Object

Clear trained model deployment cache

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :model_id (String) —

    The unique identifier of the trained model.

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/elasticsearch/api/actions/machine_learning/clear_trained_model_deployment_cache.rb', line 32

def clear_trained_model_deployment_cache(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.clear_trained_model_deployment_cache' }

  defined_params = [:model_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'model_id' missing" unless arguments[:model_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _model_id = arguments.delete(:model_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/trained_models/#{Utils.__listify(_model_id)}/deployment/cache/_clear"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#close_job(arguments = {}) ⇒ Object

Close anomaly detection jobs

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The name of the job to close

  • :allow_no_match (Boolean) —

    Whether to ignore if a wildcard expression matches no jobs. (This includes ‘_all` string or when no jobs have been specified)

  • :force (Boolean) —

    True if the job should be forcefully closed

  • :timeout (Time) —

    Controls the time to wait until a job has closed. Default to 30 minutes

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The URL params optionally sent in the body

Raises:

  • (ArgumentError)

See Also:



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/close_job.rb', line 36

def close_job(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.close_job' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/_close"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete_calendar(arguments = {}) ⇒ Object

Delete a calendar

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :calendar_id (String) —

    The ID of the calendar to delete

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/elasticsearch/api/actions/machine_learning/delete_calendar.rb', line 32

def delete_calendar(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.delete_calendar' }

  defined_params = [:calendar_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'calendar_id' missing" unless arguments[:calendar_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _calendar_id = arguments.delete(:calendar_id)

  method = Elasticsearch::API::HTTP_DELETE
  path   = "_ml/calendars/#{Utils.__listify(_calendar_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete_calendar_event(arguments = {}) ⇒ Object

Delete events from a calendar

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :calendar_id (String) —

    The ID of the calendar to modify

  • :event_id (String) —

    The ID of the event to remove from the calendar

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/delete_calendar_event.rb', line 33

def delete_calendar_event(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.delete_calendar_event' }

  defined_params = %i[calendar_id event_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'calendar_id' missing" unless arguments[:calendar_id]
  raise ArgumentError, "Required argument 'event_id' missing" unless arguments[:event_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _calendar_id = arguments.delete(:calendar_id)

  _event_id = arguments.delete(:event_id)

  method = Elasticsearch::API::HTTP_DELETE
  path   = "_ml/calendars/#{Utils.__listify(_calendar_id)}/events/#{Utils.__listify(_event_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete_calendar_job(arguments = {}) ⇒ Object

Delete anomaly jobs from a calendar

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :calendar_id (String) —

    The ID of the calendar to modify

  • :job_id (String) —

    The ID of the job to remove from the calendar

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/delete_calendar_job.rb', line 33

def delete_calendar_job(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.delete_calendar_job' }

  defined_params = %i[calendar_id job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'calendar_id' missing" unless arguments[:calendar_id]
  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _calendar_id = arguments.delete(:calendar_id)

  _job_id = arguments.delete(:job_id)

  method = Elasticsearch::API::HTTP_DELETE
  path   = "_ml/calendars/#{Utils.__listify(_calendar_id)}/jobs/#{Utils.__listify(_job_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete_data_frame_analytics(arguments = {}) ⇒ Object

Delete a data frame analytics job

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :id (String) —

    The ID of the data frame analytics to delete

  • :force (Boolean) —

    True if the job should be forcefully deleted

  • :timeout (Time) —

    Controls the time to wait until a job is deleted. Defaults to 1 minute

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/elasticsearch/api/actions/machine_learning/delete_data_frame_analytics.rb', line 34

def delete_data_frame_analytics(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.delete_data_frame_analytics' }

  defined_params = [:id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'id' missing" unless arguments[:id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _id = arguments.delete(:id)

  method = Elasticsearch::API::HTTP_DELETE
  path   = "_ml/data_frame/analytics/#{Utils.__listify(_id)}"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete_datafeed(arguments = {}) ⇒ Object

Delete a datafeed

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :datafeed_id (String) —

    The ID of the datafeed to delete

  • :force (Boolean) —

    True if the datafeed should be forcefully deleted

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/elasticsearch/api/actions/machine_learning/delete_datafeed.rb', line 33

def delete_datafeed(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.delete_datafeed' }

  defined_params = [:datafeed_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'datafeed_id' missing" unless arguments[:datafeed_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _datafeed_id = arguments.delete(:datafeed_id)

  method = Elasticsearch::API::HTTP_DELETE
  path   = "_ml/datafeeds/#{Utils.__listify(_datafeed_id)}"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete_expired_data(arguments = {}) ⇒ Object

Delete expired ML data

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job(s) to perform expired data hygiene for

  • :requests_per_second (Number) —

    The desired requests per second for the deletion processes.

  • :timeout (Time) —

    How long can the underlying delete processes run until they are canceled

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    deleting expired data parameters

See Also:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/elasticsearch/api/actions/machine_learning/delete_expired_data.rb', line 35

def delete_expired_data(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.delete_expired_data' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  method = Elasticsearch::API::HTTP_DELETE
  path   = if _job_id
             "_ml/_delete_expired_data/#{Utils.__listify(_job_id)}"
           else
             '_ml/_delete_expired_data'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete_filter(arguments = {}) ⇒ Object

Delete a filter

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :filter_id (String) —

    The ID of the filter to delete

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/elasticsearch/api/actions/machine_learning/delete_filter.rb', line 32

def delete_filter(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.delete_filter' }

  defined_params = [:filter_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'filter_id' missing" unless arguments[:filter_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _filter_id = arguments.delete(:filter_id)

  method = Elasticsearch::API::HTTP_DELETE
  path   = "_ml/filters/#{Utils.__listify(_filter_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete_forecast(arguments = {}) ⇒ Object

Delete forecasts from a job

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job from which to delete forecasts

  • :forecast_id (String) —

    The ID of the forecast to delete, can be comma delimited list. Leaving blank implies ‘_all`

  • :allow_no_forecasts (Boolean) —

    Whether to ignore if ‘_all` matches no forecasts

  • :timeout (Time) —

    Controls the time to wait until the forecast(s) are deleted. Default to 30 seconds

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/elasticsearch/api/actions/machine_learning/delete_forecast.rb', line 35

def delete_forecast(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.delete_forecast' }

  defined_params = %i[job_id forecast_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _job_id = arguments.delete(:job_id)

  _forecast_id = arguments.delete(:forecast_id)

  method = Elasticsearch::API::HTTP_DELETE
  path   = if _job_id && _forecast_id
             "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/_forecast/#{Utils.__listify(_forecast_id)}"
           else
             "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/_forecast"
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete_job(arguments = {}) ⇒ Object

Delete an anomaly detection job

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job to delete

  • :force (Boolean) —

    True if the job should be forcefully deleted

  • :wait_for_completion (Boolean) —

    Should this request wait until the operation has completed before returning

  • :delete_user_annotations (Boolean) —

    Should annotations added by the user be deleted

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/elasticsearch/api/actions/machine_learning/delete_job.rb', line 35

def delete_job(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.delete_job' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _job_id = arguments.delete(:job_id)

  method = Elasticsearch::API::HTTP_DELETE
  path   = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete_model_snapshot(arguments = {}) ⇒ Object

Delete a model snapshot

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job to fetch

  • :snapshot_id (String) —

    The ID of the snapshot to delete

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/delete_model_snapshot.rb', line 33

def delete_model_snapshot(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.delete_model_snapshot' }

  defined_params = %i[job_id snapshot_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]
  raise ArgumentError, "Required argument 'snapshot_id' missing" unless arguments[:snapshot_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _job_id = arguments.delete(:job_id)

  _snapshot_id = arguments.delete(:snapshot_id)

  method = Elasticsearch::API::HTTP_DELETE
  path   = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/model_snapshots/#{Utils.__listify(_snapshot_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete_trained_model(arguments = {}) ⇒ Object

Delete an unreferenced trained model

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :model_id (String) —

    The ID of the trained model to delete

  • :timeout (Time) —

    Controls the amount of time to wait for the model to be deleted.

  • :force (Boolean) —

    True if the model should be forcefully deleted

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/elasticsearch/api/actions/machine_learning/delete_trained_model.rb', line 34

def delete_trained_model(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.delete_trained_model' }

  defined_params = [:model_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'model_id' missing" unless arguments[:model_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _model_id = arguments.delete(:model_id)

  method = Elasticsearch::API::HTTP_DELETE
  path   = "_ml/trained_models/#{Utils.__listify(_model_id)}"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#delete_trained_model_alias(arguments = {}) ⇒ Object

Delete a trained model alias

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :model_alias (String) —

    The trained model alias to delete

  • :model_id (String) —

    The trained model where the model alias is assigned

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/delete_trained_model_alias.rb', line 33

def delete_trained_model_alias(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.delete_trained_model_alias' }

  defined_params = %i[model_id model_alias].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'model_id' missing" unless arguments[:model_id]
  raise ArgumentError, "Required argument 'model_alias' missing" unless arguments[:model_alias]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _model_alias = arguments.delete(:model_alias)

  _model_id = arguments.delete(:model_id)

  method = Elasticsearch::API::HTTP_DELETE
  path   = "_ml/trained_models/#{Utils.__listify(_model_id)}/model_aliases/#{Utils.__listify(_model_alias)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#estimate_model_memory(arguments = {}) ⇒ Object

Estimate job model memory usage

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The analysis config, plus cardinality estimates for fields it references (Required)

Raises:

  • (ArgumentError)

See Also:



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/elasticsearch/api/actions/machine_learning/estimate_model_memory.rb', line 32

def estimate_model_memory(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.estimate_model_memory' }

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body   = arguments.delete(:body)

  method = Elasticsearch::API::HTTP_POST
  path   = '_ml/anomaly_detectors/_estimate_model_memory'
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#evaluate_data_frame(arguments = {}) ⇒ Object

Evaluate data frame analytics

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The evaluation definition (Required)

Raises:

  • (ArgumentError)

See Also:



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/elasticsearch/api/actions/machine_learning/evaluate_data_frame.rb', line 32

def evaluate_data_frame(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.evaluate_data_frame' }

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body   = arguments.delete(:body)

  method = Elasticsearch::API::HTTP_POST
  path   = '_ml/data_frame/_evaluate'
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#explain_data_frame_analytics(arguments = {}) ⇒ Object

Explain data frame analytics config

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :id (String) —

    The ID of the data frame analytics to explain

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The data frame analytics config to explain

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/elasticsearch/api/actions/machine_learning/explain_data_frame_analytics.rb', line 33

def explain_data_frame_analytics(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.explain_data_frame_analytics' }

  defined_params = [:id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _id = arguments.delete(:id)

  method = if body
             Elasticsearch::API::HTTP_POST
           else
             Elasticsearch::API::HTTP_GET
           end

  path = if _id
           "_ml/data_frame/analytics/#{Utils.__listify(_id)}/_explain"
         else
           '_ml/data_frame/analytics/_explain'
         end
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#flush_job(arguments = {}) ⇒ Object

Force buffered data to be processed

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The name of the job to flush

  • :calc_interim (Boolean) —

    Calculates interim results for the most recent bucket or all buckets within the latency period

  • :start (Date) —

    When used in conjunction with calc_interim, specifies the range of buckets on which to calculate interim results

  • :end (Date) —

    When used in conjunction with calc_interim, specifies the range of buckets on which to calculate interim results

  • :advance_time (Date) —

    Advances time to the given value generating results and updating the model for the advanced interval

  • :skip_time (Date) —

    Skips time to the given value without generating results or updating the model for the skipped interval

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    Flush parameters

Raises:

  • (ArgumentError)

See Also:



38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/elasticsearch/api/actions/machine_learning/flush_job.rb', line 38

def flush_job(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.flush_job' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/_flush"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#forecast(arguments = {}) ⇒ Object

Predict future behavior of a time series

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job to forecast for

  • :duration (Time) —

    The duration of the forecast

  • :expires_in (Time) —

    The time interval after which the forecast expires. Expired forecasts will be deleted at the first opportunity.

  • :max_model_memory (String) —

    The max memory able to be used by the forecast. Default is 20mb.

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    Query parameters can be specified in the body

Raises:

  • (ArgumentError)

See Also:



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/forecast.rb', line 36

def forecast(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.forecast' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/_forecast"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_buckets(arguments = {}) ⇒ Object

Get anomaly detection job results for buckets

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    ID of the job to get bucket results from

  • :timestamp (Date) —

    The timestamp of the desired single bucket result

  • :expand (Boolean) —

    Include anomaly records

  • :exclude_interim (Boolean) —

    Exclude interim results

  • :from (Integer) —

    skips a number of buckets

  • :size (Integer) —

    specifies a max number of buckets to get

  • :start (Date) —

    Start time filter for buckets

  • :end (Date) —

    End time filter for buckets

  • :anomaly_score (Double) —

    Filter for the most anomalous buckets

  • :sort (String) —

    Sort buckets by a particular field

  • :desc (Boolean) —

    Set the sort direction

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    Bucket selection details if not provided in URI

Raises:

  • (ArgumentError)

See Also:



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_buckets.rb', line 43

def get_buckets(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_buckets' }

  defined_params = %i[job_id timestamp].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  _timestamp = arguments.delete(:timestamp)

  method = if body
             Elasticsearch::API::HTTP_POST
           else
             Elasticsearch::API::HTTP_GET
           end

  path = if _job_id && _timestamp
           "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/results/buckets/#{Utils.__listify(_timestamp)}"
         else
           "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/results/buckets"
         end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_calendar_events(arguments = {}) ⇒ Object

Get info about events in calendars

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :calendar_id (String) —

    The ID of the calendar containing the events

  • :job_id (String) —

    Get events for the job. When this option is used calendar_id must be ‘_all’

  • :start (Date) —

    Get events after this time

  • :end (Date) —

    Get events before this time

  • :from (Integer) —

    Skips a number of events

  • :size (Integer) —

    Specifies a max number of events to get

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_calendar_events.rb', line 37

def get_calendar_events(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_calendar_events' }

  defined_params = [:calendar_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'calendar_id' missing" unless arguments[:calendar_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _calendar_id = arguments.delete(:calendar_id)

  method = Elasticsearch::API::HTTP_GET
  path   = "_ml/calendars/#{Utils.__listify(_calendar_id)}/events"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_calendars(arguments = {}) ⇒ Object

Get calendar configuration info

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :calendar_id (String) —

    The ID of the calendar to fetch

  • :from (Integer) —

    skips a number of calendars

  • :size (Integer) —

    specifies a max number of calendars to get

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The from and size parameters optionally sent in the body

See Also:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_calendars.rb', line 35

def get_calendars(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_calendars' }

  defined_params = [:calendar_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _calendar_id = arguments.delete(:calendar_id)

  method = if body
             Elasticsearch::API::HTTP_POST
           else
             Elasticsearch::API::HTTP_GET
           end

  path = if _calendar_id
           "_ml/calendars/#{Utils.__listify(_calendar_id)}"
         else
           '_ml/calendars'
         end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_categories(arguments = {}) ⇒ Object

Get anomaly detection job results for categories

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The name of the job

  • :category_id (Long) —

    The identifier of the category definition of interest

  • :from (Integer) —

    skips a number of categories

  • :size (Integer) —

    specifies a max number of categories to get

  • :partition_field_value (String) —

    Specifies the partition to retrieve categories for. This is optional, and should never be used for jobs where per-partition categorization is disabled.

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    Category selection details if not provided in URI

Raises:

  • (ArgumentError)

See Also:



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_categories.rb', line 37

def get_categories(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_categories' }

  defined_params = %i[job_id category_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  _category_id = arguments.delete(:category_id)

  method = if body
             Elasticsearch::API::HTTP_POST
           else
             Elasticsearch::API::HTTP_GET
           end

  path = if _job_id && _category_id
           "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/results/categories/#{Utils.__listify(_category_id)}"
         else
           "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/results/categories"
         end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_data_frame_analytics(arguments = {}) ⇒ Object

Get data frame analytics job configuration info

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :id (String) —

    The ID of the data frame analytics to fetch

  • :allow_no_match (Boolean) —

    Whether to ignore if a wildcard expression matches no data frame analytics. (This includes ‘_all` string or when no data frame analytics have been specified)

  • :from (Integer) —

    skips a number of analytics

  • :size (Integer) —

    specifies a max number of analytics to get

  • :exclude_generated (Boolean) —

    Omits fields that are illegal to set on data frame analytics PUT

  • :headers (Hash) —

    Custom HTTP headers

See Also:



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_data_frame_analytics.rb', line 36

def get_data_frame_analytics(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_data_frame_analytics' }

  defined_params = [:id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _id = arguments.delete(:id)

  method = Elasticsearch::API::HTTP_GET
  path   = if _id
             "_ml/data_frame/analytics/#{Utils.__listify(_id)}"
           else
             '_ml/data_frame/analytics'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_data_frame_analytics_stats(arguments = {}) ⇒ Object

Get data frame analytics job stats

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :id (String) —

    The ID of the data frame analytics stats to fetch

  • :allow_no_match (Boolean) —

    Whether to ignore if a wildcard expression matches no data frame analytics. (This includes ‘_all` string or when no data frame analytics have been specified)

  • :from (Integer) —

    skips a number of analytics

  • :size (Integer) —

    specifies a max number of analytics to get

  • :verbose (Boolean) —

    whether the stats response should be verbose

  • :headers (Hash) —

    Custom HTTP headers

See Also:



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_data_frame_analytics_stats.rb', line 36

def get_data_frame_analytics_stats(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_data_frame_analytics_stats' }

  defined_params = [:id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _id = arguments.delete(:id)

  method = Elasticsearch::API::HTTP_GET
  path   = if _id
             "_ml/data_frame/analytics/#{Utils.__listify(_id)}/_stats"
           else
             '_ml/data_frame/analytics/_stats'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_datafeed_stats(arguments = {}) ⇒ Object

Get datafeed stats

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :datafeed_id (String) —

    The ID of the datafeeds stats to fetch

  • :allow_no_match (Boolean) —

    Whether to ignore if a wildcard expression matches no datafeeds. (This includes ‘_all` string or when no datafeeds have been specified)

  • :headers (Hash) —

    Custom HTTP headers

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_datafeed_stats.rb', line 33

def get_datafeed_stats(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_datafeed_stats' }

  defined_params = [:datafeed_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _datafeed_id = arguments.delete(:datafeed_id)

  method = Elasticsearch::API::HTTP_GET
  path   = if _datafeed_id
             "_ml/datafeeds/#{Utils.__listify(_datafeed_id)}/_stats"
           else
             '_ml/datafeeds/_stats'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_datafeeds(arguments = {}) ⇒ Object

Get datafeeds configuration info

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :datafeed_id (String) —

    The ID of the datafeeds to fetch

  • :allow_no_match (Boolean) —

    Whether to ignore if a wildcard expression matches no datafeeds. (This includes ‘_all` string or when no datafeeds have been specified)

  • :exclude_generated (Boolean) —

    Omits fields that are illegal to set on datafeed PUT

  • :headers (Hash) —

    Custom HTTP headers

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_datafeeds.rb', line 34

def get_datafeeds(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_datafeeds' }

  defined_params = [:datafeed_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _datafeed_id = arguments.delete(:datafeed_id)

  method = Elasticsearch::API::HTTP_GET
  path   = if _datafeed_id
             "_ml/datafeeds/#{Utils.__listify(_datafeed_id)}"
           else
             '_ml/datafeeds'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_filters(arguments = {}) ⇒ Object

Get filters

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :filter_id (String) —

    The ID of the filter to fetch

  • :from (Integer) —

    skips a number of filters

  • :size (Integer) —

    specifies a max number of filters to get

  • :headers (Hash) —

    Custom HTTP headers

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_filters.rb', line 34

def get_filters(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_filters' }

  defined_params = [:filter_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _filter_id = arguments.delete(:filter_id)

  method = Elasticsearch::API::HTTP_GET
  path   = if _filter_id
             "_ml/filters/#{Utils.__listify(_filter_id)}"
           else
             '_ml/filters'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_influencers(arguments = {}) ⇒ Object

Get anomaly detection job results for influencers

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    Identifier for the anomaly detection job

  • :exclude_interim (Boolean) —

    Exclude interim results

  • :from (Integer) —

    skips a number of influencers

  • :size (Integer) —

    specifies a max number of influencers to get

  • :start (Date) —

    start timestamp for the requested influencers

  • :end (Date) —

    end timestamp for the requested influencers

  • :influencer_score (Double) —

    influencer score threshold for the requested influencers

  • :sort (String) —

    sort field for the requested influencers

  • :desc (Boolean) —

    whether the results should be sorted in decending order

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    Influencer selection criteria

Raises:

  • (ArgumentError)

See Also:



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_influencers.rb', line 41

def get_influencers(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_influencers' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  method = if body
             Elasticsearch::API::HTTP_POST
           else
             Elasticsearch::API::HTTP_GET
           end

  path = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/results/influencers"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_job_stats(arguments = {}) ⇒ Object

Get anomaly detection job stats

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the jobs stats to fetch

  • :allow_no_match (Boolean) —

    Whether to ignore if a wildcard expression matches no jobs. (This includes ‘_all` string or when no jobs have been specified)

  • :headers (Hash) —

    Custom HTTP headers

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_job_stats.rb', line 33

def get_job_stats(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_job_stats' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _job_id = arguments.delete(:job_id)

  method = Elasticsearch::API::HTTP_GET
  path   = if _job_id
             "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/_stats"
           else
             '_ml/anomaly_detectors/_stats'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_jobs(arguments = {}) ⇒ Object

Get anomaly detection jobs configuration info

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the jobs to fetch

  • :allow_no_match (Boolean) —

    Whether to ignore if a wildcard expression matches no jobs. (This includes ‘_all` string or when no jobs have been specified)

  • :exclude_generated (Boolean) —

    Omits fields that are illegal to set on job PUT

  • :headers (Hash) —

    Custom HTTP headers

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_jobs.rb', line 34

def get_jobs(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_jobs' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _job_id = arguments.delete(:job_id)

  method = Elasticsearch::API::HTTP_GET
  path   = if _job_id
             "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}"
           else
             '_ml/anomaly_detectors'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_memory_stats(arguments = {}) ⇒ Object

Get machine learning memory usage info

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :node_id (String) —

    Specifies the node or nodes to retrieve stats for.

  • :master_timeout (Time) —

    Explicit operation timeout for connection to master node

  • :timeout (Time) —

    Explicit operation timeout

  • :headers (Hash) —

    Custom HTTP headers

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_memory_stats.rb', line 34

def get_memory_stats(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_memory_stats' }

  defined_params = [:node_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _node_id = arguments.delete(:node_id)

  method = Elasticsearch::API::HTTP_GET
  path   = if _node_id
             "_ml/memory/#{Utils.__listify(_node_id)}/_stats"
           else
             '_ml/memory/_stats'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_model_snapshot_upgrade_stats(arguments = {}) ⇒ Object

Get anomaly detection job model snapshot upgrade usage info

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job. May be a wildcard, comma separated list or ‘_all`.

  • :snapshot_id (String) —

    The ID of the snapshot. May be a wildcard, comma separated list or ‘_all`.

  • :allow_no_match (Boolean) —

    Whether to ignore if a wildcard expression matches no jobs or no snapshots. (This includes the ‘_all` string.)

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_model_snapshot_upgrade_stats.rb', line 34

def get_model_snapshot_upgrade_stats(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_model_snapshot_upgrade_stats' }

  defined_params = %i[job_id snapshot_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]
  raise ArgumentError, "Required argument 'snapshot_id' missing" unless arguments[:snapshot_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _job_id = arguments.delete(:job_id)

  _snapshot_id = arguments.delete(:snapshot_id)

  method = Elasticsearch::API::HTTP_GET
  path   = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/model_snapshots/#{Utils.__listify(_snapshot_id)}/_upgrade/_stats"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_model_snapshots(arguments = {}) ⇒ Object

Get model snapshots info

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job to fetch

  • :snapshot_id (String) —

    The ID of the snapshot to fetch

  • :from (Integer) —

    Skips a number of documents

  • :size (Integer) —

    The default number of documents returned in queries as a string.

  • :start (Date) —

    The filter ‘start’ query parameter

  • :end (Date) —

    The filter ‘end’ query parameter

  • :sort (String) —

    Name of the field to sort on

  • :desc (Boolean) —

    True if the results should be sorted in descending order

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    Model snapshot selection criteria

Raises:

  • (ArgumentError)

See Also:



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_model_snapshots.rb', line 40

def get_model_snapshots(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_model_snapshots' }

  defined_params = %i[job_id snapshot_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  _snapshot_id = arguments.delete(:snapshot_id)

  method = if body
             Elasticsearch::API::HTTP_POST
           else
             Elasticsearch::API::HTTP_GET
           end

  path = if _job_id && _snapshot_id
           "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/model_snapshots/#{Utils.__listify(_snapshot_id)}"
         else
           "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/model_snapshots"
         end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_overall_buckets(arguments = {}) ⇒ Object

Get overall bucket results

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The job IDs for which to calculate overall bucket results

  • :top_n (Integer) —

    The number of top job bucket scores to be used in the overall_score calculation

  • :bucket_span (Time) —

    The span of the overall buckets. Defaults to the longest job bucket_span

  • :overall_score (Double) —

    Returns overall buckets with overall scores higher than this value

  • :exclude_interim (Boolean) —

    If true overall buckets that include interim buckets will be excluded

  • :start (Date) —

    Returns overall buckets with timestamps after this time

  • :end (Date) —

    Returns overall buckets with timestamps earlier than this time

  • :allow_no_match (Boolean) —

    Whether to ignore if a wildcard expression matches no jobs. (This includes ‘_all` string or when no jobs have been specified)

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    Overall bucket selection details if not provided in URI

Raises:

  • (ArgumentError)

See Also:



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_overall_buckets.rb', line 40

def get_overall_buckets(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_overall_buckets' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  method = if body
             Elasticsearch::API::HTTP_POST
           else
             Elasticsearch::API::HTTP_GET
           end

  path = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/results/overall_buckets"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_records(arguments = {}) ⇒ Object

Get anomaly records for an anomaly detection job

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job

  • :exclude_interim (Boolean) —

    Exclude interim results

  • :from (Integer) —

    skips a number of records

  • :size (Integer) —

    specifies a max number of records to get

  • :start (Date) —

    Start time filter for records

  • :end (Date) —

    End time filter for records

  • :record_score (Double) —

    Returns records with anomaly scores greater or equal than this value

  • :sort (String) —

    Sort records by a particular field

  • :desc (Boolean) —

    Set the sort direction

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    Record selection criteria

Raises:

  • (ArgumentError)

See Also:



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_records.rb', line 41

def get_records(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_records' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  method = if body
             Elasticsearch::API::HTTP_POST
           else
             Elasticsearch::API::HTTP_GET
           end

  path = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/results/records"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_trained_models(arguments = {}) ⇒ Object

Get trained model configuration info

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :model_id (String) —

    The ID of the trained models to fetch

  • :allow_no_match (Boolean) —

    Whether to ignore if a wildcard expression matches no trained models. (This includes ‘_all` string or when no trained models have been specified)

  • :include (String) —

    A comma delimited string of optional fields to include in the response body. (options: definition, feature_importance_baseline, hyperparameters, total_feature_importance, definition_status)

  • :include_model_definition (Boolean) —

    Should the full model definition be included in the results. These definitions can be large. So be cautious when including them. Defaults to false. Deprecated

  • :decompress_definition (Boolean) —

    Should the model definition be decompressed into valid JSON or returned in a custom compressed format. Defaults to true.

  • :from (Integer) —

    skips a number of trained models

  • :size (Integer) —

    specifies a max number of trained models to get

  • :tags (List) —

    A comma-separated list of tags that the model must have.

  • :exclude_generated (Boolean) —

    Omits fields that are illegal to set on model PUT

  • :headers (Hash) —

    Custom HTTP headers

See Also:



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_trained_models.rb', line 40

def get_trained_models(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_trained_models' }

  defined_params = [:model_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _model_id = arguments.delete(:model_id)

  method = Elasticsearch::API::HTTP_GET
  path   = if _model_id
             "_ml/trained_models/#{Utils.__listify(_model_id)}"
           else
             '_ml/trained_models'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#get_trained_models_stats(arguments = {}) ⇒ Object

Get trained models usage info

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :model_id (String) —

    The ID of the trained models stats to fetch

  • :allow_no_match (Boolean) —

    Whether to ignore if a wildcard expression matches no trained models. (This includes ‘_all` string or when no trained models have been specified)

  • :from (Integer) —

    skips a number of trained models

  • :size (Integer) —

    specifies a max number of trained models to get

  • :headers (Hash) —

    Custom HTTP headers

See Also:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/elasticsearch/api/actions/machine_learning/get_trained_models_stats.rb', line 35

def get_trained_models_stats(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.get_trained_models_stats' }

  defined_params = [:model_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _model_id = arguments.delete(:model_id)

  method = Elasticsearch::API::HTTP_GET
  path   = if _model_id
             "_ml/trained_models/#{Utils.__listify(_model_id)}/_stats"
           else
             '_ml/trained_models/_stats'
           end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#infer_trained_model(arguments = {}) ⇒ Object

Evaluate a trained model

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :model_id (String) —

    The unique identifier of the trained model. (Required)

  • :timeout (Time) —

    Controls the amount of time to wait for inference results.

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The docs to apply inference on and inference configuration overrides (Required)

Raises:

  • (ArgumentError)

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/elasticsearch/api/actions/machine_learning/infer_trained_model.rb', line 34

def infer_trained_model(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.infer_trained_model' }

  defined_params = [:model_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'model_id' missing" unless arguments[:model_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _model_id = arguments.delete(:model_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/trained_models/#{Utils.__listify(_model_id)}/_infer"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#info(arguments = {}) ⇒ Object

Get machine learning information

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :headers (Hash) —

    Custom HTTP headers

See Also:



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/elasticsearch/api/actions/machine_learning/info.rb', line 31

def info(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.info' }

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body   = nil

  method = Elasticsearch::API::HTTP_GET
  path   = '_ml/info'
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#open_job(arguments = {}) ⇒ Object

Open anomaly detection jobs

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job to open

  • :timeout (Time) —

    Controls the time to wait until a job has opened.

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    Query parameters can be specified in the body

Raises:

  • (ArgumentError)

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/elasticsearch/api/actions/machine_learning/open_job.rb', line 34

def open_job(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.open_job' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/_open"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#post_calendar_events(arguments = {}) ⇒ Object

Add scheduled events to the calendar

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :calendar_id (String) —

    The ID of the calendar to modify

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    A list of events (Required)

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/elasticsearch/api/actions/machine_learning/post_calendar_events.rb', line 33

def post_calendar_events(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.post_calendar_events' }

  defined_params = [:calendar_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'calendar_id' missing" unless arguments[:calendar_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _calendar_id = arguments.delete(:calendar_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/calendars/#{Utils.__listify(_calendar_id)}/events"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#post_data(arguments = {}) ⇒ Object

Send data to an anomaly detection job for analysis

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The name of the job receiving the data

  • :reset_start (Date) —

    Optional parameter to specify the start of the bucket resetting range

  • :reset_end (Date) —

    Optional parameter to specify the end of the bucket resetting range

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The data to process (Required)

Raises:

  • (ArgumentError)

See Also:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/post_data.rb', line 35

def post_data(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.post_data' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/_data"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#preview_data_frame_analytics(arguments = {}) ⇒ Object

Preview features used by data frame analytics

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :id (String) —

    The ID of the data frame analytics to preview

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The data frame analytics config to preview

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/elasticsearch/api/actions/machine_learning/preview_data_frame_analytics.rb', line 33

def preview_data_frame_analytics(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.preview_data_frame_analytics' }

  defined_params = [:id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _id = arguments.delete(:id)

  method = if body
             Elasticsearch::API::HTTP_POST
           else
             Elasticsearch::API::HTTP_GET
           end

  path = if _id
           "_ml/data_frame/analytics/#{Utils.__listify(_id)}/_preview"
         else
           '_ml/data_frame/analytics/_preview'
         end
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#preview_datafeed(arguments = {}) ⇒ Object

Preview a datafeed

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :datafeed_id (String) —

    The ID of the datafeed to preview

  • :start (Date) —

    The start time from where the datafeed preview should begin

  • :end (Date) —

    The end time when the datafeed preview should stop

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The datafeed config and job config with which to execute the preview

See Also:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/elasticsearch/api/actions/machine_learning/preview_datafeed.rb', line 35

def preview_datafeed(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.preview_datafeed' }

  defined_params = [:datafeed_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _datafeed_id = arguments.delete(:datafeed_id)

  method = if body
             Elasticsearch::API::HTTP_POST
           else
             Elasticsearch::API::HTTP_GET
           end

  path = if _datafeed_id
           "_ml/datafeeds/#{Utils.__listify(_datafeed_id)}/_preview"
         else
           '_ml/datafeeds/_preview'
         end
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_calendar(arguments = {}) ⇒ Object

Create a calendar

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :calendar_id (String) —

    The ID of the calendar to create

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The calendar details

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/elasticsearch/api/actions/machine_learning/put_calendar.rb', line 33

def put_calendar(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.put_calendar' }

  defined_params = [:calendar_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'calendar_id' missing" unless arguments[:calendar_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _calendar_id = arguments.delete(:calendar_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_ml/calendars/#{Utils.__listify(_calendar_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_calendar_job(arguments = {}) ⇒ Object

Add anomaly detection job to calendar

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :calendar_id (String) —

    The ID of the calendar to modify

  • :job_id (String) —

    The ID of the job to add to the calendar

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/put_calendar_job.rb', line 33

def put_calendar_job(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.put_calendar_job' }

  defined_params = %i[calendar_id job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'calendar_id' missing" unless arguments[:calendar_id]
  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _calendar_id = arguments.delete(:calendar_id)

  _job_id = arguments.delete(:job_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_ml/calendars/#{Utils.__listify(_calendar_id)}/jobs/#{Utils.__listify(_job_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_data_frame_analytics(arguments = {}) ⇒ Object

Create a data frame analytics job

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :id (String) —

    The ID of the data frame analytics to create

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The data frame analytics configuration (Required)

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/elasticsearch/api/actions/machine_learning/put_data_frame_analytics.rb', line 33

def put_data_frame_analytics(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.put_data_frame_analytics' }

  defined_params = [:id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'id' missing" unless arguments[:id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _id = arguments.delete(:id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_ml/data_frame/analytics/#{Utils.__listify(_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_datafeed(arguments = {}) ⇒ Object

Create a datafeed

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :datafeed_id (String) —

    The ID of the datafeed to create

  • :ignore_unavailable (Boolean) —

    Ignore unavailable indexes (default: false)

  • :allow_no_indices (Boolean) —

    Ignore if the source indices expressions resolves to no concrete indices (default: true)

  • :ignore_throttled (Boolean) —

    Ignore indices that are marked as throttled (default: true) Deprecated

  • :expand_wildcards (List) —

    Whether source index expressions should get expanded to open or closed indices (default: open) (options: open, closed, hidden, none, all)

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The datafeed config (Required)

Raises:

  • (ArgumentError)

See Also:



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/elasticsearch/api/actions/machine_learning/put_datafeed.rb', line 37

def put_datafeed(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.put_datafeed' }

  defined_params = [:datafeed_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'datafeed_id' missing" unless arguments[:datafeed_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _datafeed_id = arguments.delete(:datafeed_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_ml/datafeeds/#{Utils.__listify(_datafeed_id)}"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_filter(arguments = {}) ⇒ Object

Create a filter

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :filter_id (String) —

    The ID of the filter to create

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The filter details (Required)

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/elasticsearch/api/actions/machine_learning/put_filter.rb', line 33

def put_filter(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.put_filter' }

  defined_params = [:filter_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'filter_id' missing" unless arguments[:filter_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _filter_id = arguments.delete(:filter_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_ml/filters/#{Utils.__listify(_filter_id)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_job(arguments = {}) ⇒ Object

Create an anomaly detection job

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job to create

  • :ignore_unavailable (Boolean) —

    Ignore unavailable indexes (default: false). Only set if datafeed_config is provided.

  • :allow_no_indices (Boolean) —

    Ignore if the source indices expressions resolves to no concrete indices (default: true). Only set if datafeed_config is provided.

  • :ignore_throttled (Boolean) —

    Ignore indices that are marked as throttled (default: true). Only set if datafeed_config is provided. Deprecated

  • :expand_wildcards (List) —

    Whether source index expressions should get expanded to open or closed indices (default: open). Only set if datafeed_config is provided. (options: open, closed, hidden, none, all)

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The job (Required)

Raises:

  • (ArgumentError)

See Also:



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/elasticsearch/api/actions/machine_learning/put_job.rb', line 37

def put_job(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.put_job' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_trained_model(arguments = {}) ⇒ Object

Create a trained model

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :model_id (String) —

    The ID of the trained models to store

  • :defer_definition_decompression (Boolean) —

    If set to ‘true` and a `compressed_definition` is provided, the request defers definition decompression and skips relevant validations.

  • :wait_for_completion (Boolean) —

    Whether to wait for all child operations(e.g. model download) to complete, before returning or not. Default to false

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The trained model configuration (Required)

Raises:

  • (ArgumentError)

See Also:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/put_trained_model.rb', line 35

def put_trained_model(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.put_trained_model' }

  defined_params = [:model_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'model_id' missing" unless arguments[:model_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _model_id = arguments.delete(:model_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_ml/trained_models/#{Utils.__listify(_model_id)}"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_trained_model_alias(arguments = {}) ⇒ Object

Create or update a trained model alias

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :model_alias (String) —

    The trained model alias to update

  • :model_id (String) —

    The trained model where the model alias should be assigned

  • :reassign (Boolean) —

    If the model_alias already exists and points to a separate model_id, this parameter must be true. Defaults to false.

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/elasticsearch/api/actions/machine_learning/put_trained_model_alias.rb', line 34

def put_trained_model_alias(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.put_trained_model_alias' }

  defined_params = %i[model_id model_alias].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'model_id' missing" unless arguments[:model_id]
  raise ArgumentError, "Required argument 'model_alias' missing" unless arguments[:model_alias]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _model_alias = arguments.delete(:model_alias)

  _model_id = arguments.delete(:model_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_ml/trained_models/#{Utils.__listify(_model_id)}/model_aliases/#{Utils.__listify(_model_alias)}"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_trained_model_definition_part(arguments = {}) ⇒ Object

Create part of a trained model definition

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :model_id (String) —

    The ID of the trained model for this definition part

  • :part (Integer) —

    The part number

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The trained model definition part (Required)

Raises:

  • (ArgumentError)

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/elasticsearch/api/actions/machine_learning/put_trained_model_definition_part.rb', line 34

def put_trained_model_definition_part(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.put_trained_model_definition_part' }

  defined_params = %i[model_id part].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'model_id' missing" unless arguments[:model_id]
  raise ArgumentError, "Required argument 'part' missing" unless arguments[:part]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _model_id = arguments.delete(:model_id)

  _part = arguments.delete(:part)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_ml/trained_models/#{Utils.__listify(_model_id)}/definition/#{Utils.__listify(_part)}"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#put_trained_model_vocabulary(arguments = {}) ⇒ Object

Create a trained model vocabulary

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :model_id (String) —

    The ID of the trained model for this vocabulary

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The trained model vocabulary (Required)

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/elasticsearch/api/actions/machine_learning/put_trained_model_vocabulary.rb', line 33

def put_trained_model_vocabulary(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.put_trained_model_vocabulary' }

  defined_params = [:model_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'model_id' missing" unless arguments[:model_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _model_id = arguments.delete(:model_id)

  method = Elasticsearch::API::HTTP_PUT
  path   = "_ml/trained_models/#{Utils.__listify(_model_id)}/vocabulary"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#reset_job(arguments = {}) ⇒ Object

Reset an anomaly detection job

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job to reset

  • :wait_for_completion (Boolean) —

    Should this request wait until the operation has completed before returning

  • :delete_user_annotations (Boolean) —

    Should annotations added by the user be deleted

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/elasticsearch/api/actions/machine_learning/reset_job.rb', line 34

def reset_job(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.reset_job' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _job_id = arguments.delete(:job_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/_reset"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#revert_model_snapshot(arguments = {}) ⇒ Object

Revert to a snapshot

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job to fetch

  • :snapshot_id (String) —

    The ID of the snapshot to revert to

  • :delete_intervening_results (Boolean) —

    Should we reset the results back to the time of the snapshot?

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    Reversion options

Raises:

  • (ArgumentError)

See Also:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/elasticsearch/api/actions/machine_learning/revert_model_snapshot.rb', line 35

def revert_model_snapshot(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.revert_model_snapshot' }

  defined_params = %i[job_id snapshot_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]
  raise ArgumentError, "Required argument 'snapshot_id' missing" unless arguments[:snapshot_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  _snapshot_id = arguments.delete(:snapshot_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/model_snapshots/#{Utils.__listify(_snapshot_id)}/_revert"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#set_upgrade_mode(arguments = {}) ⇒ Object

Set upgrade_mode for ML indices

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :enabled (Boolean) —

    Whether to enable upgrade_mode ML setting or not. Defaults to false.

  • :timeout (Time) —

    Controls the time to wait before action times out. Defaults to 30 seconds

  • :headers (Hash) —

    Custom HTTP headers

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'lib/elasticsearch/api/actions/machine_learning/set_upgrade_mode.rb', line 33

def set_upgrade_mode(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.set_upgrade_mode' }

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body   = nil

  method = Elasticsearch::API::HTTP_POST
  path   = '_ml/set_upgrade_mode'
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#start_data_frame_analytics(arguments = {}) ⇒ Object

Start a data frame analytics job

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :id (String) —

    The ID of the data frame analytics to start

  • :timeout (Time) —

    Controls the time to wait until the task has started. Defaults to 20 seconds

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The start data frame analytics parameters

Raises:

  • (ArgumentError)

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/elasticsearch/api/actions/machine_learning/start_data_frame_analytics.rb', line 34

def start_data_frame_analytics(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.start_data_frame_analytics' }

  defined_params = [:id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'id' missing" unless arguments[:id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _id = arguments.delete(:id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/data_frame/analytics/#{Utils.__listify(_id)}/_start"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#start_datafeed(arguments = {}) ⇒ Object

Start datafeeds

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :datafeed_id (String) —

    The ID of the datafeed to start

  • :start (Date) —

    The start time from where the datafeed should begin

  • :end (Date) —

    The end time when the datafeed should stop. When not set, the datafeed continues in real time

  • :timeout (Time) —

    Controls the time to wait until a datafeed has started. Default to 20 seconds

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The start datafeed parameters

Raises:

  • (ArgumentError)

See Also:



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/start_datafeed.rb', line 36

def start_datafeed(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.start_datafeed' }

  defined_params = [:datafeed_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'datafeed_id' missing" unless arguments[:datafeed_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _datafeed_id = arguments.delete(:datafeed_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/datafeeds/#{Utils.__listify(_datafeed_id)}/_start"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#start_trained_model_deployment(arguments = {}) ⇒ Object

Start a trained model deployment

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :model_id (String) —

    The unique identifier of the trained model.

  • :cache_size (String) —

    A byte-size value for configuring the inference cache size. For example, 20mb.

  • :deployment_id (String) —

    The Id of the new deployment. Defaults to the model_id if not set.

  • :number_of_allocations (Integer) —

    The total number of allocations this model is assigned across machine learning nodes.

  • :threads_per_allocation (Integer) —

    The number of threads used by each model allocation during inference.

  • :priority (String) —

    The deployment priority. (options: normal, low)

  • :queue_capacity (Integer) —

    Controls how many inference requests are allowed in the queue at a time.

  • :timeout (Time) —

    Controls the amount of time to wait for the model to deploy.

  • :wait_for (String) —

    Specifies the allocation status to wait for before returning. (options: started, starting, fully_allocated)

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The settings for the trained model deployment

Raises:

  • (ArgumentError)

See Also:



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/elasticsearch/api/actions/machine_learning/start_trained_model_deployment.rb', line 41

def start_trained_model_deployment(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.start_trained_model_deployment' }

  defined_params = [:model_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'model_id' missing" unless arguments[:model_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _model_id = arguments.delete(:model_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/trained_models/#{Utils.__listify(_model_id)}/deployment/_start"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#stop_data_frame_analytics(arguments = {}) ⇒ Object

Stop data frame analytics jobs

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :id (String) —

    The ID of the data frame analytics to stop

  • :allow_no_match (Boolean) —

    Whether to ignore if a wildcard expression matches no data frame analytics. (This includes ‘_all` string or when no data frame analytics have been specified)

  • :force (Boolean) —

    True if the data frame analytics should be forcefully stopped

  • :timeout (Time) —

    Controls the time to wait until the task has stopped. Defaults to 20 seconds

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The stop data frame analytics parameters

Raises:

  • (ArgumentError)

See Also:



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/stop_data_frame_analytics.rb', line 36

def stop_data_frame_analytics(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.stop_data_frame_analytics' }

  defined_params = [:id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'id' missing" unless arguments[:id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _id = arguments.delete(:id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/data_frame/analytics/#{Utils.__listify(_id)}/_stop"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#stop_datafeed(arguments = {}) ⇒ Object

Stop datafeeds

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :datafeed_id (String) —

    The ID of the datafeed to stop

  • :allow_no_match (Boolean) —

    Whether to ignore if a wildcard expression matches no datafeeds. (This includes ‘_all` string or when no datafeeds have been specified)

  • :force (Boolean) —

    True if the datafeed should be forcefully stopped.

  • :timeout (Time) —

    Controls the time to wait until a datafeed has stopped. Default to 20 seconds

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The URL params optionally sent in the body

Raises:

  • (ArgumentError)

See Also:



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/elasticsearch/api/actions/machine_learning/stop_datafeed.rb', line 36

def stop_datafeed(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.stop_datafeed' }

  defined_params = [:datafeed_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'datafeed_id' missing" unless arguments[:datafeed_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _datafeed_id = arguments.delete(:datafeed_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/datafeeds/#{Utils.__listify(_datafeed_id)}/_stop"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#stop_trained_model_deployment(arguments = {}) ⇒ Object

Stop a trained model deployment

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :model_id (String) —

    The unique identifier of the trained model.

  • :allow_no_match (Boolean) —

    Whether to ignore if a wildcard expression matches no deployments. (This includes ‘_all` string or when no deployments have been specified)

  • :force (Boolean) —

    True if the deployment should be forcefully stopped

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The stop deployment parameters

Raises:

  • (ArgumentError)

See Also:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/elasticsearch/api/actions/machine_learning/stop_trained_model_deployment.rb', line 35

def stop_trained_model_deployment(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.stop_trained_model_deployment' }

  defined_params = [:model_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'model_id' missing" unless arguments[:model_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _model_id = arguments.delete(:model_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/trained_models/#{Utils.__listify(_model_id)}/deployment/_stop"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#update_data_frame_analytics(arguments = {}) ⇒ Object

Update a data frame analytics job

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :id (String) —

    The ID of the data frame analytics to update

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The data frame analytics settings to update (Required)

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/elasticsearch/api/actions/machine_learning/update_data_frame_analytics.rb', line 33

def update_data_frame_analytics(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.update_data_frame_analytics' }

  defined_params = [:id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'id' missing" unless arguments[:id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _id = arguments.delete(:id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/data_frame/analytics/#{Utils.__listify(_id)}/_update"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#update_datafeed(arguments = {}) ⇒ Object

Update a datafeed

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :datafeed_id (String) —

    The ID of the datafeed to update

  • :ignore_unavailable (Boolean) —

    Ignore unavailable indexes (default: false)

  • :allow_no_indices (Boolean) —

    Ignore if the source indices expressions resolves to no concrete indices (default: true)

  • :ignore_throttled (Boolean) —

    Ignore indices that are marked as throttled (default: true) Deprecated

  • :expand_wildcards (List) —

    Whether source index expressions should get expanded to open or closed indices (default: open) (options: open, closed, hidden, none, all)

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The datafeed update settings (Required)

Raises:

  • (ArgumentError)

See Also:



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/elasticsearch/api/actions/machine_learning/update_datafeed.rb', line 37

def update_datafeed(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.update_datafeed' }

  defined_params = [:datafeed_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'datafeed_id' missing" unless arguments[:datafeed_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _datafeed_id = arguments.delete(:datafeed_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/datafeeds/#{Utils.__listify(_datafeed_id)}/_update"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#update_filter(arguments = {}) ⇒ Object

Update a filter

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :filter_id (String) —

    The ID of the filter to update

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The filter update (Required)

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/elasticsearch/api/actions/machine_learning/update_filter.rb', line 33

def update_filter(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.update_filter' }

  defined_params = [:filter_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'filter_id' missing" unless arguments[:filter_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _filter_id = arguments.delete(:filter_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/filters/#{Utils.__listify(_filter_id)}/_update"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#update_job(arguments = {}) ⇒ Object

Update an anomaly detection job

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job to create

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The job update settings (Required)

Raises:

  • (ArgumentError)

See Also:



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/elasticsearch/api/actions/machine_learning/update_job.rb', line 33

def update_job(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.update_job' }

  defined_params = [:job_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/_update"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#update_model_snapshot(arguments = {}) ⇒ Object

Update a snapshot

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job to fetch

  • :snapshot_id (String) —

    The ID of the snapshot to update

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The model snapshot properties to update (Required)

Raises:

  • (ArgumentError)

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/elasticsearch/api/actions/machine_learning/update_model_snapshot.rb', line 34

def update_model_snapshot(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.update_model_snapshot' }

  defined_params = %i[job_id snapshot_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]
  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]
  raise ArgumentError, "Required argument 'snapshot_id' missing" unless arguments[:snapshot_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _job_id = arguments.delete(:job_id)

  _snapshot_id = arguments.delete(:snapshot_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/model_snapshots/#{Utils.__listify(_snapshot_id)}/_update"
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#update_trained_model_deployment(arguments = {}) ⇒ Object

Update a trained model deployment

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :model_id (String) —

    The unique identifier of the trained model.

  • :number_of_allocations (Integer) —

    Update the model deployment to this number of allocations.

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The updated trained model deployment settings

Raises:

  • (ArgumentError)

See Also:



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/elasticsearch/api/actions/machine_learning/update_trained_model_deployment.rb', line 34

def update_trained_model_deployment(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.update_trained_model_deployment' }

  defined_params = [:model_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'model_id' missing" unless arguments[:model_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = arguments.delete(:body)

  _model_id = arguments.delete(:model_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/trained_models/#{Utils.__listify(_model_id)}/deployment/_update"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#upgrade_job_snapshot(arguments = {}) ⇒ Object

Upgrade a snapshot

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :job_id (String) —

    The ID of the job

  • :snapshot_id (String) —

    The ID of the snapshot

  • :timeout (Time) —

    How long should the API wait for the job to be opened and the old snapshot to be loaded.

  • :wait_for_completion (Boolean) —

    Should the request wait until the task is complete before responding to the caller. Default is false.

  • :headers (Hash) —

    Custom HTTP headers

Raises:

  • (ArgumentError)

See Also:



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/elasticsearch/api/actions/machine_learning/upgrade_job_snapshot.rb', line 35

def upgrade_job_snapshot(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.upgrade_job_snapshot' }

  defined_params = %i[job_id snapshot_id].each_with_object({}) do |variable, set_variables|
    set_variables[variable] = arguments[variable] if arguments.key?(variable)
  end
  request_opts[:defined_params] = defined_params unless defined_params.empty?

  raise ArgumentError, "Required argument 'job_id' missing" unless arguments[:job_id]
  raise ArgumentError, "Required argument 'snapshot_id' missing" unless arguments[:snapshot_id]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body = nil

  _job_id = arguments.delete(:job_id)

  _snapshot_id = arguments.delete(:snapshot_id)

  method = Elasticsearch::API::HTTP_POST
  path   = "_ml/anomaly_detectors/#{Utils.__listify(_job_id)}/model_snapshots/#{Utils.__listify(_snapshot_id)}/_upgrade"
  params = Utils.process_params(arguments)

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#validate(arguments = {}) ⇒ Object

Validate an anomaly detection job

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The job config (Required)

Raises:

  • (ArgumentError)

See Also:



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/elasticsearch/api/actions/machine_learning/validate.rb', line 32

def validate(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.validate' }

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body   = arguments.delete(:body)

  method = Elasticsearch::API::HTTP_POST
  path   = '_ml/anomaly_detectors/_validate'
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end

#validate_detector(arguments = {}) ⇒ Object

Validate an anomaly detection job

Parameters:

  • arguments (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arguments):

  • :headers (Hash) —

    Custom HTTP headers

  • :body (Hash) —

    The detector (Required)

Raises:

  • (ArgumentError)

See Also:

  • [TODO]


32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/elasticsearch/api/actions/machine_learning/validate_detector.rb', line 32

def validate_detector(arguments = {})
  request_opts = { endpoint: arguments[:endpoint] || 'ml.validate_detector' }

  raise ArgumentError, "Required argument 'body' missing" unless arguments[:body]

  arguments = arguments.clone
  headers = arguments.delete(:headers) || {}

  body   = arguments.delete(:body)

  method = Elasticsearch::API::HTTP_POST
  path   = '_ml/anomaly_detectors/_validate/detector'
  params = {}

  Elasticsearch::API::Response.new(
    perform_request(method, path, params, body, headers, request_opts)
  )
end