mindee 3.4.0 → 3.5.0

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

@@ -34,8 +34,10 @@ module Mindee
           out_str << "\n:Rotation applied: #{is_rotation_applied}"
           out_str << "\n\nPrediction\n=========="
           out_str << "\n#{@prediction.to_s.size.positive? ? "#{@prediction}\n" : ''}"
-          out_str << "\nPage Predictions\n================\n\n"
+          out_str << "\nPage Predictions\n================\n\n" unless @pages.empty?
           out_str << @pages.map(&:to_s).join("\n\n")
+          out_str.rstrip!
+          out_str
         end
       end
     end

data/lib/mindee/parsing/generated/generated_list_field.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'generated_object_field'
+
+module Mindee
+  module Parsing
+    module Generated
+      # A list of values or objects, used in generated APIs.
+      class GeneratedListField
+        include Mindee::Parsing::Standard
+        include Mindee::Parsing::Generated
+
+        # Id of the page (as given by the API).
+        # @return [Integer]
+        attr_accessor :page_id
+
+        # List of word values
+        # @return [Array<GeneratedObjectField, StringField>]
+        attr_accessor :values
+
+        # Id of the page the object was found on.
+        # List of word values.
+
+        def initialize(raw_prediction, page_id = nil)
+          @values = []
+
+          raw_prediction.each do |value|
+            page_id = value['page_id'] if value.key?('page_id') && !value['page_id'].nil?
+
+            if Generated.generated_object?(value)
+              @values.push(GeneratedObjectField.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(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/generated/generated_object_field.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative '../common'
+
+module Mindee
+  module Parsing
+    # Generated fields and functions.
+    module Generated
+      # A JSON-like object, with miscellaneous values.
+      class GeneratedObjectField
+        include Mindee::Parsing::Standard
+        attr_accessor :page_id, :confidence, :raw_value
+
+        # 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 = {}
+          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
+        # complicating 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
+        # complicating 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 [Boolean] Whether to include private methods in the check.
+        # @return [Boolean] 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] =
+            PositionField.new({ name.to_s => value }, value_key: name.to_s, page_id: item_page_id)
+        end
+
+        def handle_default_field(name, value)
+          @all_values[name] = value.nil? ? nil : value.to_s
+        end
+      end
+
+      def self.generated_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) }
+        false
+      end
+    end
+  end
+end

data/lib/mindee/parsing/generated.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'generated/generated_object_field'
+require_relative 'generated/generated_list_field'

data/lib/mindee/parsing.rb

@@ -3,3 +3,4 @@
 require_relative 'parsing/standard'
 require_relative 'parsing/custom'
 require_relative 'parsing/common'
+require_relative 'parsing/generated'

data/lib/mindee/product/barcode_reader/barcode_reader_v1.rb

@@ -19,7 +19,9 @@ module Mindee
           @prediction = BarcodeReaderV1Document.new(prediction['prediction'], nil)
           @pages = []
           prediction['pages'].each do |page|
-            @pages.push(BarcodeReaderV1Page.new(page))
+            if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+              @pages.push(BarcodeReaderV1Page.new(page))
+            end
           end
         end
 

data/lib/mindee/product/cropper/cropper_v1.rb

@@ -19,7 +19,9 @@ module Mindee
           @prediction = CropperV1Document.new
           @pages = []
           prediction['pages'].each do |page|
-            @pages.push(CropperV1Page.new(page))
+            if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+              @pages.push(CropperV1Page.new(page))
+            end
           end
         end
 

