mindee 2.2.1 → 3.1.0

data/lib/mindee/parsing/standard/locale_field.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module Standard
+      # Represents locale information
+      class Locale
+        # The confidence score, value will be between 0.0 and 1.0
+        # @return [Float]
+        attr_reader :confidence
+        #  Language code in ISO 639-1 format.
+        # @return [String]
+        attr_reader :language
+        # Country code in ISO 3166-1 alpha-2 format.
+        # @return [String, nil]
+        attr_reader :country
+        # Currency code in ISO 4217 format.
+        # @return [String]
+        attr_reader :currency
+        # Language code, with country code when available.
+        # @return [String]
+        attr_reader :value
+
+        # @param prediction [Hash]
+        def initialize(prediction, _page_id = nil)
+          value_key = if prediction.include? 'value'
+                        'value'
+                      else
+                        'language'
+                      end
+          @confidence = prediction['confidence']
+          @value = prediction[value_key]
+          @language = prediction['language']
+          @country = prediction['country']
+          @currency = prediction['currency']
+        end
+
+        # @return [String]
+        def to_s
+          out_str = String.new
+          out_str << "#{@value}; " if @value
+          out_str << "#{@language}; " if @language
+          out_str << "#{@country}; " if @country
+          out_str << "#{@currency}; " if @currency
+          out_str.strip
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/standard/payment_details_field.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'base_field'
+
+module Mindee
+  module Parsing
+    module Standard
+      # Represents payment details for invoices and receipts
+      class PaymentDetails < Field
+        # @return [String, nil]
+        attr_reader :account_number
+        # @return [String, nil]
+        attr_reader :iban
+        # @return [String, nil]
+        attr_reader :routing_number
+        # @return [String, nil]
+        attr_reader :swift
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        # @param reconstructed [Boolean]
+        def initialize(prediction, page_id, reconstructed: false)
+          super
+          @account_number = prediction['account_number']
+          @iban = prediction['iban']
+          @routing_number = prediction['routing_number']
+          @swift = prediction['swift']
+        end
+
+        # @return [String]
+        def to_s
+          out_str = String.new
+          out_str << "#{@account_number}; " if @account_number
+          out_str << "#{@iban}; " if @iban
+          out_str << "#{@routing_number}; " if @routing_number
+          out_str << "#{@swift}; " if @swift
+          out_str.strip
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/standard/position_field.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module Standard
+      # An element's position on the image
+      class PositionField
+        # @return [Mindee::Geometry::Polygon]
+        attr_reader :polygon
+        # @return [Mindee::Geometry::Polygon]
+        attr_reader :value
+        # @return [Mindee::Geometry::Quadrilateral]
+        attr_reader :quadrangle
+        # @return [Mindee::Geometry::Quadrilateral]
+        attr_reader :rectangle
+        # @return [Mindee::Geometry::Quadrilateral]
+        attr_reader :bounding_box
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          unless prediction['polygon'].nil? || prediction['polygon'].empty?
+            @polygon = Geometry.polygon_from_prediction(prediction['polygon'])
+          end
+          @quadrangle = to_quadrilateral(prediction, 'quadrangle')
+          @rectangle = to_quadrilateral(prediction, 'rectangle')
+          @bounding_box = to_quadrilateral(prediction, 'bounding_box')
+          @page_id = page_id || prediction['page_id']
+          @value = @polygon
+        end
+
+        # @return [String]
+        def to_s
+          out_str = String.new
+          out_str << "Polygon with #{@polygon.size} points." if @polygon
+          out_str
+        end
+
+        private
+
+        def to_quadrilateral(prediction, key)
+          Geometry.quadrilateral_from_prediction(prediction[key]) unless prediction[key].nil? || prediction[key].empty?
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/standard/tax_field.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative 'base_field'
+
+module Mindee
+  module Parsing
+    module Standard
+      # Represents tax information.
+      class TaxField < Field
+        # Tax value as 3 decimal float
+        # @return [Float, nil]
+        attr_reader :value
+        # Tax rate percentage
+        # @return [Float]
+        attr_reader :rate
+        # Tax code
+        # @return [String]
+        attr_reader :code
+        # Tax base
+        # @return [Float]
+        attr_reader :base
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          super
+          @value = prediction['value']&.round(3)
+          @rate = prediction['rate'].to_f unless prediction['rate'].nil?
+          @base = prediction['base'].to_f unless prediction['base'].nil?
+          @code = prediction['code'] unless prediction['code'] == 'None'
+        end
+
+        # @param value [Float]
+        def print_float(value)
+          format('%.2f', value)
+        end
+
+        # @return [String]
+        def to_s
+          printable = printable_values
+          out_str = String.new
+          out_str << ("Base: #{printable[:base]}")
+          out_str << (", Code: #{printable[:code]}")
+          out_str << (", Rate (%): #{printable[:rate]}")
+          out_str << (", Amount: #{printable[:value]}")
+          out_str.strip
+        end
+
+        # @return [Hash]
+        def printable_values
+          out_h = {}
+          out_h[:code] = @code.nil? ? '' : @code
+          out_h[:base] = @base.nil? ? '' : print_float(@base)
+          out_h[:rate] = @rate.nil? ? '' : print_float(@rate).to_s
+          out_h[:value] = @value.nil? ? '' : print_float(@value).to_s
+          out_h
+        end
+
+        # @return [String]
+        def to_table_line
+          printable = printable_values
+          out_str = String.new
+          out_str << ("| #{printable[:base].ljust(13, ' ')}")
+          out_str << (" | #{printable[:code].ljust(6, ' ')}")
+          out_str << (" | #{printable[:rate].ljust(8, ' ')}")
+          out_str << (" | #{printable[:value].ljust(13, ' ')} |")
+          out_str.strip
+        end
+      end
+
+      # Represents tax information, grouped as an array.
+      class Taxes < Array
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          super(prediction.map { |entry| TaxField.new(entry, page_id) })
+        end
+
+        # @param char [String]
+        # @return [String]
+        def line_separator(char)
+          out_str = String.new
+          out_str << '  '
+          out_str << "+#{char * 15}"
+          out_str << "+#{char * 8}"
+          out_str << "+#{char * 10}"
+          out_str << "+#{char * 15}"
+          out_str << '+'
+          out_str
+        end
+
+        # @return [String]
+        def to_s
+          return '' if nil? || empty?
+
+          out_str = String.new
+          out_str << ("\n#{line_separator('-')}")
+          out_str << "\n  | Base          | Code   | Rate (%) | Amount        |"
+          out_str << "\n#{line_separator('=')}"
+          each do |entry|
+            out_str << "\n  #{entry.to_table_line}\n#{line_separator('-')}"
+          end
+          out_str
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/standard/text_field.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'base_field'
+
+module Mindee
+  module Parsing
+    module Standard
+      # Represents basic text information.
+      class TextField < Field
+        # Value as String
+        # @return [String, nil]
+        attr_reader :value
+      end
+    end
+  end
+end

