mindee-lite 5.0.0.beta1

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/v1/parsing/universal.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'universal/universal_object_field'
+require_relative 'universal/universal_list_field'

data/lib/mindee/v1/parsing.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'parsing/standard'
+require_relative 'parsing/common'
+require_relative 'parsing/universal'

data/lib/mindee/v1/product/.rubocop.yml

@@ -0,0 +1,12 @@
+inherit_from: ../../../../.rubocop.yml
+
+Metrics/AbcSize:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/PerceivedComplexity:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'barcode_reader_v1_document'
+require_relative 'barcode_reader_v1_page'
+
+module Mindee
+  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
+
+          # @param prediction [Hash]
+          def initialize(prediction)
+            super
+            @prediction = BarcodeReaderV1Document.new(prediction['prediction'], nil)
+            @pages = []
+            prediction['pages'].each do |page|
+              @pages.push(BarcodeReaderV1Page.new(page))
+            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
+            # Whether this product has access to an asynchronous endpoint.
+            # @return [bool]
+            attr_reader :has_async
+            # Whether this product has access to synchronous endpoint.
+            # @return [bool]
+            attr_reader :has_sync
+          end
+        end
+      end
+    end
+  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/v1/product/barcode_reader/barcode_reader_v1_page.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'barcode_reader_v1_document'
+
+module Mindee
+  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
+                            BarcodeReaderV1PagePrediction.new(
+                              prediction['prediction'],
+                              prediction['id']
+                            )
+                          end
+          end
+        end
+
+        # Barcode Reader V1 page prediction.
+        class BarcodeReaderV1PagePrediction < BarcodeReaderV1Document
+          # @return [String]
+          def to_s
+            out_str = String.new
+            out_str << "\n#{super}"
+            out_str
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'cropper_v1_document'
+require_relative 'cropper_v1_page'
+
+module Mindee
+  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
+
+          # @param prediction [Hash]
+          def initialize(prediction)
+            super
+            @prediction = CropperV1Document.new(prediction['prediction'], nil)
+            @pages = []
+            prediction['pages'].each do |page|
+              @pages.push(CropperV1Page.new(page))
+            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
+            # Whether this product has access to an asynchronous endpoint.
+            # @return [bool]
+            attr_reader :has_async
+            # Whether this product has access to synchronous endpoint.
+            # @return [bool]
+            attr_reader :has_sync
+          end
+        end
+      end
+    end
+  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/v1/product/financial_document/financial_document_v1.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'financial_document_v1_document'
+require_relative 'financial_document_v1_page'
+
+module Mindee
+  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 = true
+
+          # @param prediction [Hash]
+          def initialize(prediction)
+            super
+            @prediction = FinancialDocumentV1Document.new(prediction['prediction'], nil)
+            @pages = []
+            prediction['pages'].each do |page|
+              @pages.push(FinancialDocumentV1Page.new(page))
+            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
+            # Whether this product has access to an asynchronous endpoint.
+            # @return [bool]
+            attr_reader :has_async
+            # Whether this product has access to synchronous endpoint.
+            # @return [bool]
+            attr_reader :has_sync
+          end
+        end
+      end
+    end
+  end
+end