mindee 1.2.0 → 2.0.0

data/lib/mindee/parsing/prediction/common_fields/position.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Mindee
+  # 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)
+      @polygon = Geometry.polygon_from_prediction(prediction['polygon']) unless prediction['polygon'].empty?
+      @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
+
+    def to_s
+      out_str = String.new
+      out_str << "Polygon with #{@polygon.size} points."
+    end
+
+    private
+
+    def to_quadrilateral(prediction, key)
+      Geometry.quadrilateral_from_prediction(prediction[key]) unless prediction[key].empty?
+    end
+  end
+end

data/lib/mindee/{fields → parsing/prediction/common_fields}/tax.rb

@@ -24,10 +24,15 @@ module Mindee
       @code = prediction['code'] unless prediction['code'] == 'None'
     end
 
+    # @param value [Float]
+    def print_float(value)
+      format('%.2f', value)
+    end
+
     def to_s
       out_str = String.new
-      out_str << "#{@value} " if @value
-      out_str << "#{@rate}% " if @rate
+      out_str << "#{print_float(@value)} " if @value
+      out_str << "#{print_float(@rate)}% " if @rate
       out_str << "#{@code} " if @code
       out_str.strip
     end

data/lib/mindee/parsing/prediction/common_fields/text.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Mindee
+  # Represents tax information.
+  class TextField < Field
+    # Amount value as 3 decimal float
+    # @return [String, nil]
+    attr_reader :value
+  end
+end

data/lib/mindee/parsing/prediction/common_fields.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'common_fields/amount'
+require_relative 'common_fields/base'
+require_relative 'common_fields/company_registration'
+require_relative 'common_fields/date'
+require_relative 'common_fields/locale'
+require_relative 'common_fields/payment_details'
+require_relative 'common_fields/position'
+require_relative 'common_fields/tax'
+require_relative 'common_fields/text'

data/lib/mindee/parsing/prediction/custom/custom_v1.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'fields'
+require_relative '../base'
+
+module Mindee
+  module Prediction
+    # Custom document object.
+    class CustomV1 < Prediction
+      # All value fields in the document
+      # @return [Hash<Symbol, Mindee::ListField>]
+      attr_reader :fields
+      # All classifications in the document
+      # @return [Hash<Symbol, Mindee::ClassificationField>]
+      attr_reader :classifications
+
+      # @param prediction [Hash]
+      # @param page_id [Integer, nil]
+      def initialize(prediction, page_id)
+        super
+        @fields = {}
+        @classifications = {}
+        prediction.each do |field_name, field_prediction|
+          field_sym = field_name.to_sym
+          set_field(field_sym, field_prediction, page_id)
+        end
+      end
+
+      def to_s
+        out_str = String.new
+        @classifications.each do |name, info|
+          out_str << "\n:#{name}: #{info}".rstrip
+        end
+        @fields.each do |name, info|
+          out_str << "\n:#{name}: #{info}".rstrip
+        end
+        out_str[1..].to_s
+      end
+
+      private
+
+      # @param field_prediction [Hash]
+      def set_field(field_sym, field_prediction, page_id)
+        # Currently two types of fields possible in a custom API response:
+        # fields having a list of values, and classification fields.
+        # Here we use the fact that only value lists have the 'values' attribute.
+
+        if field_prediction.key? 'values'
+          @fields[field_sym] = ListField.new(field_prediction, page_id)
+        elsif field_prediction.key? 'value'
+          @classifications[field_sym] = ClassificationField.new(field_prediction)
+        else
+          throw 'Unknown API field type'
+        end
+      end
+    end
+  end
+end

data/lib/mindee/{fields/custom_docs.rb → parsing/prediction/custom/fields.rb}

@@ -26,9 +26,9 @@ module Mindee
     # The confidence score, value will be between 0.0 and 1.0
     # @return [Float]
     attr_accessor :confidence
-    # @return [Array<Array<Float>>]
-    attr_reader :bbox
-    # @return [Array<Array<Float>>]
+    # @return [Mindee::Geometry::Quadrilateral]
+    attr_reader :bounding_box
+    # @return [Mindee::Geometry::Polygon]
     attr_reader :polygon
     attr_reader :content
 
@@ -36,8 +36,8 @@ module Mindee
     def initialize(prediction)
       @content = prediction['content']
       @confidence = prediction['confidence']