data/lib/mindee/parsing/standard.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'standard/amount_field'
+require_relative 'standard/base_field'
+require_relative 'standard/classification_field'
+require_relative 'standard/company_registration_field'
+require_relative 'standard/date_field'
+require_relative 'standard/payment_details_field'
+require_relative 'standard/position_field'
+require_relative 'standard/tax_field'
+require_relative 'standard/text_field'
+require_relative 'standard/locale_field'

data/lib/mindee/parsing.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'parsing/prediction'
-require_relative 'parsing/document'
+require_relative 'parsing/standard'
+require_relative 'parsing/custom'
+require_relative 'parsing/common'

data/lib/mindee/{input → pdf}/pdf_processing.rb

@@ -2,41 +2,13 @@
 
 require 'set'
 require 'origami'
-
-# Monkey-patching for Origami
-module PDFTools
-  def to_io_stream(params = {})
-    options = {
-      delinearize: true,
-      recompile: true,
-      decrypt: false,
-    }
-    options.update(params)
-
-    if frozen? # incompatible flags with frozen doc (signed)
-      options[:recompile] = nil
-      options[:rebuild_xrefs] = nil
-      options[:noindent] = nil
-      options[:obfuscate] = false
-    end
-    load_all_objects unless @loaded
-
-    intents_as_pdfa1 if options[:intent] =~ %r{pdf[/-]?A1?/i}
-    delinearize! if options[:delinearize] && linearized?
-    compile(options) if options[:recompile]
-
-    io_stream = StringIO.new(output(options))
-    io_stream.set_encoding Encoding::BINARY
-    io_stream
-  end
-end
-
-Origami::PDF.class_eval { include PDFTools }
+require_relative 'pdf_tools'
 
 module Mindee
