mindee 4.13.0 → 5.0.0.rc1

data/lib/mindee/v1/parsing/universal/universal_list_field.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'universal_object_field'
+
+module Mindee
+  module V1
+    module Parsing
+      module Universal
+        # A list of values or objects, used in universal APIs.
+        class UniversalListField
+          include Mindee::V1::Parsing::Standard
+          include Mindee::V1::Parsing::Universal
+
+          # ID of the page (as given by the API).
+          # @return [Integer]
+          attr_reader :page_id
+
+          # List of word values
+          # @return [Array<UniversalObjectField, StringField>]
+          attr_reader :values
+
+          # ID of the page the object was found on.
+          # List of word values.
+
+          def initialize(raw_prediction, page_id = nil)
+            @values = [] # : Array[UniversalObjectField | Parsing::Standard::StringField]
+
+            raw_prediction.each do |value|
+              page_id = value['page_id'] if value.key?('page_id') && !value['page_id'].nil?
+
+              if Universal.universal_object?(value)
+                @values.push(Mindee::V1::Parsing::Universal::UniversalObjectField.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(Mindee::V1::Parsing::Standard::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.join(separator)
+          end
+
+          # String representation
+          def to_s
+            contents_string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/parsing/universal/universal_object_field.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative '../common'
+
+module Mindee
+  module V1
+    module Parsing
+      # Universal fields and functions.
+      module Universal
+        # A JSON-like object, with miscellaneous values.
+        class UniversalObjectField
+          # ID of the page (as given by the API).
+          # @return [Integer]
+          attr_reader :page_id
+          # The confidence score, value will be between 0.0 and 1.0
+          # @return [Float]
+          attr_reader :confidence
+          # Value as String
+          # @return [String]
+          attr_reader :raw_value
+          # All values
+          # @return [Hash]
+          attr_reader :all_values
+
+          # 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 = {} # : Hash[String | Symbol, untyped]
+            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
+          # changing the user 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 changing DX 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 [bool] Whether to include private methods in the check.
+          # @return [bool] `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] =
+              Mindee::V1::Parsing::Standard::PositionField.new(
+                { name.to_s => value }, item_page_id
+              )
+          end
+
+          def handle_default_field(name, value)
+            @all_values[name] = value&.to_s
+          end
+        end
+
+        def self.universal_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.to_s) }
+          false
+        end
+      end
+    end
+  end
+end

data/lib/mindee/{product → v1/product}/.rubocop.yml

@@ -1,4 +1,4 @@
-inherit_from: ../../../.rubocop.yml
+inherit_from: ../../../../.rubocop.yml
 
 Metrics/AbcSize:
   Enabled: false
@@ -10,4 +10,3 @@ Metrics/PerceivedComplexity:
   Enabled: false
 Metrics/MethodLength:
   Enabled: false
-

data/lib/mindee/{product/fr/id_card/id_card_v1.rb → v1/product/barcode_reader/barcode_reader_v1.rb}

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-require_relative '../../../parsing'
-require_relative 'id_card_v1_document'
-require_relative 'id_card_v1_page'
+require_relative '../../parsing'
+require_relative 'barcode_reader_v1_document'
+require_relative 'barcode_reader_v1_page'
 
 module Mindee
-  module Product
-    module FR
-      # Carte Nationale d'Identité module.
-      module IdCard
-        # Carte Nationale d'Identité API version 1 inference prediction.
-        class IdCardV1 < Mindee::Parsing::Common::Inference
-          @endpoint_name = 'idcard_fr'
+  module V1
+    module Product
+      # Barcode Reader module.
+      module BarcodeReader
+        # Barcode Reader API version 1 inference prediction.
+        class BarcodeReaderV1 < Mindee::V1::Parsing::Common::Inference
+          @endpoint_name = 'barcode_reader'
           @endpoint_version = '1'
           @has_async = false
           @has_sync = true
@@ -19,10 +19,10 @@ module Mindee
           # @param prediction [Hash]
           def initialize(prediction)
             super