-      @polygon = prediction['polygon']
-      @bbox = Geometry.get_bbox_as_polygon(@polygon) unless @polygon.nil? || @polygon.empty?
+      @polygon = Geometry.polygon_from_prediction(prediction['polygon'])
+      @bounding_box = Geometry.get_bounding_box(@polygon) unless @polygon.nil? || @polygon.empty?
     end
 
     # @return [String]

data/lib/mindee/parsing/prediction/eu/license_plate/license_plate_v1.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../../common_fields'
+require_relative '../../base'
+
+module Mindee
+  module Prediction
+    module EU
+      # License plate prediction.
+      class LicensePlateV1 < Prediction
+        # A list of license plates.
+        # @return [Array<Mindee::TextField>]
+        attr_reader :license_plates
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          super
+          @license_plates = []
+          prediction['license_plates'].each do |item|
+            @license_plates.push(TextField.new(item, page_id))
+          end
+        end
+
+        def to_s
+          license_plates = @license_plates.map(&:value).join(', ')
+          out_str = String.new
+          out_str << "\n:License plates: #{license_plates}".rstrip
+          out_str[1..].to_s
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/prediction/fr/bank_account_details/bank_account_details_v1.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../../common_fields'
+require_relative '../../base'
+
+module Mindee
+  module Prediction
+    module FR
+      # French bank account information (RIB)
+      class BankAccountDetailsV1 < Prediction
+        # The account's IBAN.
+        # @return [Mindee::TextField]
+        attr_reader :iban
+        # The account holder's name.
+        # @return [Mindee::TextField]
+        attr_reader :account_holder_name
+        # The bank's SWIFT code.
+        # @return [Mindee::TextField]
+        attr_reader :swift
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          super
+          @iban = TextField.new(prediction['iban'], page_id)
+          @account_holder_name = TextField.new(prediction['account_holder_name'], page_id)
+          @swift = TextField.new(prediction['swift'], page_id)
+        end
+
+        def to_s
+          out_str = String.new
+          out_str << "\n:IBAN: #{@iban}".rstrip
+          out_str << "\n:Account holder name: #{@account_holder_name}".rstrip
+          out_str << "\n:SWIFT: #{@swift}".rstrip
+          out_str[1..].to_s
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/prediction/fr/carte_vitale/carte_vitale_v1.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../../common_fields'
+require_relative '../../base'
+
+module Mindee
+  module Prediction
+    module FR
+      # French Carte Vitale
+      class CarteVitaleV1 < Prediction
+        # List of given (first) names of the cardholder.
+        # @return [Array<Mindee::TextField>]
+        attr_reader :given_names
+        # The surname (last name) of the cardholder.
+        # @return [Mindee::TextField]
+        attr_reader :surname
+        # The social security number of the cardholder.
+        # @return [Mindee::TextField]
+        attr_reader :social_security
+        # The issuance date of the card.
+        # @return [Mindee::DateField]
+        attr_reader :issuance_date
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          super
+          @given_names = []
+          prediction['given_names'].each do |item|
+            @given_names.push(TextField.new(item, page_id))
+          end
+          @surname = TextField.new(prediction['surname'], page_id)
+          @social_security = TextField.new(prediction['social_security'], page_id)
+          @issuance_date = DateField.new(prediction['issuance_date'], page_id)
+        end
+
+        def to_s
+          given_names = @given_names.map(&:value).join(', ')
+          out_str = String.new
+          out_str << "\n:Given names: #{given_names}".rstrip
+          out_str << "\n:Surname: #{@surname}".rstrip
+          out_str << "\n:Social Security Number: #{@social_security}".rstrip
+          out_str << "\n:Issuance date: #{@issuance_date}".rstrip
+          out_str[1..].to_s
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/prediction/fr/id_card/id_card_v1.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative '../../common_fields'
+require_relative '../../base'
+
+module Mindee
+  module Prediction
+    module FR
+      # French national ID card
+      class IdCardV1 < Prediction
+        # The authority which has issued the card.
+        # @return [Array<Mindee::TextField>]
+        attr_reader :authority
+        # Indicates if it is the recto side, the verso side or both.
+        # @return [Mindee::TextField]
+        attr_reader :document_side
+        # The card number.
+        # @return [Mindee::TextField]
+        attr_reader :id_number
+        # The expiration date of the card.
+        # @return [Mindee::DateField]
+        attr_reader :expiry_date
+        # The surname (last name) of the cardholder.
+        # @return [Mindee::TextField]
+        attr_reader :surname
+        # List of first (given) names of the cardholder.
+        # @return [Mindee::TextField]
+        attr_reader :given_names
+        # The date of birth of the cardholder.
+        # @return [Mindee::DateField]
+        attr_reader :birth_date
+        # The place of birth of the cardholder.
+        # @return [Mindee::TextField]
+        attr_reader :birth_place
+        # The sex or gender of the cardholder.
+        # @return [Mindee::TextField]
+        attr_reader :gender
+        # The value of the first MRZ line.
+        # @return [Mindee::TextField]
+        attr_reader :mrz1
+        # The value of the second MRZ line.
+        # @return [Mindee::TextField]
+        attr_reader :mrz2
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          super
+          @document_side = TextField.new(prediction['document_side'], page_id) if page_id
+          @authority = TextField.new(prediction['authority'], page_id)
+          @id_number = TextField.new(prediction['id_number'], page_id)
+          @birth_date = DateField.new(prediction['birth_date'], page_id)
+          @expiry_date = DateField.new(prediction['expiry_date'], page_id)
+          @birth_place = TextField.new(prediction['birth_place'], page_id)
+          @gender = TextField.new(prediction['gender'], page_id)
+          @surname = TextField.new(prediction['surname'], page_id)
+          @mrz1 = TextField.new(prediction['mrz1'], page_id)
+          @mrz2 = TextField.new(prediction['mrz2'], page_id)
+          @given_names = []
+          prediction['given_names'].each do |item|
+            @given_names.push(TextField.new(item, page_id))
+          end
+        end
+
+        def to_s
+          given_names = @given_names.map(&:value).join(', ')
+          out_str = String.new
+          out_str << "\n:Document side: #{@document_side}".rstrip if @document_side
+          out_str << "\n:Authority: #{@authority}".rstrip
+          out_str << "\n:Given names: #{given_names}".rstrip
+          out_str << "\n:Surname: #{@surname}".rstrip
+          out_str << "\n:Gender: #{@gender}".rstrip
+          out_str << "\n:ID Number: #{@id_number}".rstrip
+          out_str << "\n:Birth date: #{@birth_date}".rstrip
+          out_str << "\n:Birth place: #{@birth_place}".rstrip
+          out_str << "\n:Expiry date: #{@expiry_date}".rstrip
+          out_str << "\n:MRZ 1: #{@mrz1}".rstrip
+          out_str << "\n:MRZ 2: #{@mrz2}".rstrip
+          out_str[1..].to_s
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/prediction/invoice/invoice_line_item.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../common_fields/base'
+
+module Mindee
+  # Line items for invoices
+  class InvoiceLineItem
+    # @return [String] The product code referring to the item.
+    attr_reader :product_code
+    # @return [String]
+    attr_reader :description
+    # @return [Float]
+    attr_reader :quantity
+    # @return [Float]
+    attr_reader :unit_price
+    # @return [Float]
+    attr_reader :total_amount
+    # @return [Float] The item tax rate percentage.
+    attr_reader :tax_rate
+    # @return [Float]
+    attr_reader :tax_amount
+    # @return [Float]
+    attr_reader :confidence
+    # @return [Integer]
+    attr_reader :page_id
+    # @return [Mindee::Geometry::Quadrilateral]
+    attr_reader :bounding_box
+    # @return [Array<Mindee::Geometry::Polygon>]
+    attr_reader :polygon
+
+    def initialize(prediction, page_id)
+      @product_code = prediction['product_code']
+      @quantity = prediction['quantity']
+      @unit_price = prediction['unit_price']
+      @total_amount = prediction['total_amount']
+      @tax_amount = prediction['tax_amount']
+      @tax_rate = prediction['tax_rate']
+      @description = prediction['description']
+      @page_id = page_id
+    end
+
+    def to_s
+      tax = Field.float_to_string(@tax_amount)
+      tax << " (#{Field.float_to_string(@tax_rate)}%)" unless @tax_rate.nil?
+
+      description = @description.nil? ? '' : @description
+      description = "#{description[0..32]}..." if description.size > 35
+
+      out_str = String.new
+      out_str << format('%- 22s', @product_code)
+      out_str << " #{format('%- 8s', Field.float_to_string(@quantity))}"
+      out_str << " #{format('%- 9s', Field.float_to_string(@unit_price))}"
+      out_str << " #{format('%- 10s', Field.float_to_string(@total_amount))}"
+      out_str << " #{format('%- 18s', tax)}"
+      out_str << " #{description}"
+    end
+  end
+end