data/lib/mindee/product/eu/driver_license/driver_license_v1.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../../../parsing'
+require_relative 'driver_license_v1_document'
+require_relative 'driver_license_v1_page'
+
+module Mindee
+  module Product
+    module EU
+      # EU Driver License module.
+      module DriverLicense
+        # EU Driver License V1 prediction inference.
+        class DriverLicenseV1 < Mindee::Parsing::Common::Inference
+          @endpoint_name = 'eu_driver_license'
+          @endpoint_version = '1'
+
+          # @param prediction [Hash]
+          def initialize(prediction)
+            super
+            @prediction = DriverLicenseV1Document.new(prediction['prediction'], nil)
+            @pages = []
+            prediction['pages'].each do |page|
+              if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+                @pages.push(DriverLicenseV1Page.new(page))
+              end
+            end
+          end
+
+          class << self
+            # Name of the endpoint for this product.
+            # @return [String]
+            attr_reader :endpoint_name
+            # Version for this product.
+            # @return [String]
+            attr_reader :endpoint_version
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/eu/driver_license/driver_license_v1_document.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative '../../../parsing'
+
+module Mindee
+  module Product
+    module EU
+      module DriverLicense
+        # EU Driver License V1 document prediction.
+        class DriverLicenseV1Document < Mindee::Parsing::Common::Prediction
+          include Mindee::Parsing::Standard
+          # EU driver license holders address
+          # @return [Mindee::Parsing::Standard::StringField]
+          attr_reader :address
+          # EU driver license holders categories
+          # @return [Mindee::Parsing::Standard::StringField]
+          attr_reader :category
+          # Country code extracted as a string.
+          # @return [Mindee::Parsing::Standard::StringField]
+          attr_reader :country_code
+          # The date of birth of the document holder
+          # @return [Mindee::Parsing::Standard::DateField]
+          attr_reader :date_of_birth
+          # ID number of the Document.
+          # @return [Mindee::Parsing::Standard::StringField]
+          attr_reader :document_id
+          # Date the document expires
+          # @return [Mindee::Parsing::Standard::DateField]
+          attr_reader :expiry_date
+          # First name(s) of the driver license holder
+          # @return [Mindee::Parsing::Standard::StringField]
+          attr_reader :first_name
+          # Authority that issued the document
+          # @return [Mindee::Parsing::Standard::StringField]
+          attr_reader :issue_authority
+          # Date the document was issued
+          # @return [Mindee::Parsing::Standard::DateField]
+          attr_reader :issue_date
+          # Last name of the driver license holder.
+          # @return [Mindee::Parsing::Standard::StringField]
+          attr_reader :last_name
+          # Machine-readable license number
+          # @return [Mindee::Parsing::Standard::StringField]
+          attr_reader :mrz
+          # Place where the driver license holder was born
+          # @return [Mindee::Parsing::Standard::StringField]
+          attr_reader :place_of_birth
+
+          # @param prediction [Hash]
+          # @param page_id [Integer, nil]
+          def initialize(prediction, page_id)
+            super()
+            @address = StringField.new(prediction['address'], page_id)
+            @category = StringField.new(prediction['category'], page_id)
+            @country_code = StringField.new(prediction['country_code'], page_id)
+            @date_of_birth = DateField.new(prediction['date_of_birth'], page_id)
+            @document_id = StringField.new(prediction['document_id'], page_id)
+            @expiry_date = DateField.new(prediction['expiry_date'], page_id)
+            @first_name = StringField.new(prediction['first_name'], page_id)
+            @issue_authority = StringField.new(prediction['issue_authority'], page_id)
+            @issue_date = DateField.new(prediction['issue_date'], page_id)
+            @last_name = StringField.new(prediction['last_name'], page_id)
+            @mrz = StringField.new(prediction['mrz'], page_id)
+            @place_of_birth = StringField.new(prediction['place_of_birth'], page_id)
+          end
+
+          # @return [String]
+          def to_s
+            out_str = String.new
+            out_str << "\n:Country Code: #{@country_code}".rstrip
+            out_str << "\n:Document ID: #{@document_id}".rstrip
+            out_str << "\n:Driver License Category: #{@category}".rstrip
+            out_str << "\n:Last Name: #{@last_name}".rstrip
+            out_str << "\n:First Name: #{@first_name}".rstrip
+            out_str << "\n:Date Of Birth: #{@date_of_birth}".rstrip
+            out_str << "\n:Place Of Birth: #{@place_of_birth}".rstrip
+            out_str << "\n:Expiry Date: #{@expiry_date}".rstrip
+            out_str << "\n:Issue Date: #{@issue_date}".rstrip
+            out_str << "\n:Issue Authority: #{@issue_authority}".rstrip
+            out_str << "\n:MRZ: #{@mrz}".rstrip
+            out_str << "\n:Address: #{@address}".rstrip
+            out_str[1..].to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/eu/driver_license/driver_license_v1_page.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative '../../../parsing'
+require_relative 'driver_license_v1_document'
+
+module Mindee
+  module Product
+    module EU
+      module DriverLicense
+        # EU Driver License V1 page.
+        class DriverLicenseV1Page < Mindee::Parsing::Common::Page
+          # @param prediction [Hash]
+          def initialize(prediction)
+            super(prediction)
+            @prediction = DriverLicenseV1PagePrediction.new(
+              prediction['prediction'],
+              prediction['id']
+            )
+          end
+        end
+
+        # EU Driver License V1 page prediction.
+        class DriverLicenseV1PagePrediction < DriverLicenseV1Document
+          include Mindee::Parsing::Standard
+
+          # Has a photo of the EU driver license holder
+          # @return [Mindee::Parsing::Standard::PositionField]
+          attr_reader :photo
+          # Has a signature of the EU driver license holder
+          # @return [Mindee::Parsing::Standard::PositionField]
+          attr_reader :signature
+
+          # @param prediction [Hash]
+          # @param page_id [Integer, nil]
+          def initialize(prediction, page_id)
+            @photo = PositionField.new(prediction['photo'], page_id)
+            @signature = PositionField.new(prediction['signature'], page_id)
+            super(prediction, page_id)
+          end
+
+          # @return [String]
+          def to_s
+            out_str = String.new
+            out_str << "\n:Photo: #{@photo}".rstrip
+            out_str << "\n:Signature: #{@signature}".rstrip
+            out_str << "\n#{super}"
+            out_str
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/eu/license_plate/license_plate_v1.rb

