Class: Mindee::V2::HTTP::MindeeApiV2

Inherits:
Object
  • Object
show all
Defined in:
lib/mindee/v2/http/mindee_api_v2.rb,
sig/mindee/v2/http/mindee_api_v2.rbs

Overview

API client for version 2.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(api_key: nil) ⇒ MindeeApiV2

Returns a new instance of MindeeApiV2.

Parameters:

  • api_key (String, nil) (defaults to: nil)
  • api_key: (String, nil) (defaults to: nil) 


16
17
18
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 16

def initialize(api_key: nil)
  @settings = ApiV2Settings.new(api_key: api_key)
end

Instance Attribute Details

#settings ⇒ ApiV2Settings (readonly)

Returns:



13
14
15
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 13

def settings
  @settings
end

Instance Method Details

#enqueue(input_source, params) ⇒ Net::HTTPResponse?

Parameters:

Returns:

Raises:



196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 196

def enqueue(input_source, params)
  uri = URI("#{@settings.base_url}/v2/products/#{params.slug}/enqueue")

  form_data = if input_source.is_a?(Mindee::Input::Source::URLInputSource)
                [['url', input_source.url]] # : Array[Array[untyped]]
              else
                file_data, file_metadata = input_source.read_contents(close: params.close_file)
                [['file', file_data, file_metadata]] # : Array[Array[untyped]]
              end
  form_data.push(['model_id', params.model_id])
  if params.is_a?(V2::Product::Extraction::Params::ExtractionParameters)
    form_data = enqueue_form_options(form_data, params)
  end

  form_data = params.append_form_data(form_data)

  headers = {
    'Authorization' => @settings.api_key,
    'User-Agent' => @settings.user_agent,
  }
  req = Net::HTTP::Post.new(uri, headers)

  req.set_form(form_data, 'multipart/form-data')
  req['Transfer-Encoding'] = 'chunked'

  Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @settings.request_timeout) do |http|
    return http.request(req)
  end
  raise Mindee::Error::MindeeError, 'Could not resolve server response.'
end

#enqueue_form_options(form_data, params) ⇒ Array[Array[untyped]]

Handle parameters for the enqueue form

Parameters:

Returns:

  • (Array[Array[untyped]]) 


178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 178

def enqueue_form_options(form_data, params)
  form_data.push(['rag', params.rag.to_s]) unless params.rag.nil?
  form_data.push(['raw_text', params.raw_text.to_s]) unless params.raw_text.nil?
  form_data.push(['polygon', params.polygon.to_s]) unless params.polygon.nil?
  form_data.push(['confidence', params.confidence.to_s]) unless params.confidence.nil?
  form_data.push ['text_context', params.text_context] if params.text_context
  form_data.push ['data_schema', params.data_schema.to_s] if params.data_schema
  unless params.webhook_ids.nil? || params.webhook_ids.empty?
    params.webhook_ids.each do |webhook_id|
      form_data.push ['webhook_ids[]', webhook_id]
    end
  end
  form_data
end

#poll(url) ⇒ Net::HTTPResponse

Polls a queue for either a result or a job.

Parameters:

  • url (String) —

    URL, passed as a string.

  • (String)

Returns:

Raises:



151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 151

def poll(url)
  uri = URI(url)
  headers = {
    'Authorization' => @settings.api_key,
    'User-Agent' => @settings.user_agent,
  }
  req = Net::HTTP::Get.new(uri, headers)
  req['Transfer-Encoding'] = 'chunked'

  Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @settings.request_timeout) do |http|
    return http.request(req)
  end
  raise Mindee::Error::MindeeError, 'Could not resolve server response.'
end

#process_response(response) ⇒ Hash

Converts an HTTP response to a parsed response object.

Parameters:

Returns:

  • (Hash)

Raises:

  • Throws if the server returned an error.



133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 133

def process_response(response)
  if !response.nil? && response.respond_to?(:body) &&
     Mindee::HTTP::ResponseValidation.valid_v2_response?(response)
    return JSON.parse(response.body, object_class: Hash)
  end

  response_body = if response.nil? || !response.respond_to?(:body)
                    '{ "status": -1,
                    "detail": "Empty server response." }'
                  else
                    response.body
                  end
  raise Mindee::HTTP::ErrorHandler.generate_v2_error(JSON.parse(response_body).transform_keys(&:to_sym))
end