-            @prediction = IdCardV1Document.new(prediction['prediction'], nil)
+            @prediction = BarcodeReaderV1Document.new(prediction['prediction'], nil)
             @pages = []
             prediction['pages'].each do |page|
-              @pages.push(IdCardV1Page.new(page))
+              @pages.push(BarcodeReaderV1Page.new(page))
             end
           end
 

data/lib/mindee/v1/product/barcode_reader/barcode_reader_v1_document.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+
+module Mindee
+  module V1
+    module Product
+      module BarcodeReader
+        # Barcode Reader API version 1.0 document data.
+        class BarcodeReaderV1Document < Mindee::V1::Parsing::Common::Prediction
+          include Mindee::V1::Parsing::Standard
+
+          # List of decoded 1D barcodes.
+          # @return [Array<Mindee::V1::Parsing::Standard::StringField>]
+          attr_reader :codes_1d
+          # List of decoded 2D barcodes.
+          # @return [Array<Mindee::V1::Parsing::Standard::StringField>]
+          attr_reader :codes_2d
+
+          # @param prediction [Hash]
+          # @param page_id [Integer, nil]
+          def initialize(prediction, page_id)
+            super
+            @codes_1d = [] # : Array[Parsing::Standard::StringField]
+            prediction['codes_1d'].each do |item|
+              @codes_1d.push(Parsing::Standard::StringField.new(item, page_id))
+            end
+            @codes_2d = [] # : Array[Parsing::Standard::StringField]
+            prediction['codes_2d'].each do |item|
+              @codes_2d.push(Parsing::Standard::StringField.new(item, page_id))
+            end
+          end
+
+          # @return [String]
+          def to_s
+            codes_1d = @codes_1d.join("\n #{' ' * 13}")
+            codes_2d = @codes_2d.join("\n #{' ' * 13}")
+            out_str = String.new
+            out_str << "\n:Barcodes 1D: #{codes_1d}".rstrip
+            out_str << "\n:Barcodes 2D: #{codes_2d}".rstrip
+            out_str[1..].to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/{product/fr/bank_statement/bank_statement_v2_page.rb → v1/product/barcode_reader/barcode_reader_v1_page.rb}

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-require_relative '../../../parsing'
-require_relative 'bank_statement_v2_document'
+require_relative '../../parsing'
+require_relative 'barcode_reader_v1_document'
 
 module Mindee
-  module Product
-    module FR
-      module BankStatement
-        # Bank Statement API version 2.0 page data.
-        class BankStatementV2Page < Mindee::Parsing::Common::Page
+  module V1
+    module Product
+      module BarcodeReader
+        # Barcode Reader API version 1.0 page data.
+        class BarcodeReaderV1Page < Mindee::V1::Parsing::Common::Page
           # @param prediction [Hash]
           def initialize(prediction)
             super
             @prediction = if prediction['prediction'].empty?
                             nil
                           else