data/lib/mindee/parsing/prediction/invoice/invoice_v4.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require_relative '../common_fields'
+require_relative 'invoice_line_item'
+require_relative '../base'
+
+module Mindee
+  module Prediction
+    # Invoice document.
+    class InvoiceV4 < Prediction
+      # Locale information.
+      # @return [Mindee::Locale]
+      attr_reader :locale
+      # The nature of the invoice.
+      # @return [Mindee::TextField]
+      attr_reader :document_type
+      # The total amount with tax included.
+      # @return [Mindee::AmountField]
+      attr_reader :total_amount
+      # The total amount without the tax value.
+      # @return [Mindee::AmountField]
+      attr_reader :total_net
+      # The total tax.
+      # @return [Mindee::AmountField]
+      attr_reader :total_tax
+      # The creation date of the invoice.
+      # @return [Mindee::DateField]
+      attr_reader :date
+      # The invoice number.
+      # @return [Mindee::TextField]
+      attr_reader :invoice_number
+      # List of Reference numbers including PO number.
+      # @return [Mindee::TextField]
+      attr_reader :reference_numbers
+      # The due date of the invoice.
+      # @return [Mindee::DateField]
+      attr_reader :due_date
+      # The list of taxes.
+      # @return [Array<Mindee::TaxField>]
+      attr_reader :taxes
+      # The name of the customer.
+      # @return [Mindee::TextField]
+      attr_reader :customer_name
+      # The address of the customer.
+      # @return [Mindee::TextField]
+      attr_reader :customer_address
+      # The company registration information for the customer.
+      # @return [Array<Mindee::CompanyRegistration>]
+      attr_reader :customer_company_registrations
+      # The supplier's name.
+      # @return [Mindee::TextField]
+      attr_reader :supplier_name
+      # The supplier's address.
+      # @return [Mindee::TextField]
+      attr_reader :supplier_address
+      # The payment information.
+      # @return [Array<Mindee::PaymentDetails>]
+      attr_reader :supplier_payment_details
+      # The supplier's company registration information.
+      # @return [Array<Mindee::CompanyRegistration>]
+      attr_reader :supplier_company_registrations
+      # Line items details.
+      # @return [Array<Mindee::InvoiceLineItem>]
+      attr_reader :line_items
+
+      # @param prediction [Hash]
+      # @param page_id [Integer, nil]
+      def initialize(prediction, page_id)
+        super
+        @locale = Locale.new(prediction['locale'])
+        @document_type = TextField.new(prediction['document_type'], page_id)
+        @total_amount = AmountField.new(prediction['total_amount'], page_id)
+        @total_net = AmountField.new(prediction['total_net'], page_id)
+        @customer_address = TextField.new(prediction['customer_address'], page_id)
+        @customer_name = TextField.new(prediction['customer_name'], page_id)
+        @date = DateField.new(prediction['date'], page_id)
+        @due_date = DateField.new(prediction['due_date'], page_id)
+        @invoice_number = TextField.new(prediction['invoice_number'], page_id)
+        @supplier_name = TextField.new(prediction['supplier_name'], page_id)
+        @supplier_address = TextField.new(prediction['supplier_address'], page_id)
+
+        @reference_numbers = []
+        prediction['reference_numbers'].each do |item|
+          @reference_numbers.push(TextField.new(item, page_id))
+        end
+        @customer_company_registrations = []
+        prediction['customer_company_registrations'].each do |item|
+          @customer_company_registrations.push(CompanyRegistration.new(item, page_id))
+        end
+        @taxes = []
+        prediction['taxes'].each do |item|
+          @taxes.push(TaxField.new(item, page_id))
+        end
+        @supplier_payment_details = []
+        prediction['supplier_payment_details'].each do |item|
+          @supplier_payment_details.push(PaymentDetails.new(item, page_id))
+        end
+        @supplier_company_registrations = []
+        prediction['supplier_company_registrations'].each do |item|
+          @supplier_company_registrations.push(CompanyRegistration.new(item, page_id))
+        end
+
+        @total_tax = AmountField.new(
+          { value: nil, confidence: 0.0 }, page_id
+        )
+
+        @line_items = []
+        prediction['line_items'].each do |item|
+          @line_items.push(InvoiceLineItem.new(item, page_id))
+        end
+        reconstruct(page_id)
+      end
+
+      def to_s
+        customer_company_registrations = @customer_company_registrations.map(&:value).join('; ')
+        supplier_payment_details = @supplier_payment_details.map(&:to_s).join("\n                 ")
+        supplier_company_registrations = @supplier_company_registrations.map(&:to_s).join('; ')
+        reference_numbers = @reference_numbers.map(&:to_s).join(', ')
+        taxes = @taxes.join("\n       ")
+        out_str = String.new
+        out_str << "\n:Locale: #{@locale}".rstrip
+        out_str << "\n:Document type: #{@document_type}".rstrip
+        out_str << "\n:Invoice number: #{@invoice_number}".rstrip
+        out_str << "\n:Reference numbers: #{reference_numbers}".rstrip
+        out_str << "\n:Invoice date: #{@date}".rstrip
+        out_str << "\n:Invoice due date: #{@due_date}".rstrip
+
+        out_str << "\n:Supplier name: #{@supplier_name}".rstrip
+        out_str << "\n:Supplier address: #{@supplier_address}".rstrip
+        out_str << "\n:Supplier company registrations: #{supplier_company_registrations}".rstrip
+        out_str << "\n:Supplier payment details: #{supplier_payment_details}".rstrip
+
+        out_str << "\n:Customer name: #{@customer_name}".rstrip
+        out_str << "\n:Customer address: #{@customer_address}".rstrip
+        out_str << "\n:Customer company registrations: #{customer_company_registrations}".rstrip
+
+        out_str << "\n:Taxes: #{taxes}".rstrip
+        out_str << "\n:Total net: #{@total_net}".rstrip
+        out_str << "\n:Total taxes: #{@total_tax}".rstrip
+        out_str << "\n:Total amount: #{@total_amount}".rstrip
+        out_str << line_items_to_s
+
+        out_str[1..].to_s
+      end
+
+      private
+
+      def line_items_to_s
+        return '' if @line_items.empty?
+
+        line_item_separator = "#{'=' * 22} #{'=' * 8} #{'=' * 9} #{'=' * 10} #{'=' * 18} #{'=' * 36}"
+        line_items = @line_items.map(&:to_s).join("\n")
+        out_str = String.new
+        out_str << "\n\n:Line Items:"
+        out_str << "\n#{line_item_separator}"
+        out_str << "\nCode                   QTY      Price     Amount     Tax (Rate)         Description"
+        out_str << "\n#{line_item_separator}"
+        out_str << "\n#{line_items}"
+        out_str << "\n#{line_item_separator}" unless line_items.empty?
+      end
+
+      def reconstruct(page_id)
+        construct_total_tax_from_taxes(page_id)
+        return unless page_id.nil?
+
+        construct_total_excl_from_tcc_and_taxes(page_id)
+        construct_total_incl_from_taxes_plus_excl(page_id)
+        construct_total_tax_from_totals(page_id)
+      end
+
+      def construct_total_excl_from_tcc_and_taxes(page_id)
+        return if @total_amount.value.nil? || taxes.empty? || !@total_net.value.nil?
+
+        total_excl = {
+          'value' => @total_amount.value - @taxes.map(&:value).sum,
+          'confidence' => TextField.array_confidence(@taxes) * @total_amount.confidence,
+        }
+        @total_net = AmountField.new(total_excl, page_id, reconstructed: true)
+      end
+
+      def construct_total_incl_from_taxes_plus_excl(page_id)
+        return if @total_net.value.nil? || @taxes.empty? || !@total_amount.value.nil?
+
+        total_incl = {
+          'value' => @taxes.map(&:value).sum + @total_net.value,
+          'confidence' => TextField.array_confidence(@taxes) * @total_net.confidence,
+        }
+        @total_amount = AmountField.new(total_incl, page_id, reconstructed: true)
+      end
+
+      def construct_total_tax_from_taxes(page_id)
+        return if @taxes.empty?
+
+        total_tax = {
+          'value' => @taxes.map(&:value).sum,
+          'confidence' => TextField.array_confidence(@taxes),
+        }
+        return unless total_tax['value'].positive?
+
+        @total_tax = AmountField.new(total_tax, page_id, reconstructed: true)
+      end
+
+      def construct_total_tax_from_totals(page_id)
+        return if !@total_tax.value.nil? || @total_amount.value.nil? || @total_net.value.nil?
+
+        total_tax = {
+          'value' => @total_amount.value - @total_net.value,
+          'confidence' => TextField.array_confidence(@taxes),
+        }
+        return unless total_tax['value'] >= 0
+
+        @total_tax = AmountField.new(total_tax, page_id, reconstructed: true)
+      end
+    end
+  end
+end