mindee 3.3.1 → 3.5.0

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

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../../../parsing'
+
+module Mindee
+  module Product
+    module FR
+      module BankStatement
+        # The list of values that represent the financial transactions recorded in a bank statement.
+        class BankStatementV1Transaction < Mindee::Parsing::Standard::FeatureField
+          include Mindee::Parsing::Standard
+          # The monetary amount of the transaction.
+          # @return [Float]
+          attr_reader :amount
+          # The date on which the transaction occurred.
+          # @return [String]
+          attr_reader :date
+          # The additional information about the transaction.
+          # @return [String]
+          attr_reader :description
+
+          # @param prediction [Hash]
+          # @param page_id [Integer, nil]
+          def initialize(prediction, page_id)
+            super(prediction, page_id)
+            @amount = prediction['amount']
+            @date = prediction['date']
+            @description = prediction['description']
+            @page_id = page_id
+          end
+
+          # @return [Hash]
+          def printable_values
+            printable = {}
+            printable[:amount] = @amount.nil? ? '' : Field.float_to_string(@amount)
+            printable[:date] = format_for_display(@date, nil)
+            printable[:description] = format_for_display(@description, 36)
+            printable
+          end
+
+          # @return [String]
+          def to_table_line
+            printable = printable_values
+            out_str = String.new
+            out_str << format('| %- 10s', printable[:amount])
+            out_str << format('| %- 11s', printable[:date])
+            out_str << format('| %- 37s', printable[:description])
+            out_str << '|'
+          end
+
+          # @return [String]
+          def to_s
+            printable = printable_values
+            out_str = String.new
+            out_str << "\n  :Amount: #{printable[:amount]}"
+            out_str << "\n  :Date: #{printable[:date]}"
+            out_str << "\n  :Description: #{printable[:description]}"
+            out_str
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/fr/carte_grise/carte_grise_v1.rb

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

data/lib/mindee/product/fr/carte_vitale/carte_vitale_v1.rb

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

data/lib/mindee/product/fr/id_card/id_card_v1.rb

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

data/lib/mindee/product/fr/id_card/id_card_v2.rb

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

