mindee 4.12.0 → 5.0.0.beta1

data/lib/mindee/errors/mindee_http_error_v2.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'mindee_error'
-require_relative '../parsing/v2/error_item'
-
-module Mindee
-  module Errors
-    # API V2 HttpError
-    class MindeeHTTPErrorV2 < MindeeError
-      # @return [Integer] The HTTP status code returned by the server.
-      attr_reader :status
-      # @return [String] A human-readable explanation specific to the occurrence of the problem.
-      attr_reader :detail
-      # @return [String] A short, human-readable summary of the problem.
-      attr_reader :title
-      # @return [String] A machine-readable code specific to the occurrence of the problem.
-      attr_reader :code
-      # @return [Array<ErrorItem>] A list of explicit error details.
-      attr_reader :errors
-
-      # @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,
-                         'title' => http_error.title,
-                         'code' => http_error.code,
-                         'errors' => http_error.errors }
-        end
-        @status = http_error['status']
-        @detail = http_error['detail']
-        @title = http_error['title']
-        @code = http_error['code']
-        @errors = if http_error.key?('errors')
-                    http_error['errors'].map do |error|
-                      Parsing::V2::ErrorItem.new(error)
-                    end
-                  else
-                    []
-                  end
-        super("HTTP #{@status} - #{@title} :: #{@code} - #{@detail}")
-      end
-    end
-  end
-end

data/lib/mindee/errors/mindee_http_unknown_error_v2.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'mindee_error'
-
-module Mindee
-  module Errors
-    # Unknown HTTP error for the V2 API.
-    class MindeeHTTPUnknownErrorV2 < MindeeHTTPErrorV2
-      def initialize(http_error)
-        super({ 'detail' => "Couldn't deserialize server error. Found: #{http_error}",
-                'status' => -1,
-                'title' => 'Unknown Error',
-                'code' => '000-000',
-                'errors' => nil })
-      end
-    end
-  end
-end

data/lib/mindee/errors/mindee_input_error.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  module Errors
-    # Base class for errors relating to input documents.
-    class MindeeInputError < MindeeError; end
-
-    # Errors relating to sources (documents) handling.
-    class MindeeSourceError < MindeeInputError; end
-
-    # Errors relating to mime type issues.
-    class MindeeMimeTypeError < MindeeSourceError
-      # @return [String]
-      attr_reader :invalid_mimetype
-
-      # @param mime_type [String]
-      def initialize(mime_type)
-        @invalid_mimetype = mime_type
-        super("'#{@invalid_mimetype}' mime type not allowed, must be one of " \
-              "#{Mindee::Input::Source::ALLOWED_MIME_TYPES.join(', ')}")
-      end
-    end
-
-    # Errors relating to the handling of images.
-    class MindeeImageError < MindeeInputError; end
-
-    # Errors relating to the handling of PDF documents.
-    class MindeePDFError < MindeeInputError; end
-  end
-end

data/lib/mindee/errors.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-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/extraction/multi_receipts_extractor.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  # Custom extraction module
-  module Extraction
-    # Multi-receipts extraction
-    # Extracts individual receipts from multi-receipts documents.
-    #
-    # @param input_source [LocalInputSource] Local Input Source to extract sub-receipts from.
-    # @param inference [Inference] Results of the inference.
-    # @return [Array<ExtractedImage>] Individual extracted receipts as an array of ExtractedMultiReceiptsImage.
-    def self.extract_receipts(input_source, inference)
-      images = []
-      unless inference.prediction.receipts
-        raise Errors::MindeeInputError,
-              'No possible receipts candidates found for Multi-Receipts extraction.'
-      end
-
-      (0...input_source.count_pages).each do |page_id|
-        receipt_positions = inference.pages[page_id].prediction.receipts.map(&:bounding_box)
-        images.concat(
-          Mindee::Image::ImageExtractor.extract_multiple_images_from_source(input_source, page_id + 1,
-                                                                            receipt_positions)
-        )
-      end
-
-      images
-    end
-  end
-end

