mindee 4.13.0 → 5.0.0.rc1

data/lib/mindee/parsing/standard/base_field.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../geometry'
-require_relative 'abstract_field'
-
-module Mindee
-  module Parsing
-    module Standard
-      # Base field object.
-      class BaseField < Mindee::Parsing::Standard::AbstractField
-        # @return [String, Float, Integer, bool]
-        attr_reader :value
-        # true if the field was reconstructed or computed using other fields.
-        # @return [bool]
-        attr_reader :reconstructed
-
-        # @param prediction [Hash]
-        # @param page_id [Integer, nil]
-        # @param reconstructed [bool]
-        def initialize(prediction, page_id, reconstructed: false)
-          super(prediction, page_id)
-          @value = prediction['value']
-          @reconstructed = reconstructed
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/standard/boolean_field.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_field'
-
-module Mindee
-  module Parsing
-    module Standard
-      # Represents basic text information.
-      class BooleanField < BaseField
-        # Value as bool
-        # @return [bool, nil]
-        attr_reader :value
-
-        def initialize(prediction, page_id = nil, reconstructed: false)
-          super
-        end
-
-        # @return [String]
-        def to_s
-          return '' if value.nil?
-
-          value ? 'True' : 'False'
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/standard/classification_field.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_field'
-
-module Mindee
-  module Parsing
-    module Standard
-      # Represents a classifier value.
-      class ClassificationField < BaseField
-        # Value as String
-        # @return [String]
-        attr_reader :value
-      end
-    end
-  end
-end

