mindee 3.4.0 → 3.5.0

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

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'international_id_v1_document'
+
+module Mindee
+  module Product
+    module InternationalId
+      # International ID V1 page.
+      class InternationalIdV1Page < Mindee::Parsing::Common::Page
+        # @param prediction [Hash]
+        def initialize(prediction)
+          super(prediction)
+          @prediction = InternationalIdV1PagePrediction.new(
+            prediction['prediction'],
+            prediction['id']
+          )
+        end
+      end
+
+      # International ID V1 page prediction.
+      class InternationalIdV1PagePrediction < InternationalIdV1Document
+        # @return [String]
+        def to_s
+          out_str = String.new
+          out_str << "\n#{super}"
+          out_str
+        end
+      end
+    end
+  end
+end

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

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