data/lib/mindee/http/api_settings_v2.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../version'
-
-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

data/lib/mindee/http/endpoint.rb

@@ -1,219 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'net/http'
-require_relative 'http_error_handler'
-require_relative '../version'
-require_relative 'response_validation'
-
-module Mindee
-  # Mindee internal HTTP module.
-  module HTTP
-    # API key's default environment key name.
-    API_KEY_ENV_NAME = 'MINDEE_API_KEY'
-    # API key's default value.
-    API_KEY_DEFAULT = nil
-
-    # Base URL default environment key name.
-    BASE_URL_ENV_NAME = 'MINDEE_BASE_URL'
-    # Base URL's default value.
-    BASE_URL_DEFAULT = 'https://api.mindee.net/v1'
-
-    # HTTP request timeout default environment key name.
-    REQUEST_TIMEOUT_ENV_NAME = 'MINDEE_REQUEST_TIMEOUT'
-    # HTTP request timeout default value.
-    TIMEOUT_DEFAULT = 120
-
-    # Default value for the user agent.
-    USER_AGENT = "mindee-api-ruby@v#{Mindee::VERSION} ruby-v#{RUBY_VERSION} #{Mindee::PLATFORM}".freeze
-
-    # Generic API endpoint for a product.
-    class Endpoint
-      # @return [String]
-      attr_reader :api_key
-      # @return [Integer]
-      attr_reader :request_timeout
-      # @return [String]
-      attr_reader :url_root
-      # @return [String]
-      attr_reader :base_url
-
-      def initialize(owner, url_name, version, api_key: '')
-        @owner = owner
-        @url_name = url_name
-        @version = version
-        @request_timeout = ENV.fetch(REQUEST_TIMEOUT_ENV_NAME, TIMEOUT_DEFAULT).to_i
-        if api_key.nil? && !ENV.fetch(API_KEY_ENV_NAME, API_KEY_DEFAULT).to_s.empty?
-          logger.debug('API key set from environment')
-        end
-        @api_key = api_key.nil? || api_key.empty? ? ENV.fetch(API_KEY_ENV_NAME, API_KEY_DEFAULT) : api_key
-        @base_url = ENV.fetch(BASE_URL_ENV_NAME, BASE_URL_DEFAULT).chomp('/')
-        @url_root = "#{@base_url}/products/#{@owner}/#{@url_name}/v#{@version}"
-      end
-
-      # Call the prediction API.
-      # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
-      # @param opts [ParseOptions] Parse options.
-      # @return [Array]
-      def predict(input_source, opts)
-        check_api_key
-        response = predict_req_post(
-          input_source,
-          opts
-        )
-        if !response.nil? && response.respond_to?(:body)
-          hashed_response = JSON.parse(response.body, object_class: Hash)
-          return [hashed_response, response.body] if ResponseValidation.valid_sync_response?(response)
-
-          ResponseValidation.clean_request!(response)
-        end
-
-        raise Errors::MindeeError, 'Could not resolve server response.' if response.nil?
-
-        error = ErrorHandler.handle_error(@url_name, response)
-        raise error
-      end
-
-      # Call the prediction API.
-      # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
-      # @param opts [ParseOptions, Hash] Parse options.
-      # @return [Array]
-      def predict_async(input_source, opts)
-        check_api_key
-        response = document_queue_req_post(input_source, opts)
-        if !response.nil? && response.respond_to?(:body)
-          hashed_response = JSON.parse(response.body, object_class: Hash)
-          return [hashed_response, response.body] if ResponseValidation.valid_async_response?(response)
-
-          ResponseValidation.clean_request!(response)
-        end
-
-        raise Errors::MindeeError, 'Could not resolve server response.' if response.nil?
-
-        raise ErrorHandler.handle_error(@url_name, response)
-      end
-
-      # Calls the parsed async doc.
-      # @param job_id [String]
-      # @return [Array]
-      def parse_async(job_id)
-        check_api_key
-        response = document_queue_req_get(job_id)
-        hashed_response = JSON.parse(response.body, object_class: Hash)
-        return [hashed_response, response.body] if ResponseValidation.valid_async_response?(response)
-
-        ResponseValidation.clean_request!(response)
-        error = ErrorHandler.handle_error(@url_name, response)
-        raise error
-      end
-
-      private
-
-      # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
-      # @param opts [ParseOptions] Parse options.
-      # @return [Net::HTTPResponse, nil]
-      def predict_req_post(input_source, opts)
-        uri = URI("#{@url_root}/predict")
-
-        params = {} # : Hash[String | Symbol, untyped]
-        params[:cropper] = 'true' if opts.cropper
-        params[:full_text_ocr] = 'true' if opts.full_text
-        uri.query = URI.encode_www_form(params)
-
-        headers = {
-          'Authorization' => "Token #{@api_key}",
-          'User-Agent' => USER_AGENT,
-        }
-        req = Net::HTTP::Post.new(uri, headers)
-        form_data = if input_source.is_a?(Mindee::Input::Source::URLInputSource)
-                      [['document', input_source.url]] # : Array[untyped]
-                    else
-                      [['document', *input_source.read_contents(close: opts.close_file)]] # : Array[untyped]
-                    end
-        form_data.push ['include_mvision', 'true'] if opts.all_words
-
-        req.set_form(form_data, 'multipart/form-data')
-        req['Transfer-Encoding'] = 'chunked'
-
-        Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @request_timeout) do |http|
-          return http.request(req)
-        end
-        raise Mindee::Errors::MindeeError, 'Could not resolve server response.'
-      end
-
-      # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
-      # @param opts [ParseOptions] Parse options.
-      # @return [Net::HTTPResponse]
-      def document_queue_req_post(input_source, opts)
-        uri = if opts.workflow_id
-                URI("#{@base_url}/workflows/#{opts.workflow_id}/predict_async")
-              else
-                URI("#{@url_root}/predict_async")
-              end
-
-        params = {} # : Hash[String | Symbol, untyped]
-        params[:cropper] = 'true' if opts.cropper
-        params[:full_text_ocr] = 'true' if opts.full_text
-        params[:rag] = 'true' if opts.rag
-        uri.query = URI.encode_www_form(params)
-
-        headers = {
-          'Authorization' => "Token #{@api_key}",
-          'User-Agent' => USER_AGENT,
-        }
-        req = Net::HTTP::Post.new(uri, headers)
-        form_data = if input_source.is_a?(Mindee::Input::Source::URLInputSource)
-                      [['document', input_source.url]] # : Array[untyped]
-                    else
-                      [['document', *input_source.read_contents(close: opts.close_file)]] # : Array[untyped]
-                    end
-        form_data.push ['include_mvision', 'true'] if opts.all_words
-
-        req.set_form(form_data, 'multipart/form-data')
-        req['Transfer-Encoding'] = 'chunked'
-
-        Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @request_timeout) do |http|
-          return http.request(req)
-        end
-        raise Mindee::Errors::MindeeError, 'Could not resolve server response.'
-      end
-
-      # @param job_id [String]
-      # @return [Net::HTTPResponse, nil]
-      def document_queue_req_get(job_id)
-        uri = URI("#{@url_root}/documents/queue/#{job_id}")
-
-        headers = {
-          'Authorization' => "Token #{@api_key}",
-          'User-Agent' => USER_AGENT,
-        }
-
-        req = Net::HTTP::Get.new(uri, headers)
-
-        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @request_timeout) do |http|
-          http.request(req)
-        end
-
-        raise Errors::MindeeError, 'Could not resolve server response.' if response.nil?
-
-        if response.code.to_i > 299 && response.code.to_i < 400
-          req = Net::HTTP::Get.new(response['location'], headers)
-          Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @request_timeout) do |http|
-            response = http.request(req)
-          end
-        end
-        response
-      end
-
-      # Checks API key
-      def check_api_key
-        return unless @api_key.nil? || @api_key.empty?
-
-        raise Errors::MindeeAPIError,
-              "Missing API key for product \"'#{@url_name}' v#{@version}\" (belonging to \"#{@owner}\"), " \
-              "check your Client Configuration.\nYou can set this using the " \
-              "'#{HTTP::API_KEY_ENV_NAME}' environment variable."
-      end
-    end
-  end
-end