@@ -20,7 +20,9 @@ module Mindee
             @prediction = LicensePlateV1Document.new(prediction['prediction'], nil)
             @pages = []
             prediction['pages'].each do |page|
-              @pages.push(LicensePlateV1Page.new(page))
+              if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+                @pages.push(LicensePlateV1Page.new(page))
+              end
             end
           end
 

data/lib/mindee/product/financial_document/financial_document_v1.rb

@@ -19,7 +19,9 @@ module Mindee
           @prediction = FinancialDocumentV1Document.new(prediction['prediction'], nil)
           @pages = []
           prediction['pages'].each do |page|
-            @pages.push(FinancialDocumentV1Page.new(page))
+            if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+              @pages.push(FinancialDocumentV1Page.new(page))
+            end
           end
         end
 

data/lib/mindee/product/fr/bank_account_details/bank_account_details_v1.rb

@@ -20,7 +20,9 @@ module Mindee
             @prediction = BankAccountDetailsV1Document.new(prediction['prediction'], nil)
             @pages = []
             prediction['pages'].each do |page|
-              @pages.push(BankAccountDetailsV1Page.new(page))
+              if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+                @pages.push(BankAccountDetailsV1Page.new(page))
+              end
             end
           end
 

data/lib/mindee/product/fr/bank_account_details/bank_account_details_v2.rb

@@ -20,7 +20,9 @@ module Mindee
             @prediction = BankAccountDetailsV2Document.new(prediction['prediction'], nil)
             @pages = []
             prediction['pages'].each do |page|
-              @pages.push(BankAccountDetailsV2Page.new(page))
+              if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+                @pages.push(BankAccountDetailsV2Page.new(page))
+              end
             end
           end
 

