mindee 1.2.0 → 2.1.0

data/lib/mindee/parsing/inference.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'page'
+
+module Mindee
+  # Product information
+  class Product
+    attr_reader :name, :type, :version
+
+    # @param http_response [Hash]
+    def initialize(http_response)
+      @name = http_response['name']
+      @type = http_response['type']
+      @version = http_response['version']
+    end
+  end
+
+  # Inference holds all predictions
+  class Inference
+    # @return [Boolean]
+    attr_reader :is_rotation_applied
+    # @return [Array<Mindee::Page>]
+    attr_reader :pages
+    # @return [Mindee::Prediction]
+    attr_reader :prediction
+    # @return [Mindee::Product]
+    attr_reader :product
+
+    # @param prediction_class [Class<Mindee::Prediction::Prediction>]
+    # @param http_response [Hash]
+    def initialize(prediction_class, http_response)
+      @is_rotation_applied = http_response['is_rotation_applied']
+      @prediction = prediction_class.new(http_response['prediction'], nil)
+      @product = Product.new(http_response['product'])
+      @pages = []
+      http_response['pages'].each do |page|
+        @pages.push(Page.new(prediction_class, page))
+      end
+    end
+
+    def to_s
+      is_rotation_applied = @is_rotation_applied ? 'Yes' : 'No'
+      out_str = String.new
+      out_str << "Inference\n#########"
+      out_str << "\n:Product: #{@product.name} v#{@product.version}"
+      out_str << "\n:Rotation applied: #{is_rotation_applied}"
+      out_str << "\n\nPrediction\n=========="
+      out_str << "\n#{@prediction}"
+      out_str << "\n\nPage Predictions\n================\n\n"
+      out_str << @pages.map(&:to_s).join("\n\n")
+    end
+  end
+end

data/lib/mindee/parsing/page.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mindee
+  # Page orientation
+  class Orientation
+    # @return [Integer]
+    attr_reader :page_id
+    # A prediction among these 3 possible outputs:
+    #   * 0 degrees: the page is already upright
+    #   * 90 degrees: the page must be rotated clockwise to be upright
+    #   * 270 degrees: the page must be rotated counterclockwise to be upright
+    # @return [Integer, nil]
+    attr_reader :value
+
+    # @param prediction [Hash]
+    # @param page_id [Integer]
+    def initialize(prediction, page_id)
+      @value = prediction['value']
+      @page_id = page_id
+    end
+  end
+
+  # Page object
+  class Page
+    # @return [Integer]
+    attr_reader :id
+    # @return [Mindee::Prediction]
+    attr_reader :prediction
+    # @return [Mindee::Orientation]
+    attr_reader :orientation
+
+    def initialize(prediction_class, page)
+      @id = page['id'].to_i
+      @prediction = prediction_class.new(page['prediction'], @id)
+      @orientation = Orientation.new(page['orientation'], @id)
+    end
+
+    def to_s
+      out_str = String.new
+      title = "Page #{@id}"
+      out_str << "#{title}\n"
+      out_str << ('-' * title.size)
+      out_str << "\n#{@prediction}"
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Prediction
+    # Base document object.
+    class Prediction
+      # document type
+      # @return [String]
+      attr_reader :document_type
+      # Validation checks for the document
+      # @return [Hash<Symbol, Boolean>]
+      attr_reader :checklist
+      # Original filename of the document
+      # @return [String, nil]
+      attr_reader :filename
+      # Detected MIME type of the document
+      # @return [String, nil]
+      attr_reader :file_mimetype
+
+      def initialize(_prediction, _page_id)
+        @checklist = {}
+      end
+
+      # @return [Boolean]
+      def all_checks
+        @checklist.all? { |_, value| value == true }
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ require_relative 'base'
 
 module Mindee
   # Represents tax information.
-  class Amount < Field
+  class AmountField < Field
     # Amount value as 3 decimal float
     # @return [Float, nil]
     attr_reader :value
@@ -13,5 +13,9 @@ module Mindee
       super
       @value = @value.round(3) unless @value.nil?
     end
+
+    def to_s
+      Field.float_to_string(@value)
+    end
   end
 end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../geometry'
+require_relative '../../../geometry'
 
 module Mindee
   # Base field object.
@@ -8,8 +8,8 @@ module Mindee
     # @return [String, Float, Integer, Boolean]
     attr_reader :value
     # @return [Array<Array<Float>>]
-    attr_reader :bbox
-    # @return [Array<Array<Float>>]
+    attr_reader :bounding_box
+    # @return [Mindee::Geometry::Polygon]
     attr_reader :polygon
     # @return [Integer, nil]
     attr_reader :page_id
@@ -26,8 +26,8 @@ module Mindee
     def initialize(prediction, page_id, reconstructed: false)
       @value = prediction['value']
       @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?
       @page_id = page_id || prediction['page_id']
       @reconstructed = reconstructed
     end
@@ -57,5 +57,16 @@ module Mindee
       end
       arr_sum.to_f
     end
+
+    # @param value [Float]
+    # @param min_precision [Integer]
+    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

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/financial_document/financial_document_v1.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require_relative '../common_fields'
+require_relative '../base'
+require_relative 'invoice_line_item'
+
+module Mindee
+  module Prediction
+    # Invoice document.
+    class FinancialDocumentV1 < 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
+      # Time as seen on the receipt in HH:MM format.
+      # @return [Mindee::TextField]
+      attr_reader :time
+      # The receipt category among predefined classes.
+      # @return [Mindee::TextField]
+      attr_reader :category
+      # The receipt sub-category among predefined classes.
+      # @return [Mindee::TextField]
+      attr_reader :subcategory
+      # A classification field, that can return 4 values : 'EXPENSE RECEIPT' ,
+      # 'CREDIT CARD RECEIPT', 'INVOICE', 'CREDIT NOTE'
+      # @return [Mindee::TextField]
+      attr_reader :document_type # rubocop:todo Lint/DuplicateMethods
+      # Total amount of tip and gratuity. Both typed and handwritten characters are supported.
+      # @return [Mindee::AmountField]
+      attr_reader :tip
+
+      # @param prediction [Hash]
+      # @param page_id [Integer, nil]
+      def initialize(prediction, page_id) # rubocop:todo Metrics/AbcSize
+        super
+
+        @time = TextField.new(prediction['time'], page_id)
+        @category = TextField.new(prediction['category'], page_id)
+        @subcategory = TextField.new(prediction['subcategory'], page_id)
+        @document_type = TextField.new(prediction['document_type'], page_id)
+        @tip = AmountField.new(prediction['tip'], page_id)
+        @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:Document type: #{@document_type}".rstrip
+        out_str << "\n:Category: #{@category}".rstrip
+        out_str << "\n:Subcategory: #{@subcategory}".rstrip
+        out_str << "\n:Locale: #{@locale}".rstrip
+        out_str << "\n:Date: #{@date}".rstrip
+        out_str << "\n:Due date: #{@due_date}".rstrip
+        out_str << "\n:Time: #{@time}".rstrip
+        out_str << "\n:Number: #{@invoice_number}".rstrip
+        out_str << "\n:Reference numbers: #{reference_numbers}".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:Tip: #{@tip}".rstrip
+
+        out_str << "\n:Taxes: #{taxes}".rstrip
+        out_str << "\n:Total taxes: #{@total_tax}".rstrip
+        out_str << "\n:Total net: #{@total_net}".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
+        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:"
+
+        return out_str if line_items.empty?
+
+        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}"
+      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