data/lib/mindee/http/mindee_api_v2.rb

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'api_settings_v2'
-require_relative '../input'
-require_relative '../errors'
-require_relative '../parsing/v2'
-
-module Mindee
-  module HTTP
-    # API client for version 2.
-    class MindeeApiV2
-      # @return [ApiSettingsV2]
-      attr_reader :settings
-
-      # @param api_key [String, nil]
-      def initialize(api_key: nil)
-        @settings = ApiSettingsV2.new(api_key: api_key)
-      end
-
-      # Sends a file to the inference queue.
-      #
-      # @param input_source [Input::Source::LocalInputSource, Input::Source::URLInputSource]
-      # @param params [Input::InferenceParameters]
-      # @return [Mindee::Parsing::V2::JobResponse]
-      # @raise [Mindee::Errors::MindeeHttpErrorV2]
-      def req_post_inference_enqueue(input_source, params)
-        @settings.check_api_key
-        response = enqueue(
-          input_source,
-          params
-        )
-        Parsing::V2::JobResponse.new(process_response(response))
-      end
-
-      # Retrieves a queued inference.
-      #
-      # @param inference_id [String]
-      # @return [Mindee::Parsing::V2::InferenceResponse]
-      def req_get_inference(inference_id)
-        @settings.check_api_key
-        response = inference_result_req_get(
-          inference_id
-        )
-        Parsing::V2::InferenceResponse.new(process_response(response))
-      end
-
-      # Retrieves a queued job.
-      #
-      # @param job_id [String]
-      # @return [Mindee::Parsing::V2::JobResponse]
-      def req_get_job(job_id)
-        @settings.check_api_key
-        response = inference_job_req_get(
-          job_id
-        )
-        Parsing::V2::JobResponse.new(process_response(response))
-      end
-
-      private
-
-      # Converts an HTTP response to a parsed response object.
-      #
-      # @param response [Net::HTTPResponse, nil]
-      # @return [Hash]
-      # @raise Throws if the server returned an error.
-      def process_response(response)
-        if !response.nil? && response.respond_to?(:body) && 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 ErrorHandler.generate_v2_error(JSON.parse(response_body).transform_keys(&:to_sym))
-      end
-
-      # Polls a queue for either a result or a job.
-      # @param url [String] URL, passed as a string.
-      # @return [Net::HTTPResponse]
-      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::Errors::MindeeError, 'Could not resolve server response.'
-      end
-
-      # Polls the API for the status of a job.
-      #
-      # @param job_id [String] ID of the job.
-      # @return [Net::HTTPResponse]
-      def inference_job_req_get(job_id)
-        poll("#{@settings.base_url}/jobs/#{job_id}")
-      end
-
-      # Polls the API for the result of an inference.
-      #
-      # @param queue_id [String] ID of the queue.
-      # @return [Net::HTTPResponse]
-      def inference_result_req_get(queue_id)
-        poll("#{@settings.base_url}/inferences/#{queue_id}")
-      end
-
-      # Handle parameters for the enqueue form
-      # @param form_data [Array] Array of form fields
-      # @param params [Input::InferenceParameters] Inference options.
-      def enqueue_form_options(form_data, params)
-        # deal with optional features
-        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 ['file_alias', params.file_alias] if params.file_alias
-        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?
-          form_data.push ['webhook_ids', params.webhook_ids.join(',')]
-        end
-        form_data
-      end
-
-      # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
-      # @param params [Input::InferenceParameters] Inference options.
-      # @return [Net::HTTPResponse, nil]
-      def enqueue(input_source, params)
-        uri = URI("#{@settings.base_url}/inferences/enqueue")
-
-        form_data = if input_source.is_a?(Mindee::Input::Source::URLInputSource)
-                      [['url', input_source.url]] # : Array[untyped]
-                    else
-                      file_data, file_metadata = input_source.read_contents(close: params.close_file)
-                      [['file', file_data, file_metadata]] # : Array[untyped]
-                    end
-        form_data.push(['model_id', params.model_id])
-
-        # deal with other parameters
-        form_data = enqueue_form_options(form_data, params)
-
-        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::Errors::MindeeError, 'Could not resolve server response.'
-      end
-    end
-  end
-end

