mindee 4.13.0 → 5.0.0.beta1

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,215 +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::BaseParameters]
-      # @return [Mindee::Parsing::V2::JobResponse]
-      # @raise [Mindee::Errors::MindeeHttpErrorV2]
-      def req_post_enqueue(input_source, params)
-        @settings.check_api_key
-        response = enqueue(
-          input_source,
-          params
-        )
-        Mindee::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)
-        req_get_result(Parsing::V2::Inference, inference_id)
-      end
-
-      # Retrieves a result from a given queue.
-      # @param product [Class<Mindee::V2::Product::BaseProduct>] The return class.
-      # @param resource [String] ID of the inference or URL to the result.
-      # @return [Mindee::Parsing::V2::BaseResponse]
-      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
-
-      # Retrieves a queued job.
-      #
-      # @param job_id [String] ID of the job or URL to the job.
-      # @return [Mindee::Parsing::V2::JobResponse]
-      def req_get_job(job_id)
-        @settings.check_api_key
-        response = inference_job_req_get(
-          job_id
-        )
-        Mindee::Parsing::V2::JobResponse.new(process_response(response))
-      end
-
-      private
-
-      # Retrieves a queued job.
-      #
-      # @param url [String]
-      # @return [Mindee::Parsing::V2::JobResponse]
-      def req_get_job_url(url)
-        @settings.check_api_key
-        response = poll(url)
-        Mindee::Parsing::V2::JobResponse.new(process_response(response))
-      end
-
-      # Retrieves a queued job.
-      #
-      # @param result_class [Mindee::V2::Parsing::BaseResponse]
-      # @param url [String]
-      # @return [Mindee::Parsing::V2::JobResponse]
-      def req_get_result_url(result_class, url)
-        @settings.check_api_key
-        response = poll(url)
-        result_class.new(process_response(response))
-      end
-
-      # @param resource [String] Resource to check.
-      # @return [Boolean]
-      def uri?(resource)
-        uri = URI.parse(resource)
-        throw Mindee::Errors::MindeeError, 'HTTP is not supported.' if uri.scheme == 'http'
-        uri.scheme == 'https'
-      rescue URI::BadURIError, URI::InvalidURIError
-        false
-      end
-
-      # 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
-
-      # Polls the API for the result of an inference.
-      #
-      # @param queue_id [String] ID of the queue.
-      # @param product [Class<Mindee::V2::Product::BaseProduct>] The return class.
-      # @return [Net::HTTPResponse]
-      def result_req_get(queue_id, product)
-        poll("#{@settings.base_url}/products/#{product.slug}/results/#{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::BaseParameters] Inference options.
-      # @return [Net::HTTPResponse, nil]
-      def enqueue(input_source, params)
-        uri = URI("#{@settings.base_url}/products/#{params.slug}/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])
-
-        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::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