-                            BankStatementV2PagePrediction.new(
+                            BarcodeReaderV1PagePrediction.new(
                               prediction['prediction'],
                               prediction['id']
                             )
@@ -23,8 +23,8 @@ module Mindee
           end
         end
 
-        # Bank Statement V2 page prediction.
-        class BankStatementV2PagePrediction < BankStatementV2Document
+        # Barcode Reader V1 page prediction.
+        class BarcodeReaderV1PagePrediction < BarcodeReaderV1Document
           # @return [String]
           def to_s
             out_str = String.new

data/lib/mindee/{product/us/bank_check/bank_check_v1.rb → v1/product/cropper/cropper_v1.rb}

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-require_relative '../../../parsing'
-require_relative 'bank_check_v1_document'
-require_relative 'bank_check_v1_page'
+require_relative '../../parsing'
+require_relative 'cropper_v1_document'
+require_relative 'cropper_v1_page'
 
 module Mindee
-  module Product
-    module US
-      # Bank Check module.
-      module BankCheck
-        # Bank Check API version 1 inference prediction.
-        class BankCheckV1 < Mindee::Parsing::Common::Inference
-          @endpoint_name = 'bank_check'
+  module V1
+    module Product
+      # Cropper module.
+      module Cropper
+        # Cropper API version 1 inference prediction.
+        class CropperV1 < Mindee::V1::Parsing::Common::Inference
+          @endpoint_name = 'cropper'
           @endpoint_version = '1'
           @has_async = false
           @has_sync = true
@@ -19,10 +19,10 @@ module Mindee
           # @param prediction [Hash]
           def initialize(prediction)
             super
-            @prediction = BankCheckV1Document.new(prediction['prediction'], nil)
+            @prediction = CropperV1Document.new(prediction['prediction'], nil)
             @pages = []
             prediction['pages'].each do |page|
-              @pages.push(BankCheckV1Page.new(page))
+              @pages.push(CropperV1Page.new(page))
             end
           end
 

data/lib/mindee/v1/product/cropper/cropper_v1_document.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+
+module Mindee
+  module V1
+    module Product
+      module Cropper
+        # Cropper API version 1.1 document data.
+        class CropperV1Document < Mindee::V1::Parsing::Common::Prediction
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v1/product/cropper/cropper_v1_page.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'cropper_v1_document'
+
+module Mindee
+  module V1
+    module Product
+      module Cropper
+        # Cropper API version 1.1 page data.
+        class CropperV1Page < Mindee::V1::Parsing::Common::Page
+          # @param prediction [Hash]
+          def initialize(prediction)
+            super
+            @prediction = if prediction['prediction'].empty?
+                            nil
+                          else
+                            CropperV1PagePrediction.new(
+                              prediction['prediction'],
+                              prediction['id']
+                            )
+                          end
+          end
+        end
+
+        # Cropper V1 page prediction.
+        class CropperV1PagePrediction < CropperV1Document
+          include Mindee::V1::Parsing::Standard
+
+          # List of documents found in the image.
+          # @return [Array<Mindee::V1::Parsing::Standard::PositionField>]
+          attr_reader :cropping
+
+          # @param prediction [Hash]
+          # @param page_id [Integer, nil]
+          def initialize(prediction, page_id)
+            @cropping = []
+            prediction['cropping'].each do |item|
+              @cropping.push(Parsing::Standard::PositionField.new(item, page_id))
+            end
+            super
+          end
+
+          # @return [String]
+          def to_s
+            cropping = @cropping.join("\n #{' ' * 18}")
+            out_str = String.new
+            out_str << "\n:Document Cropper: #{cropping}".rstrip
+            out_str
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/{product/ind/indian_passport/indian_passport_v1.rb → v1/product/financial_document/financial_document_v1.rb}

@@ -1,28 +1,28 @@
 # frozen_string_literal: true
 
-require_relative '../../../parsing'
-require_relative 'indian_passport_v1_document'
-require_relative 'indian_passport_v1_page'
+require_relative '../../parsing'
+require_relative 'financial_document_v1_document'
+require_relative 'financial_document_v1_page'
 
 module Mindee
-  module Product
-    module IND
-      # Passport - India module.
-      module IndianPassport
-        # Passport - India API version 1 inference prediction.
-        class IndianPassportV1 < Mindee::Parsing::Common::Inference
-          @endpoint_name = 'ind_passport'
+  module V1
+    module Product
+      # Financial Document module.
+      module FinancialDocument
+        # Financial Document API version 1 inference prediction.
+        class FinancialDocumentV1 < Mindee::V1::Parsing::Common::Inference
+          @endpoint_name = 'financial_document'
           @endpoint_version = '1'
           @has_async = true
-          @has_sync = false
+          @has_sync = true
 
           # @param prediction [Hash]
           def initialize(prediction)
             super
-            @prediction = IndianPassportV1Document.new(prediction['prediction'], nil)
+            @prediction = FinancialDocumentV1Document.new(prediction['prediction'], nil)
             @pages = []
             prediction['pages'].each do |page|
-              @pages.push(IndianPassportV1Page.new(page))
+              @pages.push(FinancialDocumentV1Page.new(page))
             end
           end