data/lib/mindee/parsing/standard/company_registration_field.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  module Parsing
-    module Standard
-      # Company registration number or code, and its type.
-      class CompanyRegistrationField < BaseField
-        # @return [String]
-        attr_reader :type
-
-        # @param prediction [Hash]
-        # @param page_id [Integer, nil]
-        # @param reconstructed [bool]
-        def initialize(prediction, page_id, reconstructed: false)
-          super
-          @type = prediction['type']
-        end
-
-        # Table line representation of the values.
-        # @return [String] The formatted table line, as a string.
-        def to_table_line
-          printable = printable_values
-          format('| %<type>-15s | %<value>-20s ', type: printable['type'], value: printable['value'])
-        end
-
-        # @return [String]
-        def to_s
-          printable = printable_values
-          format('Type: %<type>s, Value: %<value>s', type: printable['type'], value: printable['value'])
-        end
-
-        # Hashed representation of the values.
-        # @return [Hash] Hash of the values.
-        def printable_values
-          printable = {}
-          printable['type'] = type
-          printable['value'] = value
-          printable
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/standard/date_field.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'date'
-
-require_relative 'base_field'
-
-module Mindee
-  module Parsing
-    module Standard
-      # Represents a date.
-      class DateField < BaseField
-        # The date as a standard Ruby `Date` object.
-        # @return [Date, nil]
-        attr_reader :date_object
-        # The ISO 8601 representation of the date, regardless of the `raw` contents.
-        # @return [String, nil]
-        attr_reader :value
-        # The textual representation of the date as found on the document.
-        # @return [String, nil]
-        attr_reader :raw
-        # Whether the field was computed or retrieved directly from the document.
-        # @return [bool, nil]
-        attr_reader :is_computed
-
-        # @param prediction [Hash]
-        # @param page_id [Integer, nil]
-        def initialize(prediction, page_id)
-          super
-          @is_computed = prediction['is_computed']
-          return unless @value
-
-          @date_object = Date.parse(@value)
-          @raw = prediction['raw']
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/standard/feature_field.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  module Parsing
-    module Standard
-      # Feature field object wrapper for specialized methods.
-      class FeatureField < AbstractField
-        # Format strings for display by shortening long strings and assigning empty ones.
-        # @param in_str [String, bool, nil]
-        # @param max_col_size [int, nil]
-        # @return [String]
-        def format_for_display(in_str, max_col_size = nil)
-          return 'True' if in_str == true
-          return 'False' if in_str == false
-          return '' if in_str.nil?
-          return in_str.to_s if max_col_size.nil?
-
-          in_str = in_str.to_s.gsub(%r{[\n\r\t]}, "\n" => '\\n', "\r" => '\\r', "\t" => '\\t')
-          in_str.to_s.length <= max_col_size.to_i ? in_str.to_s : "#{in_str[0..(max_col_size.to_i - 4)]}..."
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/standard/locale_field.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  module Parsing
-    module Standard
-      # Represents locale information
-      class LocaleField
-        # The confidence score, value will be between 0.0 and 1.0
-        # @return [Float]
-        attr_reader :confidence
-        #  Language code in ISO 639-1 format.
-        # @return [String]
-        attr_reader :language
-        # Country code in ISO 3166-1 alpha-2 format.
-        # @return [String, nil]
-        attr_reader :country
-        # Currency code in ISO 4217 format.
-        # @return [String]
-        attr_reader :currency
-        # Language code, with country code when available.
-        # @return [String]
-        attr_reader :value
-
-        # @param prediction [Hash]
-        def initialize(prediction, _page_id = nil)
-          value_key = if !prediction.include?('value') || prediction['value'].nil?
-                        'language'
-                      else
-                        'value'
-                      end
-          @confidence = prediction['confidence']
-          @value = prediction[value_key]
-          @language = prediction['language']
-          @country = prediction['country']
-          @currency = prediction['currency']
-        end
-
-        # @return [String]
-        def to_s
-          out_str = String.new
-          out_str << "#{@value}; " unless @value.nil?
-          out_str << "#{@language}; " if @language
-          out_str << "#{@country}; " if @country
-          out_str << "#{@currency}; " if @currency
-          out_str.strip
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/standard/payment_details_field.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_field'
-
-module Mindee
-  module Parsing
-    module Standard
-      # Represents payment details for invoices and receipts
-      class PaymentDetailsField < BaseField
-        # @return [String, nil]
-        attr_reader :account_number
-        # @return [String, nil]
-        attr_reader :iban
-        # @return [String, nil]
-        attr_reader :routing_number
-        # @return [String, nil]
-        attr_reader :swift
-
-        # @param prediction [Hash]
-        # @param page_id [Integer, nil]
-        # @param reconstructed [bool]
-        def initialize(prediction, page_id, reconstructed: false)
-          super
-          @account_number = prediction['account_number']
-          @iban = prediction['iban']
-          @routing_number = prediction['routing_number']
-          @swift = prediction['swift']
-        end
-
-        # @return [String]
-        def to_s
-          out_str = String.new
-          out_str << "#{@account_number}; " if @account_number
-          out_str << "#{@iban}; " if @iban
-          out_str << "#{@routing_number}; " if @routing_number
-          out_str << "#{@swift}; " if @swift
-          out_str.strip
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/standard/position_field.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  module Parsing
-    module Standard
-      # An element's position on the image
-      class PositionField
-        # @return [Mindee::Geometry::Polygon]
-        attr_reader :polygon
-        # @return [Mindee::Geometry::Polygon]
-        attr_reader :value
-        # @return [Mindee::Geometry::Quadrilateral]
-        attr_reader :quadrangle
-        # @return [Mindee::Geometry::Quadrilateral]
-        attr_reader :rectangle
-        # @return [Mindee::Geometry::Quadrilateral]
-        attr_reader :bounding_box
-
-        # @param prediction [Hash]
-        # @param page_id [Integer, nil]
-        def initialize(prediction, page_id)
-          unless prediction['polygon'].nil? || prediction['polygon'].empty?
-            @polygon = Mindee::Geometry::Polygon.new(prediction['polygon'])
-          end
-          @quadrangle = to_quadrilateral(prediction, 'quadrangle')
-          @rectangle = to_quadrilateral(prediction, 'rectangle')
-          @bounding_box = to_quadrilateral(prediction, 'bounding_box')
-          @page_id = page_id || prediction['page_id']
-          @value = @polygon
-        end
-
-        # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/PerceivedComplexity
-
-        # String representation.
-        # @return [String]
-        def to_s
-          return "Polygon with #{@polygon.size} points." if @polygon&.size&.positive?
-          return "Polygon with #{@bounding_box.size} points." if @bounding_box&.size&.positive?
-          return "Polygon with #{@rectangle.size} points." if @rectangle&.size&.positive?
-          return "Polygon with #{@quadrangle.size} points." if @quadrangle&.size&.positive?
-
-          ''
-        end
-
-        # rubocop:enable Metrics/CyclomaticComplexity
-        # rubocop:enable Metrics/PerceivedComplexity
-
-        private
-
-        def to_quadrilateral(prediction, key)
-          return if prediction[key].nil? || prediction[key].empty?
-
-          Mindee::Geometry.quadrilateral_from_prediction(prediction[key])
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/standard/string_field.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_field'
-
-module Mindee
-  module Parsing
-    module Standard
-      # Represents basic text information.
-      class StringField < Mindee::Parsing::Standard::BaseField
-        # Value as String
-        # @return [String, nil]
-        attr_reader :value
-        # Value as String
-        # @return [String, nil]
-        attr_reader :raw_value
-
-        def initialize(prediction, page_id = nil, reconstructed: false)
-          super
-          @raw_value = prediction['raw_value']
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/standard/tax_field.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_field'
-
-module Mindee
-  module Parsing
-    module Standard
-      # Represents tax information.
-      class TaxField < BaseField
-        # Tax value as 3 decimal float
-        # @return [Float, nil]
-        attr_reader :value
-        # Tax rate percentage
-        # @return [Float]
-        attr_reader :rate
-        # Tax code
-        # @return [String]
-        attr_reader :code
-        # Tax base
-        # @return [Float]
-        attr_reader :base
-
-        # @param prediction [Hash]
-        # @param page_id [Integer, nil]
-        def initialize(prediction, page_id)
-          super
-          @value = prediction['value']&.round(3)
-          @rate = prediction['rate'].to_f unless prediction['rate'].nil?
-          @base = prediction['base'].to_f unless prediction['base'].nil?
-          @code = prediction['code'] unless prediction['code'] == 'None'
-        end
-
-        # @param value [Float]
-        def print_float(value)
-          format('%.2f', value)
-        end
-
-        # @return [String]
-        def to_s
-          printable = printable_values
-          out_str = String.new
-          out_str << "Base: #{printable[:base]}"
-          out_str << ", Code: #{printable[:code]}"
-          out_str << ", Rate (%): #{printable[:rate]}"
-          out_str << ", Amount: #{printable[:value]}"
-          out_str.strip
-        end
-
-        # @return [Hash]
-        def printable_values
-          out_h = {}
-          out_h[:code] = @code.nil? ? '' : @code
-          out_h[:base] = @base.nil? ? '' : print_float(@base)
-          out_h[:rate] = @rate.nil? ? '' : print_float(@rate).to_s
-          out_h[:value] = @value.to_s.empty? ? '' : print_float(@value.to_f).to_s
-          out_h
-        end
-
-        # @return [String]
-        def to_table_line
-          printable = printable_values
-          out_str = String.new
-          out_str << "| #{printable[:base].ljust(13, ' ')}"
-          out_str << " | #{printable[:code].ljust(6, ' ')}"
-          out_str << " | #{printable[:rate].ljust(8, ' ')}"
-          out_str << " | #{printable[:value].ljust(13, ' ')} |"
-          out_str.strip
-        end
-      end
-
-      # Represents tax information, grouped as an array.
-      class Taxes < Array
-        # @param prediction [Hash]
-        # @param page_id [Integer, nil]
-        def initialize(prediction, page_id)
-          super(prediction.map { |entry| TaxField.new(entry, page_id) })
-        end
-
-        # @param char [String]
-        # @return [String]
-        def line_separator(char)
-          out_str = String.new
-          out_str << '  '
-          out_str << "+#{char * 15}"
-          out_str << "+#{char * 8}"
-          out_str << "+#{char * 10}"
-          out_str << "+#{char * 15}"
-          out_str << '+'
-          out_str
-        end
-
-        # @return [String]
-        def to_s
-          return '' if nil? || empty?
-
-          out_str = String.new
-          out_str << "\n#{line_separator('-')}"
-          out_str << "\n  | Base          | Code   | Rate (%) | Amount        |"
-          out_str << "\n#{line_separator('=')}"
-          each do |entry|
-            out_str << "\n  #{entry.to_table_line}\n#{line_separator('-')}"
-          end
-          out_str
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/universal/universal_list_field.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'universal_object_field'
-
-module Mindee
-  module Parsing
-    module Universal
-      # A list of values or objects, used in universal APIs.
-      class UniversalListField
-        include Mindee::Parsing::Standard
-        include Mindee::Parsing::Universal
-
-        # ID of the page (as given by the API).
-        # @return [Integer]
-        attr_reader :page_id
-
-        # List of word values
-        # @return [Array<UniversalObjectField, StringField>]
-        attr_reader :values
-
-        # ID of the page the object was found on.
-        # List of word values.
-
-        def initialize(raw_prediction, page_id = nil)
-          @values = [] # : Array[UniversalObjectField | Parsing::Standard::StringField]
-
-          raw_prediction.each do |value|
-            page_id = value['page_id'] if value.key?('page_id') && !value['page_id'].nil?
-
-            if Universal.universal_object?(value)
-              @values.push(Mindee::Parsing::Universal::UniversalObjectField.new(value, page_id))
-            else
-              value_str = value.dup
-              value_str['value'] = value_str['value'].to_s if value_str.key?('value') && !value_str['value'].nil?
-              @values.push(Mindee::Parsing::Standard::StringField.new(value_str, page_id))
-            end
-          end
-        end
-
-        # Return an Array of the contents of all values.
-        # @return [Array<String>]
-        def contents_list
-          @values.map(&:to_s)
-        end
-
-        # Return a string representation of all values.
-        def contents_string(separator = ' ')
-          @values.map(&:to_s).join(separator)
-        end
-
-        # String representation
-        def to_s
-          contents_string
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/universal/universal_object_field.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../common'
-
-module Mindee
-  module Parsing
-    # Universal fields and functions.
-    module Universal
-      # A JSON-like object, with miscellaneous values.
-      class UniversalObjectField
-        # ID of the page (as given by the API).
-        # @return [Integer]
-        attr_reader :page_id
-        # The confidence score, value will be between 0.0 and 1.0
-        # @return [Float]
-        attr_reader :confidence
-        # Value as String
-        # @return [String]
-        attr_reader :raw_value
-        # All values
-        # @return [Hash]
-        attr_reader :all_values
-
-        # ID of the page the object was found on.
-        # Confidence with which the value was assessed.
-        # Raw unprocessed value, as it was sent by the server.
-
-        def initialize(raw_prediction, page_id = nil)
-          @all_values = {} # : Hash[String | Symbol, untyped]
-          item_page_id = nil
-          raw_prediction.each do |name, value|
-            case name
-            when 'page_id'
-              item_page_id = value
-            when 'polygon', 'rectangle', 'quadrangle', 'bounding_box'
-              handle_position_field(name, value, item_page_id)
-            when 'confidence'
-              @confidence = value
-            when 'raw_value'
-              @raw_value = value
-            else
-              handle_default_field(name, value)
-            end
-            @page_id = page_id || item_page_id
-          end
-        end
-
-        # String representation that takes into account the level of indentation.
-        def str_level(level = 0)
-          indent = "  #{'  ' * level}"
-          out_str = ''
-          @all_values.each do |attr, value|
-            str_value = value.nil? ? '' : value.to_s
-            out_str += "\n#{indent}:#{attr}: #{str_value}".rstrip
-          end
-          "\n#{indent}#{out_str.strip}"
-        end
-
-        # Necessary overload of the method_missing method to allow for direct access to dynamic attributes without
-        # changing the user usage too much.
-        # Returns the corresponding attribute when asked.
-        #
-        # Otherwise, raises a NoMethodError.
-        #
-        # @param method_name [Symbol] The name of the method being called.
-        # @param _args [Array] Arguments passed to the method.
-        # @return [Object] The value associated with the method name in @all_values.
-        def method_missing(method_name, *_args)
-          super unless @all_values.key?(method_name.to_s)
-          @all_values[method_name.to_s]
-        end
-
-        # Necessary overload of the respond_to_missing? method to allow for direct access to dynamic attributes without
-        # changing the user usage too much.
-        # Returns true if the method name exists as a key in @all_values,
-        # indicating that the object can respond to the method.
-        # Otherwise, calls super to fallback to the default behavior.
-        #
-        # @param method_name [Symbol] The name of the method being checked.
-        # @param include_private [bool] Whether to include private methods in the check.
-        # @return [bool] `true` if the method can be responded to, false otherwise.
-        def respond_to_missing?(method_name, include_private = false)
-          @all_values.key?(method_name.to_s) || super
-        end
-
-        # String representation
-        def to_s
-          str_level
-        end
-
-        private
-
-        def handle_position_field(name, value, item_page_id)
-          @all_values[name.to_s] =
-            Mindee::Parsing::Standard::PositionField.new(
-              { name.to_s => value }, item_page_id
-            )
-        end
-
-        def handle_default_field(name, value)
-          @all_values[name] = value&.to_s
-        end
-      end
-
-      def self.universal_object?(str_dict)
-        common_keys = [
-          'value',
-          'polygon',
-          'rectangle',
-          'page_id',
-          'confidence',
-          'quadrangle',
-          'values',
-          'raw_value',
-        ]
-        str_dict.each_key { |key| return true unless common_keys.include?(key.to_s) }
-        false
-      end
-    end
-  end
-end

data/lib/mindee/parsing/v2/inference.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'inference_job'
-require_relative 'inference_model'
-require_relative 'inference_file'
-require_relative 'inference_result'
-require_relative 'inference_active_options'
-require_relative '../../v2/parsing/base_inference'
-
-module Mindee
-  module Parsing
-    module V2
-      # Complete data returned by an inference request.
-      class Inference < Mindee::V2::Parsing::BaseInference
-        # @return [InferenceActiveOptions] Options which were activated during the inference.
-        attr_reader :active_options
-        # @return [InferenceResult] Result contents.
-        attr_reader :result
-
-        @params_type = Input::InferenceParameters
-        @slug = 'extraction'
-        @response_type = InferenceResponse
-
-        # @param server_response [Hash] Hash representation of the JSON returned by the service.
-        def initialize(server_response)
-          super
-          @active_options = InferenceActiveOptions.new(server_response['active_options'])
-          @result = InferenceResult.new(server_response['result'])
-        end
-
-        # String representation.
-        # @return [String]
-        def to_s
-          [
-            super,
-            @active_options.to_s,
-            @result.to_s,
-            '',
-          ].join("\n")
-        end
-      end
-    end
-  end
-end