mindee 1.2.0 → 2.0.0

data/docs/ruby-receipt-ocr.md

@@ -0,0 +1,170 @@
+The Ruby  OCR SDK supports the [receipt API](https://developers.mindee.com/docs/receipt-ocr) for extracting data from receipts.
+
+Using this sample below, we are going to illustrate how to extract the data that we want using the OCR SDK.
+
+![sample receipt](https://raw.githubusercontent.com/mindee/client-lib-test-data/main/receipt/receipt-with-tip.jpg)
+
+## Quick Start
+```ruby
+require 'mindee'
+
+# Init a new client, specifying an API key
+mindee_client = Mindee::Client.new(api_key: 'my-api-key')
+
+# Send the file
+result = mindee_client.doc_from_path('/path/to/the/file.ext').parse(Mindee::Prediction::ReceiptV4)
+
+# Print a summary of the document prediction in RST format
+puts result.inference.prediction
+```
+
+Output:
+```shell
+:Locale: en-US; en; US; USD;
+:Date: 2014-07-07
+:Category: food
+:Subcategory: restaurant
+:Document type: EXPENSE RECEIPT
+:Time: 20:20
+:Supplier name: LOGANS
+:Taxes: 3.34 TAX
+:Total net: 40.48
+:Total taxes: 3.34
+:Tip: 10.00
+:Total amount: 53.8
+```
+
+## Fields
+Each prediction object contains a set of different fields.
+Each `Field` object contains at a minimum the following attributes:
+
+* `value` (String or Float depending on the field type): corresponds to the field value. Can be `nil` if no value was extracted.
+* `confidence` (Float): the confidence score of the field prediction.
+* `bounding_box` (Array< Array< Float > >): contains exactly 4 relative vertices coordinates (points) of a right rectangle containing the field in the document.
+* `polygon` (Array< Array< Float > >): contains the relative vertices coordinates (points) of a polygon containing the field in the image.
+* `reconstructed` (Boolean): True if the field was reconstructed or computed using other fields.
+
+
+## Attributes
+Depending on the field type specified, additional attributes can be extracted in the `Receipt` object.
+
+Using the above sample, the following are the basic fields that can be extracted:
+
+- [Orientation](#orientation)
+- [Category](#category)
+- [Date](#date)
+- [Locale](#locale)
+- [Supplier Information](#supplier-information)
+- [Taxes](#taxes)
+- [Time](#time)
+- [Totals](#totals)
+
+
+### Category
+* **`category`** (Field): Receipt category as seen on the receipt.
+  The following categories are supported: toll, food, parking, transport, accommodation, gasoline, miscellaneous.
+
+```ruby
+puts result.inference.prediction.category.value
+```
+
+
+### Date
+Date fields:
+
+* contain the `date_object` attribute, which is a standard Ruby [date object](https://ruby-doc.org/stdlib-2.7.1/libdoc/date/rdoc/Date.html)
+* have a `value` attribute which is the [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) representation of the date.
+
+The following date fields are available:
+
+* **`date`**: Date the receipt was issued
+
+```ruby
+puts result.inference.prediction.date.value
+```
+
+
+### Locale
+**`locale`** (Locale): Locale information.
+
+* `locale.value` (String): Locale with country and language codes.
+```ruby
+puts result.inference.prediction.locale
+```
+
+* `locale.language` (String): Language code in [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) format as seen on the document.
+* 
+```ruby
+puts result.inference.prediction.locale.language
+```
+
+* `locale.currency` (String): Currency code in [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) format as seen on the document.
+
+```ruby
+puts result.inference.prediction.locale.currency
+```
+
+* `locale.country` (String): Country code in [ISO 3166-1](https://en.wikipedia.org/wiki/ISO_3166-1) alpha-2 format as seen on the document.
+
+```ruby
+puts result.inference.prediction.locale.country
+```
+
+### Supplier Information
+* **`supplier_name`** (Field): Supplier name as written in the receipt.
+
+```ruby
+puts result.inference.prediction.supplier_name.value
+```
+
+
+### Taxes
+**`taxes`** (Array< TaxField >): Contains tax fields as seen on the receipt.
+
+* `value` (Float): The tax amount.
+```ruby
+# Show the amount of the first tax
+puts result.inference.prediction.taxes[0].value
+```
+
+* `code` (String): The tax code (HST, GST... for Canadian; City Tax, State tax for US, etc..).
+```ruby
+# Show the code of the first tax
+puts result.inference.prediction.taxes[0].code
+```
+
+* `rate` (Float): The tax rate.
+```ruby
+# Show the rate of the first tax
+puts result.inference.prediction.taxes[0].rate
+```
+
+### Time
+* **`time`**: Time of purchase as seen on the receipt
+    * `value` (string): Time of purchase with 24 hours formatting (hh:mm).
+
+```ruby
+puts result.inference.prediction.time.value
+```
+
+### Totals
+* **`total_amount`** (Field): Total amount including taxes
+
+```ruby
+puts result.inference.prediction.total_amount.value
+```
+
+* **`total_net`** (Field): Total amount paid excluding taxes
+
+```ruby
+puts result.inference.prediction.total_net.value
+```
+
+* **`total_tax`** (Field): Total tax value from tax lines
+
+```ruby
+puts result.inference.prediction.total_tax.value
+```
+
+## Questions?
+[Join our Slack](https://join.slack.com/t/mindee-community/shared_invite/zt-1jv6nawjq-FDgFcF2T5CmMmRpl9LLptw)

data/lib/mindee/client.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'inputs'
+require_relative 'input'
 require_relative 'document_config'
-require_relative 'endpoint'
+require_relative 'http/endpoint'
+require_relative 'parsing/prediction'
 
 module Mindee
   # General client for sending a document to the API.
@@ -15,157 +16,191 @@ module Mindee
     end
 
     # Call prediction API on the document and parse the results.
-    # @param document_name [String] Document name (type) to parse
-    # @param username [String] API username, the endpoint owner
-    # @param include_words [Boolean] Include all the words of the document in the response
-    # @param close_file [Boolean] Whether to close the file after parsing it.
+    #
+    # @param prediction_class [Mindee::Prediction::Prediction]
+    #
+    # @param endpoint_name [String] For custom endpoints, the "API name" field in the "Settings" page of the
+    #  API Builder. Do not set for standard (off the shelf) endpoints.
+    #
+    # @param account_name [String] For custom endpoints, your account or organization username on the API Builder.
+    #  This is normally not required unless you have a custom endpoint which has the
+    #  same name as standard (off the shelf) endpoint.
+    #  Do not set for standard (off the shelf) endpoints.
+    #
+    # @param include_words [Boolean] Whether to include the full text for each page.
+    #  This performs a full OCR operation on the server and will increase response time.
+    #
+    # @param close_file [Boolean] Whether to `close()` the file after parsing it.
+    #  Set to false if you need to access the file after this operation.
+    #
+    # @param page_options [Hash, nil] Page cutting/merge options:
+    #
+    #  * `:page_indexes` Zero-based list of page indexes.
+    #  * `:operation` Operation to apply on the document, given the `page_indexes specified:
+    #      * `:KEEP_ONLY` - keep only the specified pages, and remove all others.
+    #      * `:REMOVE` - remove the specified pages, and keep all others.
+    #  * `:on_min_pages` Apply the operation only if document has at least this many pages.
+    #
+    # @param cropper [Boolean] Whether to include cropper results for each page.
+    #  This performs a cropping operation on the server and will increase response time.
+    #
     # @return [Mindee::DocumentResponse]
-    def parse(document_name, username: '', include_words: false, close_file: true)
+    def parse(
+      prediction_class,
+      endpoint_name: '',
+      account_name: '',
+      include_words: false,
+      close_file: true,
+      page_options: nil,
+      cropper: false
+    )
+      doc_config = find_doc_config(prediction_class, endpoint_name, account_name)
+      @input_doc.process_pdf(page_options) if !page_options.nil? && @input_doc.pdf?
+      doc_config.predict(@input_doc, include_words, close_file, cropper)
+    end
+
+    private
+
+    # @param document_class [Mindee::Prediction::Prediction]
+    # @param endpoint_name [String]
+    def determine_endpoint_name(document_class, endpoint_name)
+      return document_class.name if document_class.name != Prediction::CustomV1.name
+
+      raise "endpoint_name is required when using #{document_class.name} class" if endpoint_name.empty?
+
+      endpoint_name
+    end
+
+    # @param document_class [Mindee::Prediction::Prediction]
+    # @param endpoint_name [String]
+    # @param account_name [String]
+    def find_doc_config(document_class, endpoint_name, account_name)
+      endpoint_name = determine_endpoint_name(document_class, endpoint_name)
+
       found = []
       @doc_configs.each_key do |conf|
-        found.push(conf) if conf[1] == document_name
+        found.push(conf) if conf[1] == endpoint_name
       end
-      raise "Document type not configured: #{document_name}" if found.empty?
+      raise "Endpoint not configured: #{endpoint_name}" if found.empty?
 
-      if !username.empty?
-        config_key = [username, document_name]
+      if !account_name.empty?
+        config_key = [account_name, endpoint_name]
       elsif found.length == 1
         config_key = found[0]
       else
         usernames = found.map { |conf| conf[0] }
         raise "Duplicate configuration detected.\n" \
-              "You specified the document '#{document_name}' in your custom config.\n" \
+              "You specified the document '#{endpoint_name}' in your custom config.\n" \
               "To avoid confusion, please add the 'account_name' attribute to " \
               "the parse method, one of #{usernames}."
       end
 
-      doc_config = @doc_configs[config_key]
-      doc_config.predict(@input_doc, include_words, close_file)
+      @doc_configs[config_key]
     end
   end
 
   # Mindee API Client.
   # See: https://developers.mindee.com/docs/
   class Client
-    DOC_TYPE_INVOICE = 'invoice'
-    DOC_TYPE_RECEIPT = 'receipt'
-    DOC_TYPE_PASSPORT = 'passport'
-    DOC_TYPE_FINANCIAL = 'financial_doc'
-
-    # @param raise_on_error [Boolean]
-    def initialize(api_key: nil, raise_on_error: true)
-      @raise_on_error = raise_on_error
+    # @param api_key [String]
+    def initialize(api_key: '')
       @doc_configs = {}
       @api_key = api_key
-    end
-
-    # Configure a 'Mindee Invoice' document.
-    # @param api_key [String] Override the client API key for this endpoint
-    # @return [Mindee::Client]
-    def config_invoice(api_key: nil)
-      @doc_configs[['mindee', DOC_TYPE_INVOICE]] = InvoiceConfig.new(
-        api_key || @api_key,
-        @raise_on_error
-      )
-      self
-    end
-
-    # Configure a 'Mindee Expense Receipts' document.
-    # @param api_key [String] Override the client API key for this endpoint
-    # @return [Mindee::Client]
-    def config_receipt(api_key: nil)
-      @doc_configs[['mindee', DOC_TYPE_RECEIPT]] = ReceiptConfig.new(
-        api_key || @api_key,
-        @raise_on_error
-      )
-      self
-    end
-
-    # Configure a 'Mindee Passport' document.
-    # @param api_key [String] Override the client API key for this endpoint
-    # @return [Mindee::Client]
-    def config_passport(api_key: nil)
-      @doc_configs[['mindee', DOC_TYPE_PASSPORT]] = PassportConfig.new(
-        api_key || @api_key,
-        @raise_on_error
-      )
-      self
-    end
-
-    # Configure a 'Mindee Financial document'. Uses 'Invoice' and 'Expense Receipt' internally.
-    # @param api_key [String] Override the client API key for this endpoint
-    # @return [Mindee::Client]
-    def config_financial_doc(api_key: nil)
-      @doc_configs[['mindee', DOC_TYPE_FINANCIAL]] = FinancialDocConfig.new(
-        api_key || @api_key,
-        @raise_on_error
-      )
-      self
+      init_default_endpoints
     end
 
     # Configure a custom document using the 'Mindee API Builder'.
     # @param account_name [String] Your organization's username on the API Builder
-    # @param document_name [String] The "API name" field in the "Settings" page of the API Builder
-    # @param api_key [String]  Override the client API key for this endpoint
+    # @param endpoint_name [String] The "API name" field in the "Settings" page of the API Builder
     # @param version [String] Specify the version of the model to use. If not set, use the latest version of the model.
     # @return [Mindee::Client]
-    def config_custom_doc(
-      document_name,
+    def add_endpoint(
       account_name,
-      api_key: nil,
+      endpoint_name,
       version: '1'
     )
-      @doc_configs[[account_name, document_name]] = CustomDocConfig.new(
-        document_name,
-        account_name,
-        version,
-        api_key || @api_key,
-        @raise_on_error
+      @doc_configs[[account_name, endpoint_name]] = DocumentConfig.new(
+        Prediction::CustomV1,
+        [HTTP::CustomEndpoint.new(account_name, endpoint_name, version, @api_key)]
       )
       self
     end
 
     # Load a document from an absolute path, as a string.
     # @param input_path [String] Path of file to open
-    # @param cut_pages [Boolean] Automatically reconstruct a multi-page document.
-    # @param max_pages [Integer] Number (between 1 and 3 incl.) of pages to reconstruct a document.
     # @return [Mindee::DocumentClient]
-    def doc_from_path(input_path, cut_pages: true, max_pages: MAX_DOC_PAGES)
-      doc = PathDocument.new(input_path, cut_pages, max_pages: max_pages)
+    def doc_from_path(input_path)
+      doc = Input::PathDocument.new(input_path)
       DocumentClient.new(doc, @doc_configs)
     end
 
     # Load a document from raw bytes.
     # @param input_bytes [String] Encoding::BINARY byte input
     # @param filename [String] The name of the file (without the path)
-    # @param cut_pages [Boolean] Automatically reconstruct a multi-page document.
-    # @param max_pages [Integer] Number (between 1 and 3 incl.) of pages to reconstruct a document.
     # @return [Mindee::DocumentClient]
-    def doc_from_bytes(input_bytes, filename, cut_pages: true, max_pages: MAX_DOC_PAGES)
-      doc = BytesDocument.new(input_bytes, filename, cut_pages, max_pages: max_pages)
+    def doc_from_bytes(input_bytes, filename)
+      doc = Input::BytesDocument.new(input_bytes, filename)
       DocumentClient.new(doc, @doc_configs)
     end
 
     # Load a document from a base64 encoded string.
     # @param base64_string [String] Input to parse as base64 string
     # @param filename [String] The name of the file (without the path)
-    # @param cut_pages [Boolean] Automatically reconstruct a multi-page document.
-    # @param max_pages [Integer] Number (between 1 and 3 incl.) of pages to reconstruct a document.
     # @return [Mindee::DocumentClient]
-    def doc_from_b64string(base64_string, filename, cut_pages: true, max_pages: MAX_DOC_PAGES)
-      doc = Base64Document.new(base64_string, filename, cut_pages, max_pages: max_pages)
+    def doc_from_b64string(base64_string, filename)
+      doc = Input::Base64Document.new(base64_string, filename)
       DocumentClient.new(doc, @doc_configs)
     end
 
     # Load a document from a normal Ruby `File`.
     # @param input_file [File] Input file handle
     # @param filename [String] The name of the file (without the path)
-    # @param cut_pages [Boolean] Automatically reconstruct a multi-page document.
-    # @param max_pages [Integer] Number (between 1 and 3 incl.) of pages to reconstruct a document.
     # @return [Mindee::DocumentClient]
-    def doc_from_file(input_file, filename, cut_pages: true, max_pages: MAX_DOC_PAGES)
-      doc = FileDocument.new(input_file, filename, cut_pages, max_pages: max_pages)
+    def doc_from_file(input_file, filename)
+      doc = Input::FileDocument.new(input_file, filename)
       DocumentClient.new(doc, @doc_configs)
     end
+
+    private
+
+    def init_default_endpoints
+      @doc_configs[['mindee', Prediction::InvoiceV4.name]] = DocumentConfig.new(
+        Prediction::InvoiceV4,
+        [HTTP::StandardEndpoint.new('invoices', '4', @api_key)]
+      )
+      @doc_configs[['mindee', Prediction::ReceiptV4.name]] = DocumentConfig.new(
+        Prediction::ReceiptV4,
+        [HTTP::StandardEndpoint.new('expense_receipts', '4', @api_key)]
+      )
+      @doc_configs[['mindee', Prediction::PassportV1.name]] = DocumentConfig.new(
+        Prediction::PassportV1,
+        [HTTP::StandardEndpoint.new('passport', '1', @api_key)]
+      )
+      @doc_configs[['mindee', Prediction::EU::LicensePlateV1.name]] = DocumentConfig.new(
+        Prediction::EU::LicensePlateV1,
+        [HTTP::StandardEndpoint.new('license_plates', '1', @api_key)]
+      )
+      @doc_configs[['mindee', Prediction::ShippingContainerV1.name]] = DocumentConfig.new(
+        Prediction::ShippingContainerV1,
+        [HTTP::StandardEndpoint.new('shipping_containers', '1', @api_key)]
+      )
+      @doc_configs[['mindee', Prediction::US::BankCheckV1.name]] = DocumentConfig.new(
+        Prediction::US::BankCheckV1,
+        [HTTP::StandardEndpoint.new('bank_check', '1', @api_key)]
+      )
+      @doc_configs[['mindee', Prediction::FR::BankAccountDetailsV1.name]] = DocumentConfig.new(
+        Prediction::FR::BankAccountDetailsV1,
+        [HTTP::StandardEndpoint.new('bank_account_details', '1', @api_key)]
+      )
+      @doc_configs[['mindee', Prediction::FR::CarteVitaleV1.name]] = DocumentConfig.new(
+        Prediction::FR::CarteVitaleV1,
+        [HTTP::StandardEndpoint.new('carte_vitale', '1', @api_key)]
+      )
+      @doc_configs[['mindee', Prediction::FR::IdCardV1.name]] = DocumentConfig.new(
+        Prediction::FR::IdCardV1,
+        [HTTP::StandardEndpoint.new('idcard_fr', '1', @api_key)]
+      )
+      self
+    end
   end
 end

data/lib/mindee/document_config.rb

@@ -2,88 +2,56 @@
 
 require 'json'
 
-require_relative 'endpoint'
-require_relative 'documents'
-require_relative 'response'
+require_relative 'http/endpoint'
+require_relative 'parsing/document'
+require_relative 'parsing/error'
+require_relative 'parsing/prediction'
 
 module Mindee
   # Specific client for sending a document to the API.
   class DocumentConfig
     # Array of possible Mindee::Endpoint to be used.
-    # @return [Array<Mindee::Endpoint>]
+    # @return [Array<Mindee::HTTP::Endpoint>]
     attr_reader :endpoints
 
-    # @param doc_class [Class<Mindee::Document>]
-    # @param document_type [String]
-    # @param endpoints [Array<Mindee::Endpoint>]
-    # @param raise_on_error [Boolean]
-    def initialize(doc_class, document_type, endpoints, raise_on_error)
-      @doc_class = doc_class
-      @document_type = document_type
+    # @param prediction_class [Class<Mindee::Prediction::Prediction>]
+    # @param endpoints [Array<Mindee::HTTP::Endpoint>]
+    def initialize(prediction_class, endpoints)
+      @prediction_class = prediction_class
       @endpoints = endpoints
-      @raise_on_error = raise_on_error
-    end
-
-    # Parse a prediction API result.
-    # @param input_doc [Mindee::InputDocument]
-    # @param response [Hash]
-    # @return [Mindee::DocumentResponse]
-    def build_predict_result(input_doc, response)
-      document = @doc_class.new(
-        response['document']['inference']['prediction'],
-        input_file: input_doc,
-        page_id: nil
-      )
-      pages = []
-      response['document']['inference']['pages'].each do |page|
-        pages.push(
-          @doc_class.new(
-            page['prediction'],
-            input_file: input_doc,
-            page_id: page['id']
-          )
-        )
-      end
-      DocumentResponse.new(response, @document_type, document, pages)
     end
 
     # Call the prediction API.
     # @param input_doc [Mindee::InputDocument]
     # @param include_words [Boolean]
     # @param close_file [Boolean]
+    # @param cropper [Boolean]
     # @return [Mindee::DocumentResponse]
-    def predict(input_doc, include_words, close_file)
+    def predict(input_doc, include_words, close_file, cropper)
       check_api_keys
-      response = predict_request(input_doc, include_words, close_file)
-      parse_response(input_doc, response)
+      response = predict_request(input_doc, include_words, close_file, cropper)
+      parse_response(response)
     end
 
     private
 
-    # @param input_doc [Mindee::InputDocument]
     # @param response [Net::HTTPResponse]
     # @return [Mindee::DocumentResponse]
-    def parse_response(input_doc, response)
+    def parse_response(response)
       hashed_response = JSON.parse(response.body, object_class: Hash)
-      unless (200..299).include?(response.code.to_i)
-        if @raise_on_error
-          raise Net::HTTPError.new(
-            "API #{response.code} HTTP error: #{hashed_response}", response
-          )
-        end
-        return DocumentResponse.new(
-          hashed_response, @document_type, {}, []
-        )
-      end
-      build_predict_result(input_doc, hashed_response)
+      return Document.new(@prediction_class, hashed_response['document']) if (200..299).include?(response.code.to_i)
+
+      error = Parsing::Error.new(hashed_response['api_request']['error'])
+      raise error
     end
 
     # @param input_doc [Mindee::InputDocument]
     # @param include_words [Boolean]
     # @param close_file [Boolean]
+    # # @param cropper [Boolean]
     # @return [Net::HTTPResponse]
-    def predict_request(input_doc, include_words, close_file)
-      @endpoints[0].predict_request(input_doc, include_words: include_words, close_file: close_file)
+    def predict_request(input_doc, include_words, close_file, cropper)
+      @endpoints[0].predict_req_post(input_doc, include_words: include_words, close_file: close_file, cropper: cropper)
     end
 
     def check_api_keys
@@ -93,108 +61,8 @@ module Mindee
         raise "Missing API key for '#{@document_type}', " \
               "check your Client Configuration.\n" \
               'You can set this using the ' \
-              "'#{endpoint.envvar_key_name}' environment variable."
-      end
-    end
-  end
-
-  # Client for Invoice documents
-  class InvoiceConfig < DocumentConfig
-    def initialize(api_key, raise_on_error)
-      endpoints = [InvoiceEndpoint.new(api_key)]
-      super(
-        Invoice,
-        'invoice',
-        endpoints,
-        raise_on_error
-      )
-    end
-  end
-
-  # Client for Receipt documents
-  class ReceiptConfig < DocumentConfig
-    def initialize(api_key, raise_on_error)
-      endpoints = [ReceiptEndpoint.new(api_key)]
-      super(
-        Receipt,
-        'receipt',
-        endpoints,
-        raise_on_error
-      )
-    end
-  end
-
-  # Client for Passport documents
-  class PassportConfig < DocumentConfig
-    def initialize(api_key, raise_on_error)
-      endpoints = [PassportEndpoint.new(api_key)]
-      super(
-        Passport,
-        'passport',
-        endpoints,
-        raise_on_error
-      )
-    end
-  end
-
-  # Client for Financial documents
-  class FinancialDocConfig < DocumentConfig
-    def initialize(api_key, raise_on_error)
-      endpoints = [
-        InvoiceEndpoint.new(api_key),
-        ReceiptEndpoint.new(api_key),
-      ]
-      super(
-        FinancialDocument,
-        'financial_doc',
-        endpoints,
-        raise_on_error
-      )
-    end
-
-    private
-
-    def predict_request(input_doc, include_words, close_file)
-      endpoint = input_doc.pdf? ? @endpoints[0] : @endpoints[1]
-      endpoint.predict_request(input_doc, include_words: include_words, close_file: close_file)
-    end
-  end
-
-  # Client for Custom (constructed) documents
-  class CustomDocConfig < DocumentConfig
-    def initialize(document_type, account_name, version, api_key, raise_on_error)
-      endpoints = [CustomEndpoint.new(document_type, account_name, version, api_key)]
-      super(
-        CustomDocument,
-        document_type,
-        endpoints,
-        raise_on_error
-      )
-    end
-
-    # Parse a prediction API result.
-    # @param input_doc [Mindee::InputDocument]
-    # @param response [Hash]
-    # @return [Mindee::DocumentResponse]
-    def build_predict_result(input_doc, response)
-      document = CustomDocument.new(
-        @document_type,
-        response['document']['inference']['prediction'],
-        input_file: input_doc,
-        page_id: nil
-      )
-      pages = []
-      response['document']['inference']['pages'].each do |page|
-        pages.push(
-          CustomDocument.new(
-            @document_type,
-            page['prediction'],
-            input_file: input_doc,
-            page_id: page['id']
-          )
-        )
+              "'#{HTTP::API_KEY_ENV_NAME}' environment variable."
       end
-      DocumentResponse.new(response, @document_type, document, pages)
     end
   end
 end