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:



189
190
191
192
193
194
195
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
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 189

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,
                  open_timeout: @settings.request_timeout,
                  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]]) 


171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 171

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:



142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 142

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

  Net::HTTP.start(uri.hostname, uri.port,
                  use_ssl: true,
                  open_timeout: @settings.request_timeout,
                  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.



124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 124

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:



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

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:



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

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(params) ⇒ Mindee::V2::Parsing::Search::BaseSearchResponse

Retrieves a list of resources with the given criteria.

Parameters:

Returns:



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 64

def req_get_search(params)
  @settings.check_api_key
  uri = URI("#{@settings.base_url}/v2/search/#{params.slug}")

  query_params = params.request_parameters
  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)

  response = Net::HTTP.start(uri.hostname, uri.port,
                             use_ssl: true,
                             open_timeout: @settings.request_timeout,
                             read_timeout: @settings.request_timeout) do |http|
    http.request(req)
  end
  params.response_class.new(process_response(response))
end

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

Send a file to the asynchronous processing queue for inference processing.

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_product_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:



164
165
166
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 164

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

#uri?(resource) ⇒ Boolean

Parameters:

  • resource (String) —

    Resource to check.

  • (String)

Returns:

  • (Boolean) 


90
91
92
93
94
95
96
 
# File 'lib/mindee/v2/http/mindee_api_v2.rb', line 90

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