mindee 4.6.0 → 4.7.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c37efc128220eca42a9c5af127911697d47bd4179166d9faec47f04988221d4d
-  data.tar.gz: da2158c80baa262b083baf4696a5d5f2d6b4226999713262419a4c98165cbd80
+  metadata.gz: c88f4c2b47bf3a97cd519d1c658f12a874ed930c8e86d5ff208c0c44d4174cca
+  data.tar.gz: 191850ef611da7ca60fac4827f6c530348adf2d07d4a7790dd46a6abb335e906
 SHA512:
-  metadata.gz: d5c02591130934ad5dcd7e6a87a22e753f4a3cf7bed31a0913c9f4296cc5ed4f741d085267a59d171d6e7146b34542878ae03ca920060ec9ef2e113c9bbd6f74
-  data.tar.gz: 6ba9a4dee2c426885452d19805bfd1582ecf76f0902c420d32cc6c7521085e50a2eb5c8ec7368a820612ae425ae37bdf53487df486d29275a534c87cfbc93f3f
+  metadata.gz: cbf412b01eb4c6a324f6548232ce24e7ed0bd6f20b12d3803a47218e971805b77c32989e644077809aaf3ec404946461deaf4e440385812228ece7d8d839d6b6
+  data.tar.gz: 381aebed32ebee1cbd763f361c46bf76eff8fd6592f1d9652ccb79ca5515a804e20c8a36459c56af189e5af883ec9b02c2f69a921dde46d15ad6bb1b7224267d

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Mindee Ruby API Library Changelog
 
+## v4.7.0-rc1 - 2025-08-13
+### Changes
+* :sparkles: add support for client V2 & associated features
+
+### Fixes
+* :recycle: add many missing internal types
+* :bug: fix invalid types for many V1 features
+* :bug: fix V1 errors sometimes having the wrong code
+* :bug: fix many presumably immutable fields having non-readonly parameters
+* :bug: fix broken `resources` accessor in `ApiRequest` object
+
+
 ## v4.6.0 - 2025-06-03
 ### Changes
 * :sparkles: add support for address fields

data/README.md

@@ -4,240 +4,39 @@
 
 Quickly and easily connect to Mindee's API services using Ruby.
 
-## Requirements
+## Mindee API Versions
+This client library has support for both Mindee platform versions.
 
-The following Ruby versions are tested and supported: 3.0, 3.1, 3.2, 3.3, 3.4
+### Latest - V2
+This is the new platform located here:
 
-## Quick Start
+https://app.mindee.com
 
-Here's the TL;DR of getting started.
+It uses **API version 2**.
 
