mindee 3.3.1 → 3.5.0

data/lib/mindee/input/sources.rb

@@ -7,6 +7,7 @@ require_relative '../pdf'
 
 module Mindee
   module Input
+    # Document source handling.
     module Source
       # Mime types accepted by the server.
       ALLOWED_MIME_TYPES = [
@@ -107,8 +108,7 @@ module Mindee
           @io_stream = PdfProcessor.parse(@io_stream, options)
         end
 
-        # Reads a document. Packs it into bytes if needed.
-        # Note: only needs filename in case of some pdf files.
+        # Reads a document.
         # @param close [Boolean]
         # @return [Array<String, [String, aBinaryString ], [Hash, nil] >]
         def read_document(close: true)
@@ -116,9 +116,7 @@ module Mindee
           # Avoids needlessly re-packing some files
           data = @io_stream.read
           @io_stream.close if close
-          return ['document', data, { filename: @filename }] if pdf?
-
-          ['document', [data].pack('m')]
+          ['document', data, { filename: Mindee::Input::Source.convert_to_unicode_escape(@filename) }]
         end
       end
 
@@ -142,6 +140,16 @@ module Mindee
           io_stream.set_encoding Encoding::BINARY
           super(io_stream, filename, fix_pdf: fix_pdf)
         end
+
+        # Overload of the same function to prevent a base64 from being re-encoded.
+        # @param close [Boolean]
+        # @return [Array<String, [String, aBinaryString ], [Hash, nil] >]
+        def read_document(close: true)
+          @io_stream.seek(0)
+          data = @io_stream.read
+          @io_stream.close if close
+          ['document', [data].pack('m'), { filename: Source.convert_to_unicode_escape(@filename) }]
+        end
       end
 
       # Load a document from raw bytes.
@@ -178,6 +186,21 @@ module Mindee
           @url = url
         end
       end
+
+      # Replaces non-ASCII characters by their unicode escape sequence.
+      # Keeps other characters as is.
+      # @return A clean String.
+      def self.convert_to_unicode_escape(string)
+        unicode_escape_string = ''.dup
+        string.each_char do |char|
+          unicode_escape_string << if char.bytesize > 1
+                                     "\\u#{char.unpack1('U').to_s(16).rjust(4, '0')}"
+                                   else
+                                     char
+                                   end
+        end
+        unicode_escape_string
+      end
     end
   end
 end

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/standard/string_field.rb

@@ -10,6 +10,14 @@ module Mindee
         # Value as String
         # @return [String, nil]
         attr_reader :value
+        # Value as String
+        # @return [String, nil]
+        attr_reader :raw_value
+
+        def initialize(prediction, page_id = nil, reconstructed: false)
+          super
+          @raw_value = prediction['raw_value']
+        end
       end
     end
   end

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