data/lib/mindee/product/generated/generated_v1.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'generated_v1_document'
+require_relative 'generated_v1_page'
+
+module Mindee
+  module Product
+    # Generated product module.
+    module Generated
+      # Generated Document V1 prediction inference.
+      class GeneratedV1 < Mindee::Parsing::Common::Inference
+        @endpoint_name = ''
+        @endpoint_version = ''
+
+        # @param prediction [Hash]
+        def initialize(prediction)
+          super
+          @prediction = GeneratedV1Document.new(prediction['prediction'])
+          @pages = []
+          prediction['pages'].each do |page|
+            if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+              @pages.push(GeneratedV1Page.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

data/lib/mindee/product/generated/generated_v1_document.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'generated_v1_prediction'
+
+module Mindee
+  module Product
+    module Generated
+      # Generated Document V1 prediction
+      class GeneratedV1Document < Mindee::Product::Generated::GeneratedV1Prediction
+        include Mindee::Parsing::Standard
+        # @param raw_prediction [Hash]
+        def initialize(raw_prediction)
+          # Generated document.
+
+          # raw_prediction: Dictionary containing the JSON document response
+          super()
+          raw_prediction.each do |field_name, field_contents|
+            if field_contents.is_a?(Array)
+              @fields[field_name] = Parsing::Generated::GeneratedListField.new(field_contents)
+            elsif field_contents.is_a?(Hash) && Parsing::Generated.generated_object?(field_contents)
+              @fields[field_name] = Parsing::Generated::GeneratedObjectField.new(field_contents)
+            else
+              field_contents_str = field_contents.dup
+              if field_contents_str.key?('value') && field_contents_str['value'].nil? == false
+                field_contents_str['value'] = field_contents_str['value'].to_s
+              end
+              @fields[field_name] = StringField.new(field_contents_str)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/generated/generated_v1_page.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'generated_v1_prediction'
+
+module Mindee
+  module Product
+    module Generated
+      # Generated Document V1 page.
+      class GeneratedV1Page < Mindee::Parsing::Common::Page
+        # @param prediction [Hash]
+        def initialize(prediction)
+          super(prediction)
+          @prediction = GeneratedV1PagePrediction.new(
+            prediction['prediction'],
+            prediction['id']
+          )
+        end
+      end
+
+      # Generated Document V1 page prediction.
+      class GeneratedV1PagePrediction < GeneratedV1Prediction
+        include Mindee::Parsing::Standard
+        include Mindee::Parsing::Generated
+        def initialize(raw_prediction, page_id = nil)
+          super()
+          raw_prediction.each do |field_name, field_contents|
+            if field_contents.is_a?(Array)
+              @fields[field_name] = GeneratedListField.new(field_contents, page_id)
+            elsif field_contents.is_a?(Hash) && Parsing::Generated.generated_object?(field_contents)
+              @fields[field_name] = GeneratedObjectField.new(field_contents, page_id)
+            else
+              field_contents_str = field_contents.dup
+              if field_contents_str.key?('value') && !field_contents_str['value'].nil?
+                field_contents_str['value'] = field_contents_str['value'].to_s
+              end
+              @fields[field_name] = StringField.new(field_contents_str, page_id)
+            end
+          end
+        end
+
+        # @return [String]
+        def to_s
+          out_str = String.new
+          out_str << "\n#{super}"
+          out_str
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/generated/generated_v1_prediction.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+
+module Mindee
+  module Product
+    module Generated
+      # Generated Document V1 page.
+      class GeneratedV1Prediction < Mindee::Parsing::Common::Prediction
+        include Mindee::Parsing::Common
+        include Mindee::Parsing::Standard
+        include Mindee::Parsing::Generated
+        # All value fields in the document
+        # @return [Hash<Symbol, Mindee::Parsing::Generated::GeneratedListField>]
+        attr_reader :fields
+
+        def initialize
+          super()
+          @fields = {}
+        end
+
+        # String representation.
+        def to_s
+          out_str = ''
+          pattern = %r{^(\n* *)( {2}):}
+          @fields.each do |field_name, field_value|
+            str_value = if field_value.is_a?(GeneratedListField) && field_value.values.length.positive?
+                          generate_field_string(field_name, field_value, pattern)
+                        else
+                          field_value.to_s
+                        end
+            out_str += "\n:#{field_name}:"
+
+            out_str += " #{str_value}".sub(%r{^\s+\n}, "\n") if str_value.length.positive?
+          end
+          out_str.sub("\n", '')
+        end
+
+        private
+
+        def generate_field_string(field_name, field_value, pattern)
+          return '' if field_value.values.empty? || field_value.values.nil?
+
+          str_value = ''
+          str_value += if field_value.values[0].is_a?(Parsing::Generated::GeneratedObjectField)
+                         field_value.values[0].str_level(1).sub(pattern, '\\1* :')
+                       else
+                         "#{field_value.values[0].to_s.sub(pattern, '\\1* :')}\n"
+                       end
+          field_value.values[1..].each do |sub_value|
+            str_value += if sub_value.is_a?(Parsing::Generated::GeneratedObjectField)
+                           sub_value.str_level(1).sub(pattern, '\\1* :')
+                         else
+                           "#{' ' * (field_name.length + 2)} #{sub_value}\n"
+                         end
+          end
+          str_value.rstrip
+        end
+
+        def generate_list_field_string(field_name, field_value, pattern)
+          str_value = ''
+          field_value.each_value do |sub_value|
+            str_value += generate_sub_value_string(field_name, sub_value, pattern)
+          end
+          str_value.rstrip
+        end
+
+        def generate_sub_value_string(field_name, sub_value, pattern)
+          if sub_value.is_a?(GeneratedObjectField)
+            sub_value.str_level(1).gsub(pattern, '\1* :')
+          else
+            (' ' * (field_name.length + 2)) + "#{sub_value}\n"
+          end
+        end
+
+        # Returns a hash of all fields that aren't a collection
+        # @return [Hash<String, StringField>]
+        def single_fields
+          single_fields = {}
+          @fields.each do |field_name, field_value|
+            single_fields[field_name] = field_value if field_value.is_a?(StringField)
+          end
+          single_fields
+        end
+
+        # Returns a hash of all list-like fields
+        # @return [Hash<String, GeneratedListField>]
+        def list_fields
+          list_fields = {}
+          @fields.each do |field_name, field_value|
+            list_fields[field_name] = field_value if field_value.is_a?(GeneratedListField)
+          end
+          list_fields
+        end
+
+        # Returns a hash of all object-like fields
+        # @return [Hash<String, GeneratedObjectField>]
+        def object_fields
+          object_fields = {}
+          @fields.each do |field_name, field_value|
+            object_fields[field_name] = field_value if field_value.is_a?(GeneratedObjectField)
+          end
+          object_fields
+        end
+
+        # Lists names of all top-level field keys
+        # @return [Array<String>]
+        def list_field_names
+          @fields.keys.map(&:to_s)
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/international_id/international_id_v1.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'international_id_v1_document'
+require_relative 'international_id_v1_page'
+
+module Mindee
+  module Product
+    # International ID module.
+    module InternationalId
+      # International ID V1 prediction inference.
+      class InternationalIdV1 < Mindee::Parsing::Common::Inference
+        @endpoint_name = 'international_id'
+        @endpoint_version = '1'
+
+        # @param prediction [Hash]
+        def initialize(prediction)
+          super
+          @prediction = InternationalIdV1Document.new(prediction['prediction'], nil)
+          @pages = []
+          prediction['pages'].each do |page|
+            if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+              @pages.push(InternationalIdV1Page.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

data/lib/mindee/product/international_id/international_id_v1_document.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+
+module Mindee
+  module Product
+    module InternationalId
+      # International ID V1 document prediction.
+      class InternationalIdV1Document < Mindee::Parsing::Common::Prediction
+        include Mindee::Parsing::Standard
+        # The physical location of the document holder's residence.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :address
+        # The date of birth of the document holder.
+        # @return [Mindee::Parsing::Standard::DateField]
+        attr_reader :birth_date
+        # The location where the document holder was born.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :birth_place
+        # The country that issued the identification document.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :country_of_issue
+        # The unique identifier assigned to the identification document.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :document_number
+        # The type of identification document being used.
+        # @return [Mindee::Parsing::Standard::ClassificationField]
+        attr_reader :document_type
+        # The date when the document will no longer be valid for use.
+        # @return [Mindee::Parsing::Standard::DateField]
+        attr_reader :expiry_date
+        # The first names or given names of the document holder.
+        # @return [Array<Mindee::Parsing::Standard::StringField>]
+        attr_reader :given_names
+        # The date when the document was issued.
+        # @return [Mindee::Parsing::Standard::DateField]
+        attr_reader :issue_date
+        # First line of information in a standardized format for easy machine reading and processing.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :mrz1
+        # Second line of information in a standardized format for easy machine reading and processing.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :mrz2
+        # Third line of information in a standardized format for easy machine reading and processing.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :mrz3
+        # Indicates the country of citizenship or nationality of the document holder.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :nationality
+        # The document holder's biological sex, such as male or female.
+        # @return [Mindee::Parsing::Standard::StringField]
+        attr_reader :sex
+        # The surnames of the document holder.
+        # @return [Array<Mindee::Parsing::Standard::StringField>]
+        attr_reader :surnames
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          super()
+          @address = StringField.new(prediction['address'], page_id)
+          @birth_date = DateField.new(prediction['birth_date'], page_id)
+          @birth_place = StringField.new(prediction['birth_place'], page_id)
+          @country_of_issue = StringField.new(prediction['country_of_issue'], page_id)
+          @document_number = StringField.new(prediction['document_number'], page_id)
+          @document_type = ClassificationField.new(prediction['document_type'], page_id)
+          @expiry_date = DateField.new(prediction['expiry_date'], page_id)
+          @given_names = []
+          prediction['given_names'].each do |item|
+            @given_names.push(StringField.new(item, page_id))
+          end
+          @issue_date = DateField.new(prediction['issue_date'], page_id)
+          @mrz1 = StringField.new(prediction['mrz1'], page_id)
+          @mrz2 = StringField.new(prediction['mrz2'], page_id)
+          @mrz3 = StringField.new(prediction['mrz3'], page_id)
+          @nationality = StringField.new(prediction['nationality'], page_id)
+          @sex = StringField.new(prediction['sex'], page_id)
+          @surnames = []
+          prediction['surnames'].each do |item|
+            @surnames.push(StringField.new(item, page_id))
+          end
+        end
+
+        # @return [String]
+        def to_s
+          surnames = @surnames.join("\n #{' ' * 10}")
+          given_names = @given_names.join("\n #{' ' * 13}")
+          out_str = String.new
+          out_str << "\n:Document Type: #{@document_type}".rstrip
+          out_str << "\n:Document Number: #{@document_number}".rstrip
+          out_str << "\n:Country of Issue: #{@country_of_issue}".rstrip
+          out_str << "\n:Surnames: #{surnames}".rstrip
+          out_str << "\n:Given Names: #{given_names}".rstrip
+          out_str << "\n:Gender: #{@sex}".rstrip
+          out_str << "\n:Birth date: #{@birth_date}".rstrip
+          out_str << "\n:Birth Place: #{@birth_place}".rstrip
+          out_str << "\n:Nationality: #{@nationality}".rstrip
+          out_str << "\n:Issue Date: #{@issue_date}".rstrip
+          out_str << "\n:Expiry Date: #{@expiry_date}".rstrip
+          out_str << "\n:Address: #{@address}".rstrip
+          out_str << "\n:Machine Readable Zone Line 1: #{@mrz1}".rstrip
+          out_str << "\n:Machine Readable Zone Line 2: #{@mrz2}".rstrip
+          out_str << "\n:Machine Readable Zone Line 3: #{@mrz3}".rstrip
+          out_str[1..].to_s
+        end
+      end
+    end
+  end
+end