#req_get_job(job_id) ⇒ Mindee::V2::Parsing::JobResponse

Retrieves a queued job.

Parameters:

  • job_id (String) —

    ID of the job or URL to the job.

  • (String)

Returns:



54
55
56
57
58
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 54

def req_get_job(job_id)
  @settings.check_api_key
  response = poll("#{@settings.base_url}/v2/jobs/#{job_id}")
  Mindee::V2::Parsing::JobResponse.new(process_response(response))
end

#req_get_job_url(url) ⇒ Mindee::V2::Parsing::JobResponse

Retrieves a queued job.

Parameters:

  • url (String)
  • (String)

Returns:



111
112
113
114
115
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 111

def req_get_job_url(url)
  @settings.check_api_key
  response = poll(url)
  Mindee::V2::Parsing::JobResponse.new(process_response(response))
end

#req_get_result(product, resource) ⇒ Mindee::V2::Parsing::BaseResponse

Retrieves a result from a given queue.

Parameters:

Returns:



39
40
41
42
43
44
45
46
47
48
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 39

def req_get_result(product, resource)
  return req_get_result_url(product.response_type, resource) if uri?(resource)

  @settings.check_api_key
  response = result_req_get(
    resource,
    product
  )
  product.response_type.new(process_response(response))
end

#req_get_result_url(result_class, url) ⇒ Mindee::V2::Parsing::BaseResponse

Retrieves a queued job.

Parameters:

Returns:



122
123
124
125
126
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 122

def req_get_result_url(result_class, url)
  @settings.check_api_key
  response = poll(url)
  result_class.new(process_response(response))
end

#req_get_search_models(model_name, model_type) ⇒ Net::HTTPResponse

Retrieves a list of models.

Parameters:

  • model_name (String, nil)
  • model_type (String, nil)
  • (String, nil)
  • (String, nil)

Returns:

Raises:



75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 75

def req_get_search_models(model_name, model_type)
  url = "#{@settings.base_url}/v2/search/models"
  uri = URI(url)

  query_params = {} # @type var query_params: Hash[Symbol, String | nil]
  query_params[:name] = model_name if model_name
  query_params[:model_type] = model_type if model_type
  uri.query = URI.encode_www_form(query_params) unless query_params.empty?

  headers = {
    'Authorization' => @settings.api_key,
    'User-Agent' => @settings.user_agent,
  }
  req = Net::HTTP::Get.new(uri, headers)
  req['Transfer-Encoding'] = 'chunked'

  Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @settings.request_timeout) do |http|
    return http.request(req)
  end
  raise Mindee::Error::MindeeError, 'Could not resolve server response.'
end

#req_post_enqueue(input_source, params) ⇒ Mindee::V2::Parsing::JobResponse

Sends a file to the queue.

Parameters:

Returns:

Raises:

  • (Mindee::Error::MindeeHttpErrorV2) 


26
27
28
29
30
31
32
33
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 26

def req_post_enqueue(input_source, params)
  @settings.check_api_key
  response = enqueue(
    input_source,
    params
  )
  Mindee::V2::Parsing::JobResponse.new(process_response(response))
end

#result_req_get(queue_id, product) ⇒ Net::HTTPResponse

Polls the API for the result of an inference.

Parameters:

Returns:



171
172
173
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 171

def result_req_get(queue_id, product)
  poll("#{@settings.base_url}/v2/products/#{product.slug}/results/#{queue_id}")
end

#search_models(model_name, model_type) ⇒ Mindee::V2::Parsing::Search::SearchResponse

Retrieves a list of models.

Parameters:

  • model_name (String, nil)
  • model_type (String, nil)
  • (String, nil)
  • (String, nil)

Returns:



64
65
66
67
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 64

def search_models(model_name, model_type)
  Mindee::V2::Parsing::Search::SearchResponse.new(process_response(req_get_search_models(model_name,
                                                                                         model_type)))
end

#uri?(resource) ⇒ Boolean

Parameters:

  • resource (String) —

    Resource to check.

  • (String)

Returns:

  • (Boolean) 


99
100
101
102
103
104
105
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 99

def uri?(resource)
  uri = URI.parse(resource)
  throw Mindee::Error::MindeeError, 'HTTP is not supported.' if uri.scheme == 'http'
  uri.scheme == 'https'
rescue URI::BadURIError, URI::InvalidURIError
  false
end