mindee 4.12.0 → 5.0.0.beta1

data/lib/mindee/v1/parsing/standard/abstract_field.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../../../geometry'
+
+module Mindee
+  module V1
+    module Parsing
+      module Standard
+        # Base BaseField object, upon which fields and feature fields are built
+        class AbstractField
+          # @return [Mindee::Geometry::Quadrilateral, nil]
+          attr_reader :bounding_box
+          # @return [Mindee::Geometry::Polygon, nil]
+          attr_reader :polygon
+          # @return [Integer, nil]
+          attr_reader :page_id
+          # The confidence score, value will be between 0.0 and 1.0
+          # @return [Float, nil]
+          attr_accessor :confidence
+
+          # @param prediction [Hash]
+          # @param page_id [Integer, nil]
+          def initialize(prediction, page_id)
+            @confidence = prediction['confidence'] if prediction.key?('confidence')
+            @polygon = Mindee::Geometry::Polygon.new(prediction['polygon']) if prediction.key?('polygon')
+            @bounding_box = Geometry.get_bounding_box(@polygon) unless @polygon.nil? || @polygon.empty?
+            @page_id = page_id || prediction['page_id']
+          end
+
+          # @return [String]
+          def to_s
+            @value ? @value.to_s : ''
+          end
+
+          # Multiply all the Mindee::V1::Parsing::Standard::BaseField confidences in the array.
+          # @return [Float]
+          def self.array_confidence(field_array)
+            product = 1
+            field_array.each do |field|
+              return 0.0 if field.confidence.nil?
+
+              product *= field.confidence
+            end
+            product.to_f
+          end
+
+          # Add all the Mindee::V1::Parsing::Standard::BaseField values in the array.
+          # @return [Float]
+          def self.array_sum(field_array)
+            arr_sum = 0
+            field_array.each do |field|
+              return 0.0 if field.value.nil?
+
+              arr_sum += field.value
+            end
+            arr_sum.to_f
+          end
+
+          # @param value [Float]
+          # @param min_precision [Integer]
+          # @return [String]
+          def self.float_to_string(value, min_precision = 2)
+            return String.new if value.nil?
+
+            precision = value.to_f.to_s.split('.')[1].size
+            precision = [precision, min_precision].max
+            format_string = "%.#{precision}f"
+            format(format_string, value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/parsing/standard/address_field.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'string_field'
+
+module Mindee
+  module V1
+    module Parsing
+      module Standard
+        # Represents physical-address information.
+        class AddressField < Mindee::V1::Parsing::Standard::StringField
+          # Street number
+          # @return [String, nil]
+          attr_reader :street_number
+          # Street name
+          # @return [String, nil]
+          attr_reader :street_name
+          # PO Box number
+          # @return [String, nil]
+          attr_reader :po_box
+          # Address complement
+          # @return [String, nil]
+          attr_reader :address_complement
+          #  City name.
+          # @return [String, nil]
+          attr_reader :city
+          # Postal or ZIP code.
+          # @return [String, nil]
+          attr_reader :postal_code
+          # State, province or region.
+          # @return [String, nil]
+          attr_reader :state
+          # Country.
+          # @return [String, nil]
+          attr_reader :country
+
+          def initialize(prediction, page_id = nil, reconstructed: false)
+            super
+            @street_number = prediction['street_number']
+            @street_name = prediction['street_name']
+            @po_box = prediction['po_box']
+            @address_complement = prediction['address_complement']
+            @city = prediction['city']
+            @postal_code = prediction['postal_code']
+            @state = prediction['state']
+            @country = prediction['country']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/parsing/standard/amount_field.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'base_field'
+
+module Mindee
+  module V1
+    module Parsing
+      module Standard
+        # Represents tax information.
+        class AmountField < BaseField
+          # Amount value as 3 decimal float
+          # @return [Float, nil]
+          attr_reader :value
+
+          def initialize(prediction, page_id, reconstructed: false)
+            super
+            @value = @value.to_f.round(3).to_f unless @value.to_s.empty?
+          end
+
+          # @return [String]
+          def to_s
+            @value.nil? ? '' : BaseField.float_to_string(@value.to_f)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../../../geometry'
+require_relative 'abstract_field'
+
+module Mindee
+  module V1
+    module Parsing
+      module Standard
+        # Base field object.
+        class BaseField < Mindee::V1::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
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'base_field'
+
+module Mindee
+  module V1
+    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
+end

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

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

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V1
+    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 = {} # @type var printable: Hash[Symbol, String]
+            printable[:type] = type
+            printable[:value] = value.to_s
+            printable
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'date'
+
+require_relative 'base_field'
+
+module Mindee
+  module V1
+    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
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V1
+    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
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V1
+    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
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'base_field'
+
+module Mindee
+  module V1
+    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
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V1
+    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
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'base_field'
+
+module Mindee
+  module V1
+    module Parsing
+      module Standard
+        # Represents basic text information.
+        class StringField < Mindee::V1::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
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative 'base_field'
+
+module Mindee
+  module V1
+    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 = {} # @type var out_h: Hash[Symbol, String]
+            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
+end