data/lib/mindee/product/fr/bank_statement/bank_statement_v1.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../../../parsing'
+require_relative 'bank_statement_v1_document'
+require_relative 'bank_statement_v1_page'
+
+module Mindee
+  module Product
+    module FR
+      # Bank Statement (FR) module.
+      module BankStatement
+        # Bank Statement (FR) V1 prediction inference.
+        class BankStatementV1 < Mindee::Parsing::Common::Inference
+          @endpoint_name = 'bank_statement_fr'
+          @endpoint_version = '1'
+
+          # @param prediction [Hash]
+          def initialize(prediction)
+            super
+            @prediction = BankStatementV1Document.new(prediction['prediction'], nil)
+            @pages = []
+            prediction['pages'].each do |page|
+              if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+                @pages.push(BankStatementV1Page.new(page))
+              end
+            end
+          end
+
+          class << self
+            # Name of the endpoint for this product.
+            # @return [String]
+            attr_reader :endpoint_name
+            # Version for this product.
+            # @return [String]
+            attr_reader :endpoint_version
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/fr/bank_statement/bank_statement_v1_document.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require_relative '../../../parsing'
+require_relative 'bank_statement_v1_transaction'
+
+module Mindee
+  module Product
+    module FR
+      module BankStatement
+        # Bank Statement (FR) V1 document prediction.
+        class BankStatementV1Document < Mindee::Parsing::Common::Prediction
+          include Mindee::Parsing::Standard
+          # The unique identifier for a customer's account in the bank's system.
+          # @return [Mindee::Parsing::Standard::StringField]
+          attr_reader :account_number
+          # The physical location of the bank where the statement was issued.
+          # @return [Mindee::Parsing::Standard::StringField]
+          attr_reader :bank_address
+          # The name of the bank that issued the statement.
+          # @return [Mindee::Parsing::Standard::StringField]
+          attr_reader :bank_name
+          # The address of the client associated with the bank statement.
+          # @return [Mindee::Parsing::Standard::StringField]
+          attr_reader :client_address
+          # The name of the client who owns the bank statement.
+          # @return [Mindee::Parsing::Standard::StringField]
+          attr_reader :client_name
+          # The final amount of money in the account at the end of the statement period.
+          # @return [Mindee::Parsing::Standard::AmountField]
+          attr_reader :closing_balance
+          # The initial amount of money in an account at the start of the period.
+          # @return [Mindee::Parsing::Standard::AmountField]
+          attr_reader :opening_balance
+          # The date on which the bank statement was generated.
+          # @return [Mindee::Parsing::Standard::DateField]
+          attr_reader :statement_date
+          # The date when the statement period ends.
+          # @return [Mindee::Parsing::Standard::DateField]
+          attr_reader :statement_end_date
+          # The date when the bank statement period begins.
+          # @return [Mindee::Parsing::Standard::DateField]
+          attr_reader :statement_start_date
+          # The total amount of money deposited into the account.
+          # @return [Mindee::Parsing::Standard::AmountField]
+          attr_reader :total_credits
+          # The total amount of money debited from the account.
+          # @return [Mindee::Parsing::Standard::AmountField]
+          attr_reader :total_debits
+          # The list of values that represent the financial transactions recorded in a bank statement.
+          # @return [Array<Mindee::Product::FR::BankStatement::BankStatementV1Transaction>]
+          attr_reader :transactions
+
+          # @param prediction [Hash]
+          # @param page_id [Integer, nil]
+          def initialize(prediction, page_id)
+            super()
+            @account_number = StringField.new(prediction['account_number'], page_id)
+            @bank_address = StringField.new(prediction['bank_address'], page_id)
+            @bank_name = StringField.new(prediction['bank_name'], page_id)
+            @client_address = StringField.new(prediction['client_address'], page_id)
+            @client_name = StringField.new(prediction['client_name'], page_id)
+            @closing_balance = AmountField.new(prediction['closing_balance'], page_id)
+            @opening_balance = AmountField.new(prediction['opening_balance'], page_id)
+            @statement_date = DateField.new(prediction['statement_date'], page_id)
+            @statement_end_date = DateField.new(prediction['statement_end_date'], page_id)
+            @statement_start_date = DateField.new(prediction['statement_start_date'], page_id)
+            @total_credits = AmountField.new(prediction['total_credits'], page_id)
+            @total_debits = AmountField.new(prediction['total_debits'], page_id)
+            @transactions = []
+            prediction['transactions'].each do |item|
+              @transactions.push(BankStatementV1Transaction.new(item, page_id))
+            end
+          end
+
+          # @return [String]
+          def to_s
+            transactions = transactions_to_s
+            out_str = String.new
+            out_str << "\n:Account Number: #{@account_number}".rstrip
+            out_str << "\n:Bank Name: #{@bank_name}".rstrip
+            out_str << "\n:Bank Address: #{@bank_address}".rstrip
+            out_str << "\n:Client Name: #{@client_name}".rstrip
+            out_str << "\n:Client Address: #{@client_address}".rstrip
+            out_str << "\n:Statement Date: #{@statement_date}".rstrip
+            out_str << "\n:Statement Start Date: #{@statement_start_date}".rstrip
+            out_str << "\n:Statement End Date: #{@statement_end_date}".rstrip
+            out_str << "\n:Opening Balance: #{@opening_balance}".rstrip
+            out_str << "\n:Closing Balance: #{@closing_balance}".rstrip
+            out_str << "\n:Transactions:"
+            out_str << transactions
+            out_str << "\n:Total Debits: #{@total_debits}".rstrip
+            out_str << "\n:Total Credits: #{@total_credits}".rstrip
+            out_str[1..].to_s
+          end
+
+          private
+
+          # @param char [String]
+          # @return [String]
+          def transactions_separator(char)
+            out_str = String.new
+            out_str << '  '
+            out_str << "+#{char * 11}"
+            out_str << "+#{char * 12}"
+            out_str << "+#{char * 38}"
+            out_str << '+'
+            out_str
+          end
+
+          # @return [String]
+          def transactions_to_s
+            return '' if @transactions.empty?
+
+            line_items = @transactions.map(&:to_table_line).join("\n#{transactions_separator('-')}\n  ")
+            out_str = String.new
+            out_str << "\n#{transactions_separator('-')}"
+            out_str << "\n  |"
+            out_str << ' Amount    |'
+            out_str << ' Date       |'
+            out_str << ' Description                          |'
+            out_str << "\n#{transactions_separator('=')}"
+            out_str << "\n  #{line_items}"
+            out_str << "\n#{transactions_separator('-')}"
+            out_str
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/fr/bank_statement/bank_statement_v1_page.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../../../parsing'
+require_relative 'bank_statement_v1_document'
+
+module Mindee
+  module Product
+    module FR
+      module BankStatement
+        # Bank Statement (FR) V1 page.
+        class BankStatementV1Page < Mindee::Parsing::Common::Page
+          # @param prediction [Hash]
+          def initialize(prediction)
+            super(prediction)
+            @prediction = BankStatementV1PagePrediction.new(
+              prediction['prediction'],
+              prediction['id']
+            )
+          end
+        end
+
+        # Bank Statement (FR) V1 page prediction.
+        class BankStatementV1PagePrediction < BankStatementV1Document
+          # @return [String]
+          def to_s
+            out_str = String.new
+            out_str << "\n#{super}"
+            out_str
+          end
+        end
+      end
+    end
+  end
+end