data/lib/mindee/http/workflow_endpoint.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'net/http'
-require_relative 'http_error_handler'
-
-module Mindee
-  module HTTP
-    # Handles the routing for workflow calls.
-    class WorkflowEndpoint
-      # @return [String]
-      attr_reader :api_key
-      # @return [Integer]
-      attr_reader :request_timeout
-      # @return [String]
-      attr_reader :url
-
-      def initialize(workflow_id, api_key: '')
-        @request_timeout = ENV.fetch(REQUEST_TIMEOUT_ENV_NAME, TIMEOUT_DEFAULT).to_i
-        @api_key = api_key.nil? || api_key.empty? ? ENV.fetch(API_KEY_ENV_NAME, API_KEY_DEFAULT) : api_key
-        base_url = ENV.fetch(BASE_URL_ENV_NAME, BASE_URL_DEFAULT)
-        @url = "#{base_url.chomp('/')}/workflows/#{workflow_id}/executions"
-      end
-
-      # Sends a document to the workflow.
-      # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
-      # @param opts [WorkflowOptions] Options to configure workflow execution behavior.
-      # @return [Array]
-      def execute_workflow(input_source, opts)
-        check_api_key
-        response = workflow_execution_req_post(input_source, opts)
-        if response.nil?
-          raise Mindee::Errors::MindeeHTTPError.new(
-            { code: 0, details: 'Server response was nil.', message: 'Unknown error.' }, @url, 0
-          )
-        end
-
-        hashed_response = JSON.parse(response.body, object_class: Hash)
-        return [hashed_response, response.body] if ResponseValidation.valid_async_response?(response)
-
-        ResponseValidation.clean_request!(response)
-        error = Mindee::HTTP::ErrorHandler.handle_error(@url_name, response)
-        raise error
-      end
-
-      # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::URLInputSource]
-      # @param opts [WorkflowOptions] Options to configure workflow execution behavior.
-      # @return [Net::HTTPResponse, nil]
-      def workflow_execution_req_post(input_source, opts)
-        uri = URI(@url)
-        params = {} # : Hash[String | Symbol, untyped]
-        params[:full_text_ocr] = 'true' if opts.full_text
-        params[:rag] = 'true' if opts.rag
-        uri.query = URI.encode_www_form(params) if params.any?
-
-        headers = {
-          'Authorization' => "Token #{@api_key}",
-          'User-Agent' => USER_AGENT,
-        }
-        req = Net::HTTP::Post.new(uri, headers)
-        form_data = [] # : Array[untyped]
-        if input_source.is_a?(Mindee::Input::Source::URLInputSource)
-          form_data.push ['document', input_source.url]
-        else
-          form_data.push ['document', *input_source.read_contents(close: opts.close_file)]
-        end
-        form_data.push ['alias', opts.document_alias] if opts.document_alias
-        form_data.push ['public_url', opts.public_url] if opts.public_url
-        form_data.push ['priority', opts.priority.to_s] if opts.priority
-
-        req.set_form(form_data, 'multipart/form-data')
-        req['Transfer-Encoding'] = 'chunked'
-
-        response = nil
-        Net::HTTP.start(uri.hostname, uri.port, use_ssl: true, read_timeout: @request_timeout) do |http|
-          response = http.request(req)
-        end
-        response
-      end
-
-      # Checks API key
-      def check_api_key
-        return unless @api_key.nil? || @api_key.empty?
-
-        raise Errors::MindeeConfigurationError, "Missing API key. Check your Client Configuration.\n" \
-                                                "You can set this using the '#{HTTP::API_KEY_ENV_NAME}'" \
-                                                'environment variable.'
-      end
-    end
-  end
-end