-First, get an [API Key](https://developers.mindee.com/docs/create-api-key)
+Consult the
+**[Latest Documentation](https://docs.mindee.com/integrations/client-libraries-sdk)**
 
-Install by adding this line to your application's Gemfile:
 
-```ruby
-gem 'mindee'
-```
+### Legacy - V1
+This is the legacy platform located here:
 
-And then execute:
+https://platform.mindee.com/
 
-```sh
-bundle install
-```
+It uses **API version 1**.
 
-Finally, Ruby away!
+Consult the
+**[Legacy Documentation](https://developers.mindee.com/docs/ruby-getting-started)**
 
-### Environment Variables
+## Additional Information
 
-This library offers customizable features through environment variables. While there may be instances where you need to
-rely on them, it's crucial to exercise caution when modifying them to avoid unintended consequences.
+**[Source Code](https://github.com/mindee/mindee-api-ruby)**
 
-If you're unsure whether you need to adjust these variables, it's advisable to refrain from doing so unless you have a
-specific reason. Accidentally overwriting them can lead to unexpected behavior.
+**[Reference Documentation](https://mindee.github.io/mindee-api-ruby/)**
 
-Before making any changes, we recommend reviewing the following information to understand the purpose and potential
-impact of each environment variable:
+**[Feedback](https://feedback.mindee.com/)**
 
-* `MINDEE_API_KEY`:
-    * **Description**: Your personal Mindee API Key as shown on the platform. Be careful not to show this publicly!
-    * **Default Value**: `nil`
-* `MINDEE_BASE_URL`:
-    * **Description**: The default base URL of the API endpoint. Use this variable to specify the root URL for API requests. Modify as needed for proxy configurations or changes in API endpoint location.
-    * **Default Value**: `https://api.mindee.net/v1`
-* `MINDEE_REQUEST_TIMEOUT`:
-    * **Description**: The default timeout for HTTP requests (in seconds).
-    * **Default Value**: `120`
-* `MINDEE_LOG_LEVEL`:
-    * **Description**: The default logging level for the mindee logger.
-    * **Default Value**: `WARN`
+### License
+Copyright © Mindee
 
-### Loading a File and Parsing It
-
-#### Global Documents
-
-```ruby
-require 'mindee'
-
-# Init a new client
-mindee_client = Mindee::Client.new(api_key: 'my-api-key')
-
-# Load a file from disk
-input_source = mindee_client.source_from_path('/path/to/the/file.ext')
-result = mindee_client.parse(
-        input_source,
-        Mindee::Product::Invoice::InvoiceV4
-)
-
-# Print a full summary of the parsed data in RST format
-puts result.document
-```
-
-**Note:** Files can also be loaded from:
-
-A URL (`https`):
-
-```rb
-input_source = mindee_client.source_from_url("https://my-url")
-```
-
-A bytes input stream:
-
-```rb
-input_source = mindee_client.source_from_bytes('/path/to/the/file.ext', "name-of-my-file.ext")
-```
-
-A base64 encoded string:
-
-```rb
-input_source = mindee_client.source_from_b64string('/path/to/the/file.ext', "name-of-my-file.ext")
-```
-
-A ruby `file` object:
-
-```rb
-input_source = mindee_client.source_from_file(input_file, "name-of-my-file.ext")
-```
-
-#### Region-Specific Documents
-
-```ruby
-require 'mindee'
-
-# Init a new client
-mindee_client = Mindee::Client.new(api_key: 'my-api-key')
-
-# Load a file from disk
-input_source = mindee_client.source_from_path('/path/to/the/file.ext')
-
-result = mindee_client.parse(
-        input_source,
-        Mindee::Product::EU::LicensePlate::LicensePlateV1
-)
-
-# Print a full summary of the parsed data in RST format
-puts result.document
-```
-
-### Universal - All Other Documents
-
-The Universal product acts as a catch-all for every and any API if it doesn't have an assigned product name.
-
-```ruby
-require 'mindee'
-
-# Init a new client and configure your custom document
-mindee_client = Mindee::Client.new(api_key: 'my-api-key')
-endpoint = mindee_client.create_endpoint(
-  endpoint_name: 'my-endpoint',
-  account_name: 'my-account'
-)
-
-# Load a file from disk
-input_source = mindee_client.source_from_path('/path/to/the/file.ext')
-
-result = mindee_client.parse(
-  input_source,
-  Mindee::Product::Universal::Universal,
-  endpoint: endpoint
-)
-
-# Print a full summary of the parsed data in RST format
-puts result.document
-
-# Looping over all prediction values
-result.document.inference.prediction.fields.each do |field_name, field_data|
-  puts field_name
-  puts field_data.values
-  puts field_data.to_s
-end
-```
-
-
-## Enqueueing and Parse a Webhook Response
-
-This is an optional way of handling asynchronous APIs.
-
-```rb
-require 'mindee'
-
-# Init a new client
-mindee_client = Mindee::Client.new(api_key: 'my-api-key')
-
-# Load a file from disk
-input_source = mindee_client.source_from_path('/path/to/the/file.ext')
-
-
-# Send the file to the server
-enqueue_response = mindee_client.enqueue(
-  input_source,
-  Mindee::Product::InternationalId::InternationalIdV2
-)
-
-job_id = enqueue_response.job.id
-
-# Load the JSON string sent by the Mindee webhook POST callback.
-# Reading the callback data will vary greatly depending on your HTTP server.
-# This is therefore beyond the scope of this example.
-
-local_response = Mindee::Input::LocalResponse.new(request.body.string)
-
-# You can also use a File object as the input.
-# FILE_PATH = File.join('path', 'to', 'file.json').freeze
-# local_response = Mindee::Input::LocalResponse.new(FILE_PATH);
-
-# Optional: verify the HMAC signature.
-unless local_response.valid_hmac_signature?(my_secret_key, 'invalid signature')
-  raise "Invalid HMAC signature!"
-end
-
-
-# Deserialize the response:
-result = mindee_client.load_prediction(
-        Mindee::Product::InternationalId::InternationalIdV2,
-        local_response
-)
-
-# Print a full summary of the parsed data in RST format
-puts result.document
-```
-
-
-## CLI Tool
-
-A command-line interface tool is available to quickly test documents:
-
-```sh
-ruby ./bin/mindee.rb <product_name> path/to/your/file.ext
-```
-
-Using the ruby bundler:
-
-```sh
-bundle exec ruby ./bin/mindee.rb <product_name> path/to/your/file.ext
-```
-
-Where possible values for `<product_name>` can be displayed by running the command with no arguments.
-
-## Further Reading
-
-There's more to it than that for those that need more features, or want to
-customize the experience.
-
-* [Ruby Overview](https://developers.mindee.com/docs/ruby-getting-started)
-* [Common file operations](https://developers.mindee.com/docs/ruby-common-file-operations)
-* [Global products](https://developers.mindee.com/docs/ruby-global-products)
-* [Localized products](https://developers.mindee.com/docs/ruby-localized-products)
-
-You can also take a look at the
-[Reference Documentation](https://mindee.github.io/mindee-api-ruby/).
-
-## License
-
-Copyright © Mindee, SA
-
-Available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-## Questions?
-
-[Join our Slack](https://join.slack.com/t/mindee-community/shared_invite/zt-2d0ds7dtz-DPAF81ZqTy20chsYpQBW5g)
+Available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/docs/code_samples/default_v2.txt

@@ -0,0 +1,28 @@
+require 'mindee'
+
+input_path = '/path/to/the/file.ext'
+api_key = 'MY_API_KEY'
+model_id = 'MY_MODEL_ID'
+
+# Init a new client
+mindee_client = Mindee::ClientV2.new(api_key: api_key)
+
+# Set inference parameters
+params = Mindee::Input::InferenceParameters.new(
+    # ID of the model, required.
+    model_id,
+    # If set to `True`, will enable Retrieval-Augmented Generation.
+    rag: false,
+)
+
+# Load a file from disk
+input_source = Mindee::Input::Source::PathInputSource.new(input_path)
+
+# Send for processing
+response = mindee_client.enqueue_and_get_inference(
+    input_source,
+    params # Note: this parameter can also be provided as a Hash.
+)
+
+# Print a brief summary of the parsed data
+puts response.inference

data/lib/mindee/client.rb

@@ -2,38 +2,17 @@
 
 require_relative 'input'
 require_relative 'http'
-require_relative 'product'
+require_relative 'logging'
+require_relative 'page_options'
 require_relative 'parsing/common/api_response'
 require_relative 'parsing/common/job'
 require_relative 'parsing/common/workflow_response'
-require_relative 'logging'
+require_relative 'product'
 
 # Default owner for products.
 OTS_OWNER = 'mindee'
 
 module Mindee
-  # Class for page options in parse calls.
-  #
-  # @!attribute page_indexes [Array[Integer]] Zero-based list of page indexes.
-  # @!attribute operation [:KEEP_ONLY, :REMOVE] Operation to apply on the document, given the specified page indexes:
-  #   * `:KEEP_ONLY` - keep only the specified pages, and remove all others.
-  #   * `:REMOVE` - remove the specified pages, and keep all others.
-  # @!attribute on_min_pages [Integer, nil] Apply the operation only if the document has at least this many pages.
-  class PageOptions
-    attr_accessor :page_indexes, :operation, :on_min_pages
-
-    def initialize(params: {})
-      params ||= {}
-      params = params.transform_keys(&:to_sym)
-      @page_indexes = params.fetch(
-        :page_indexes,
-        [] # : Array[Integer]
-      )
-      @operation    = params.fetch(:operation, :KEEP_ONLY)
-      @on_min_pages = params.fetch(:on_min_pages, nil)
-    end
-  end
-
   # Class for configuration options in parse calls.
   #
   # @!attribute all_words [bool] Whether to include the full text for each page.
@@ -89,8 +68,9 @@ module Mindee
   #       * `: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 the document has at least this many pages.
+  # @!attribute close_file [bool, nil] Whether to close the file after sending it. Defaults to true.
   class WorkflowOptions
-    attr_accessor :document_alias, :priority, :full_text, :public_url, :page_options, :rag
+    attr_accessor :document_alias, :priority, :full_text, :public_url, :page_options, :rag, :close_file
 
     def initialize(params: {})
       params = params.transform_keys(&:to_sym)
@@ -102,6 +82,7 @@ module Mindee
       raw_page_options = params.fetch(:page_options, nil)
       raw_page_options = PageOptions.new(params: raw_page_options) unless raw_page_options.is_a?(PageOptions)
       @page_options = raw_page_options
+      @close_file = params.fetch(:close_file, true)
     end
   end
 
@@ -326,7 +307,7 @@ module Mindee
         process_pdf_if_required(input_source, opts)
       end
 
-      workflow_endpoint = Mindee::HTTP::WorkflowEndpoint.new(workflow_id, api_key: @api_key)
+      workflow_endpoint = Mindee::HTTP::WorkflowEndpoint.new(workflow_id, api_key: @api_key.to_s)
       logger.debug("Sending document to workflow '#{workflow_id}'")
 
       prediction, raw_http = workflow_endpoint.execute_workflow(
@@ -455,11 +436,11 @@ module Mindee
       account_name = fix_account_name(account_name)
       version = fix_version(product_class, version)
 
-      HTTP::Endpoint.new(account_name, endpoint_name, version, api_key: @api_key)
+      HTTP::Endpoint.new(account_name, endpoint_name, version, api_key: @api_key.to_s)
     end
 
     def fix_endpoint_name(product_class, endpoint_name)
-      endpoint_name.nil? || endpoint_name.empty? ? product_class.endpoint_name : endpoint_name
+      endpoint_name.nil? || endpoint_name.empty? ? product_class.endpoint_name.to_s : endpoint_name.to_s
     end
 
     def fix_account_name(account_name)
@@ -474,11 +455,11 @@ module Mindee
     def fix_version(product_class, version)
       return version unless version.nil? || version.empty?
 
-      if product_class.endpoint_version.nil? || product_class.endpoint_version.empty?
+      if product_class.endpoint_version.nil? || product_class.endpoint_version.to_s.empty?
         logger.debug('No version provided for a custom build, will attempt to poll version 1 by default.')
         return '1'
       end
-      product_class.endpoint_version
+      product_class.endpoint_version || ''
     end
 
     # If needed, converts the parsing options provided as a hash into a proper ParseOptions object.

data/lib/mindee/client_v2.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative 'input'
+require_relative 'http'
+require_relative 'product'
+require_relative 'parsing/common/api_response'
+require_relative 'parsing/common/job'
+require_relative 'parsing/common/workflow_response'
+require_relative 'logging'
+
+module Mindee
+  # Mindee V2 API Client.
+  class ClientV2
+    # @return [HTTP::MindeeApiV2]
+    private attr_reader :mindee_api
+
+    # @param api_key [String]
+    def initialize(api_key: '')
+      @mindee_api = Mindee::HTTP::MindeeApiV2.new(api_key: api_key)
+    end
+
+    # Retrieves an inference.
+    # @param inference_id [String]
+    # @return [Mindee::Parsing::V2::InferenceResponse]
+    def get_inference(inference_id)
+      @mindee_api.req_get_inference(inference_id)
+    end
+
+    # Retrieves an inference.
+    # @param job_id [String]
+    # @return [Mindee::Parsing::V2::JobResponse]
+    def get_job(job_id)
+      @mindee_api.req_get_job(job_id)
+    end
+
+    # Enqueue a document for async parsing.
+    # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
+    #   The source of the input document (local file or URL).
+    # @param params [Hash, InferenceParameters]
+    # @return [Mindee::Parsing::V2::JobResponse]
+    def enqueue_inference(input_source, params)
+      normalized_params = normalize_inference_parameters(params)
+      logger.debug("Enqueueing document to model '#{normalized_params.model_id}'.")
+
+      @mindee_api.req_post_inference_enqueue(input_source, normalized_params)
+    end
+
+    # Enqueue a document for async parsing and automatically try to retrieve it.
+    # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
+    #   The source of the input document (local file or URL).
+    # @param params [Hash, InferenceParameters] Parameters for the inference.
+    # @return [Mindee::Parsing::V2::InferenceResponse]
+    def enqueue_and_get_inference(input_source, params)
+      normalized_params = normalize_inference_parameters(params)
+      normalized_params.validate_async_params
+      enqueue_response = enqueue_inference(input_source, normalized_params)
+
+      if enqueue_response.job.id.nil? || enqueue_response.job.id.empty?
+        logger.error("Failed enqueueing:\n#{enqueue_response.raw_http}")
+        raise Mindee::Errors::MindeeError, 'Enqueueing of the document failed.'
+      end
+
+      job_id = enqueue_response.job.id
+      logger.debug("Successfully enqueued document with job id: #{job_id}.")
+
+      sleep(normalized_params.polling_options.initial_delay_sec)
+      retry_counter = 1
+      poll_results = get_job(job_id)
+
+      while retry_counter < normalized_params.polling_options.max_retries
+        if poll_results.job.status == 'Failed'
+          break
+        elsif poll_results.job.status == 'Processed'
+          return get_inference(poll_results.job.id)
+        end
+
+        logger.debug(
+          "Successfully enqueued inference with job id: #{job_id}.\n" \
+          "Attempt n°#{retry_counter}/#{normalized_params.polling_options.max_retries}.\n" \
+          "Job status: #{poll_results.job.status}."
+        )
+
+        sleep(normalized_params.polling_options.delay_sec)
+        poll_results = get_job(job_id)
+        retry_counter += 1
+      end
+
+      error = poll_results.job.error
+      unless error.nil?
+        err_to_raise = Mindee::Errors::MindeeHTTPErrorV2.new(error)
+        # NOTE: purposefully decoupled from the line above, otherwise rubocop thinks `error` is a `message` param.
+        raise err_to_raise
+      end
+
+      sec_count = normalized_params.polling_options.delay_sec * retry_counter
+      raise Mindee::Errors::MindeeError,
+            "Asynchronous parsing request timed out after #{sec_count} seconds"
+    end
+
+    # If needed, converts the parsing options provided as a hash into a proper InferenceParameters object.
+    # @param params [Hash, InferenceParameters] Params.
+    # @return [InferenceParameters]
+    def normalize_inference_parameters(params)
+      return params if params.is_a?(Input::InferenceParameters)
+
+      Input::InferenceParameters.from_hash(params: params)
+    end
+  end
+end

data/lib/mindee/errors/mindee_http_error_v2.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'mindee_error'
+
+module Mindee
+  module Errors
+    # API V2 HttpError
+    class MindeeHTTPErrorV2 < MindeeError
+      # @return [Integer]
+      attr_reader :status
+      # @return [String]
+      attr_reader :detail
+
+      # @param http_error [Hash, Parsing::V2::ErrorResponse]
+      def initialize(http_error)
+        if http_error.is_a?(Parsing::V2::ErrorResponse)
+          http_error = { 'detail' => http_error.detail,
+                         'status' => http_error.status }
+        end
+        @status = http_error['status']
+        @detail = http_error['detail']
+        super("HTTP error: #{@status} - #{@detail}")
+      end
+    end
+  end
+end

data/lib/mindee/errors.rb

@@ -2,4 +2,5 @@
 
 require_relative 'errors/mindee_error'
 require_relative 'errors/mindee_http_error'
+require_relative 'errors/mindee_http_error_v2'
 require_relative 'errors/mindee_input_error'

data/lib/mindee/geometry/point.rb

@@ -6,9 +6,9 @@ module Mindee
     # A relative set of coordinates (X, Y) on the document.
     class Point
       # @return [Float]
-      attr_accessor :x
+      attr_reader :x
       # @return [Float]
-      attr_accessor :y
+      attr_reader :y
 
       # rubocop:disable Naming/MethodParameterName
 

data/lib/mindee/geometry/quadrilateral.rb

@@ -6,13 +6,13 @@ module Mindee
     # Contains exactly 4 relative vertices coordinates (Points).
     class Quadrilateral
       # @return [Mindee::Geometry::Point]
-      attr_accessor :top_left
+      attr_reader :top_left
       # @return [Mindee::Geometry::Point]
-      attr_accessor :top_right
+      attr_reader :top_right
       # @return [Mindee::Geometry::Point]
-      attr_accessor :bottom_right
+      attr_reader :bottom_right
       # @return [Mindee::Geometry::Point]
-      attr_accessor :bottom_left
+      attr_reader :bottom_left
 
       # @param top_left [Mindee::Geometry::Point]
       # @param top_right [Mindee::Geometry::Point]

data/lib/mindee/geometry/utils.rb

@@ -83,6 +83,7 @@ module Mindee
     # @param anchor [Array<Mindee::Geometry::Point] Reference polygon
     # @param margin_left [Float] Margin tolerance on the left of the anchor
     # @param margin_right [Float] Margin tolerance on the right of the anchor
+    # @return bool
     def self.below?(candidate, anchor, margin_left, margin_right)
       return false if Geometry.get_min_max_y(candidate).min < Geometry.get_min_max_y(anchor).min
       if Geometry.get_min_max_x(candidate).min <

data/lib/mindee/http/api_settings_v2.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Mindee
+  module HTTP
+    # API client for version 2.
+    class ApiSettingsV2
+      # V2 API key's default environment key name.
+      MINDEE_V2_API_KEY_ENV_NAME = 'MINDEE_V2_API_KEY'
+      # V2 API key's default value.
+      MINDEE_V2_API_KEY_DEFAULT = nil
+
+      # V2 base URL default environment key name.
+      MINDEE_V2_BASE_URL_ENV_NAME = 'MINDEE_V2_BASE_URL'
+      # V2 base URL default value.
+      MINDEE_V2_BASE_URL_DEFAULT = 'https://api-v2.mindee.net/v2'
+
+      # HTTP request timeout default environment key name.
+      MINDEE_V2_REQUEST_TIMEOUT_ENV_NAME = 'MINDEE_V2_REQUEST_TIMEOUT'
+      # HTTP request timeout default value.
+      MINDEE_V2_TIMEOUT_DEFAULT = 120
+
+      # Default value for the user agent (same as V1).
+      USER_AGENT = "mindee-api-ruby@v#{Mindee::VERSION} ruby-v#{RUBY_VERSION} #{Mindee::PLATFORM}".freeze
+
+      # @return [String]
+      attr_reader :api_key
+      # @return [Integer]
+      attr_reader :request_timeout
+      # @return [String]
+      attr_reader :base_url
+      # @return [String]
+      attr_reader :user_agent
+
+      def initialize(api_key: nil)
+        @request_timeout = ENV.fetch(MINDEE_V2_REQUEST_TIMEOUT_ENV_NAME, MINDEE_V2_TIMEOUT_DEFAULT).to_i
+        if api_key.nil? && !ENV.fetch(MINDEE_V2_API_KEY_ENV_NAME, MINDEE_V2_API_KEY_DEFAULT).to_s.empty?
+          logger.debug('API key set from environment')
+        end
+        @api_key = if api_key.nil? || api_key.empty?
+                     ENV.fetch(MINDEE_V2_API_KEY_ENV_NAME,
+                               MINDEE_V2_API_KEY_DEFAULT)
+                   else
+                     api_key
+                   end
+        @base_url = ENV.fetch(MINDEE_V2_BASE_URL_ENV_NAME, MINDEE_V2_BASE_URL_DEFAULT).chomp('/')
+        @user_agent = USER_AGENT
+      end
+
+      # Checks API key for a value.
+      # @return
+      # @raise [Errors::MindeeAPIError] Raises if the api key is empty or nil.
+      def check_api_key
+        return unless @api_key.nil? || @api_key.to_s.empty?
+
+        raise Errors::MindeeAPIError,
+              "Missing API key. check your Client Configuration.\nYou can set this using the " \
+              "'#{MINDEE_V2_API_KEY_ENV_NAME}' environment variable."
+      end
+    end
+  end
+end