-  module Input
-    # Class for PDF documents
+  module PDF
+    # Module for PDF document handling
     module PdfProcessor
+      Origami::PDF.class_eval { include PDFTools }
       DEFAULT_OPTIONS = {
         page_indexes: [0],
         operation: :KEEP_ONLY,

data/lib/mindee/pdf/pdf_tools.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Mindee
+  module PDF
+    # Monkey-patching for Origami
+    module PDFTools
+      # @return [StringIO]
+      def to_io_stream(params = {})
+        options = {
+          delinearize: true,
+          recompile: true,
+          decrypt: false,
+        }
+        options.update(params)
+
+        if frozen? # incompatible flags with frozen doc (signed)
+          options[:recompile] = nil
+          options[:rebuild_xrefs] = nil
+          options[:noindent] = nil
+          options[:obfuscate] = false
+        end
+        load_all_objects unless @loaded
+
+        intents_as_pdfa1 if options[:intent] =~ %r{pdf[/-]?A1?/i}
+        delinearize! if options[:delinearize] && linearized?
+        compile(options) if options[:recompile]
+
+        io_stream = StringIO.new(output(options))
+        io_stream.set_encoding Encoding::BINARY
+        io_stream
+      end
+    end
+  end
+end

data/lib/mindee/pdf.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'pdf/pdf_processing'

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

@@ -0,0 +1,5 @@
+inherit_from: ../../../.rubocop.yml
+
+Metrics/AbcSize:
+  Max: 75
+

data/lib/mindee/product/custom/custom_v1.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'custom_v1_document'
+require_relative 'custom_v1_page'
+
+module Mindee
+  module Product
+    module Custom
+      # Custom Document V1 prediction inference.
+      class CustomV1 < Mindee::Parsing::Common::Inference
+        @endpoint_name = ''
+        @endpoint_version = ''
+
+        # @param prediction [Hash]
+        def initialize(prediction)
+          super
+          @prediction = CustomV1Document.new(prediction['prediction'], nil)
+          @pages = []
+          prediction['pages'].each do |page|
+            @pages.push(CustomV1Page.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
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/custom/custom_v1_document.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+
+module Mindee
+  module Product
+    module Custom
+      # Custom Document V1 prediction
+      class CustomV1Document < Mindee::Parsing::Common::Prediction
+        # All value fields in the document
+        # @return [Hash<Symbol, Mindee::Parsing::Custom::ListField>]
+        attr_reader :fields
+        # All classifications in the document
+        # @return [Hash<Symbol, Mindee::Parsing::Custom::ClassificationField>]
+        attr_reader :classifications
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          super()
+          @fields = {}
+          @classifications = {}
+          prediction.each do |field_name, field_prediction|
+            field_sym = field_name.to_sym
+            set_field(field_sym, field_prediction, page_id)
+          end
+        end
+
+        # @return [String]
+        def to_s
+          out_str = String.new
+          @classifications.each do |name, info|
+            out_str << "\n:#{name}: #{info}".rstrip
+          end
+          @fields.each do |name, info|
+            out_str << "\n:#{name}: #{info}".rstrip
+          end
+          out_str[1..].to_s
+        end
+
+        private
+
+        # @param field_prediction [Hash]
+        def set_field(field_sym, field_prediction, page_id)
+          # Currently two types of fields possible in a custom API response:
+          # fields having a list of values, and classification fields.
+          # Here we use the fact that only value lists have the 'values' attribute.
+
+          if field_prediction.key? 'values'
+            @fields[field_sym] = Parsing::Custom::ListField.new(field_prediction, page_id)
+          elsif field_prediction.key? 'value'
+            @classifications[field_sym] = Parsing::Custom::ClassificationField.new(field_prediction)
+          else
+            throw 'Unknown API field type'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/custom/custom_v1_page.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'custom_v1_document'
+
+module Mindee
+  module Product
+    module Custom
+      # Custom Document V1 page.
+      class CustomV1Page < Mindee::Parsing::Common::Page
+        # @param prediction [Hash]
+        def initialize(prediction)
+          super(prediction)
+          @prediction = CustomV1PagePrediction.new(
+            prediction['prediction'],
+            prediction['id']
+          )
+        end
+      end
+
+      # Custom Document V1 page prediction.
+      class CustomV1PagePrediction < CustomV1Document
+        # @return [String]
+        def to_s
+          out_str = String.new
+          out_str << "\n#{super}"
+          out_str
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/eu/license_plate/license_plate_v1.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../../../parsing'
+require_relative 'license_plate_v1_document'
+require_relative 'license_plate_v1_page'
+
+module Mindee
+  module Product
+    module EU
+      module LicensePlate
+        # License Plate V1 prediction inference.
+        class LicensePlateV1 < Mindee::Parsing::Common::Inference
+          @endpoint_name = 'license_plates'
+          @endpoint_version = '1'
+
+          # @param prediction [Hash]
+          def initialize(prediction)
+            super
+            @prediction = LicensePlateV1Document.new(prediction['prediction'], nil)
+            @pages = []
+            prediction['pages'].each do |page|
+              @pages.push(LicensePlateV1Page.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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/eu/license_plate/license_plate_v1_document.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../../parsing'
+
+module Mindee
+  module Product
+    module EU
+      module LicensePlate
+        # License Plate V1 document prediction.
+        class LicensePlateV1Document < Mindee::Parsing::Common::Prediction
+          include Mindee::Parsing::Standard
+          # List of all license plates found in the image.
+          # @return [Array<Mindee::Parsing::Standard::TextField>]
+          attr_reader :license_plates
+
+          # @param prediction [Hash]
+          # @param page_id [Integer, nil]
+          def initialize(prediction, page_id)
+            super()
+            @license_plates = []
+            prediction['license_plates'].each do |item|
+              @license_plates.push(TextField.new(item, page_id))
+            end
+          end
+
+          # @return [String]
+          def to_s
+            license_plates = @license_plates.join("\n #{' ' * 16}")
+            out_str = String.new
+            out_str << "\n:License Plates: #{license_plates}".rstrip
+            out_str[1..].to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/product/eu/license_plate/license_plate_v1_page.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../../../parsing'
+require_relative 'license_plate_v1_document'
+
+module Mindee
+  module Product
+    module EU
+      module LicensePlate
+        # License Plate V1 page.
+        class LicensePlateV1Page < Mindee::Parsing::Common::Page
+          # @param prediction [Hash]
+          def initialize(prediction)
+            super(prediction)
+            @prediction = LicensePlateV1PagePrediction.new(
+              prediction['prediction'],
+              prediction['id']
+            )
+          end
+        end
+
+        # License Plate V1 page prediction.
+        class LicensePlateV1PagePrediction < LicensePlateV1Document
+          # @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/financial_document/financial_document_v1.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'financial_document_v1_document'
+require_relative 'financial_document_v1_page'
+
+module Mindee
+  module Product
+    module FinancialDocument
+      # Financial Document V1 prediction inference.
+      class FinancialDocumentV1 < Mindee::Parsing::Common::Inference
+        @endpoint_name = 'financial_document'
+        @endpoint_version = '1'
+
+        # @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
+        end
+      end
+    end
+  end
+end