mindee 4.13.0 → 5.0.0.beta1

data/lib/mindee/parsing/common/extras/rag_extra.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  module Parsing
-    module Common
-      module Extras
-        # Retrieval-Augmented Generation extra.
-        class RAGExtra
-          # ID of the matching document
-          # @return [String, nil]
-          attr_reader :matching_document_id
-
-          def initialize(raw_prediction)
-            @matching_document_id = raw_prediction['matching_document_id'] if raw_prediction['matching_document_id']
-          end
-
-          # String representation.
-          # @return [String]
-          def to_s
-            @matching_document_id || ''
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/common/inference.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'product'
-
-module Mindee
-  module Parsing
-    # Common fields used for most documents.
-    module Common
-      # Abstract class for prediction Inferences
-      # Holds prediction for a page or entire document.
-      class Inference
-        # @return [bool]
-        attr_reader :is_rotation_applied
-        # @return [Array<Mindee::Parsing::Common::Page>]
-        attr_reader :pages
-        # @return [Mindee::Parsing::Common::Prediction]
-        attr_reader :prediction
-        # @return [Mindee::Parsing::Common::Product]
-        attr_reader :product
-        # 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
-        # @return [Mindee::Parsing::Common::Extras::Extras] Potential Extras fields sent back along the prediction.
-        attr_reader :extras
-
-        @endpoint_name = nil
-        @endpoint_version = nil
-        @has_async = false
-        @has_sync = false
-
-        # @param raw_prediction [Hash]
-        def initialize(raw_prediction)
-          @is_rotation_applied = raw_prediction['is_rotation_applied']
-          @product = Product.new(raw_prediction['product'])
-          @pages = [] # : Array[Page]
-          @extras = Extras::Extras.new(raw_prediction['extras']) if raw_prediction.include?('extras')
-        end
-
-        # @return [String]
-        def to_s
-          is_rotation_applied = @is_rotation_applied ? 'Yes' : 'No'
-          out_str = String.new
-          out_str << "Inference\n#########"
-          out_str << "\n:Product: #{@product.name} v#{@product.version}"
-          out_str << "\n:Rotation applied: #{is_rotation_applied}"
-          out_str << "\n\nPrediction\n=========="
-          out_str << "\n#{"#{@prediction}\n" if @prediction.to_s.size.positive?}"
-          if @pages.any? { |page| !page.prediction.nil? }
-            out_str << "\nPage Predictions\n================\n\n"
-            out_str << @pages.map(&:to_s).join("\n\n")
-          end
-          out_str.rstrip!
-          out_str
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/common/job.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-
-module Mindee
-  module Parsing
-    module Common
-      # Job (queue) information on async parsing.
-      class Job
-        # @return [String] Mindee ID of the document
-        attr_reader :id
-        # @return [Time]
-        attr_reader :issued_at
-        # @return [Time, nil]
-        attr_reader :available_at
-        # @return [JobStatus, Symbol]
-        attr_reader :status
-        # @return [Integer, nil]
-        attr_reader :millisecs_taken
-        # @return [Hash, nil]
-        attr_reader :error
-
-        # @param http_response [Hash]
-        def initialize(http_response)
-          @id = http_response['id']
-          @error = http_response['error']
-          @issued_at = Time.iso8601(http_response['issued_at'])
-          if http_response.key?('available_at') && !http_response['available_at'].nil?
-            @available_at = Time.iso8601(http_response['available_at'])
-            @millisecs_taken = (1000 * (@available_at.to_time - @issued_at.to_time).to_f).to_i
-          end
-          @status = case http_response['status']
-                    when 'waiting'
-                      JobStatus::WAITING
-                    when 'processing'
-                      JobStatus::PROCESSING
-                    when 'completed'
-                      JobStatus::COMPLETED
-                    else
-                      http_response['status']&.to_sym
-                    end
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/common/ocr/mvision_v1.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  module Parsing
-    module Common
-      module OCR
-        # Mindee Vision V1.
-        class MVisionV1
-          # List of pages.
-          # @return [Array<OCRPage>]
-          attr_reader :pages
-
-          # @param prediction [Hash]
-          def initialize(prediction)
-            @pages = [] # : Array[Mindee::Parsing::Common::OCR::OCRPage]
-            prediction['pages'].each do |page_prediction|
-              @pages.push(OCRPage.new(page_prediction))
-            end
-          end
-
-          # @return [String]
-          def to_s
-            out_str = String.new
-            @pages.map do |page|
-              out_str << "\n"
-              out_str << page.to_s
-            end
-            out_str.strip
-          end
-
-          # Constructs a line from a column, located underneath given coordinates
-          # @param coordinates [Array<Mindee::Geometry::Point>] Polygon or bounding box where the reconstruction should
-          # start.
-          # @param page_id [Integer] ID of the page to start at
-          # @param x_margin [Float] Margin of misalignment for the x coordinate.
-          # @return [Mindee::Parsing::Common::OCR::OCRLine]
-          def reconstruct_vertically(coordinates, page_id, x_margin)
-            line_arr = OCRLine.new([])
-            @pages[page_id].all_lines.each do |line|
-              line.each do |word|
-                line_arr.push(word) if Geometry.below?(word.polygon, coordinates, x_margin / 2, x_margin * 2)
-              end
-            end
-            line_arr
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/common/ocr/ocr.rb

@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'mvision_v1'
-
-module Mindee
-  module Parsing
-    module Common
-      # Ocr-specific parsing fields and options
-      module OCR
-        # A single word.
-        class OCRWord
-          # The confidence score, value will be between 0.0 and 1.0
-          # @return [Float]
-          attr_reader :confidence
-          # @return [String]
-          attr_reader :text
-          # @return [Mindee::Geometry::Quadrilateral]
-          attr_reader :bounding_box
-          # @return [Mindee::Geometry::Polygon]
-          attr_reader :polygon
-
-          # @param prediction [Hash]
-          def initialize(prediction)
-            @text = prediction['text']
-            @confidence = prediction['confidence']
-            @polygon = Mindee::Geometry::Polygon.new(prediction['polygon'])
-            @bounding_box = Geometry.get_bounding_box(@polygon) unless @polygon.nil? || @polygon.empty?
-          end
-
-          # @return [String]
-          def to_s
-            @text.to_s
-          end
-        end
-
-        # A list of words which are on the same line.
-        class OCRLine < Array
-          # @param prediction [Hash, nil]
-          # @param from_array [Array<OCRWord>, nil]
-          def initialize(prediction = nil, from_array = nil)
-            if !prediction.nil?
-              super(prediction.map { |word_prediction| OCRWord.new(word_prediction) })
-            elsif !from_array.nil?
-              super(from_array)
-            end
-          end
-
-          # Sort the words on the line from left to right.
-          # @return [OCRLine]
-          def sort_on_x
-            from_array = sort_by { |word| Geometry.get_min_max_x(word.polygon).min }
-            OCRLine.new(nil, from_array)
-          end
-
-          # @return [String]
-          def to_s
-            each(&:to_s).join(' ')
-          end
-        end
-
-        # OCR extraction for a single page.
-        class OCRPage
-          # All the words on the page, in semi-random order.
-          # @return [Array<OCRWord>]
-          attr_reader :all_words
-          # @return [Array<OCRLine>]
-          attr_reader :lines
-
-          # @param prediction [Hash]
-          def initialize(prediction)
-            @lines = [] # : Array[Mindee::Parsing::Common::OCR::OCRLine]
-            @all_words = [] # : Array[Mindee::Parsing::Common::OCR::OCRWord]
-            prediction['all_words'].each do |word_prediction|
-              @all_words.push(OCRWord.new(word_prediction))
-            end
-          end
-
-          # All the words on the page, ordered in lines.
-          # @return [Array<OCRLine>]
-          def all_lines
-            @lines = to_lines if @lines.empty?
-            @lines
-          end
-
-          # @return [String]
-          def to_s
-            lines = all_lines
-            return '' if lines.empty?
-
-            out_str = String.new
-            lines.map do |line|
-              out_str << "#{line}\n" unless line.to_s.strip.empty?
-            end
-            out_str.strip
-          end
-
-          private
-
-          # Helper function that iterates through all the words and compares them to a candidate
-          # @param sorted_words [Array<OCRWord>]
-          # @param current [OCRWord]
-          # @param indexes [Array<Integer>]
-          # @param lines [Array<OCRLine>]
-          def parse_one(sorted_words, current, indexes, lines)
-            line = OCRLine.new(nil, [])
-            sorted_words.each_with_index do |word, idx|
-              next if indexes.include?(idx)
-
-              if current.nil?
-                current = word
-                indexes.push(idx)
-                line = OCRLine.new([])
-                line.push(word)
-              elsif words_on_same_line?(current, word)
-                line.push(word)
-                indexes.push(idx)
-              end
-            end
-            lines.push(line.sort_on_x) if line.any?
-          end
-
-          # Order all the words on the page into lines.
-          # @return [Array<OCRLine>]
-          def to_lines
-            current = nil
-            indexes = [] # : Array[Integer]
-            lines = [] # : Array[Mindee::Parsing::Common::OCR::OCRLine]
-
-            # make sure words are sorted from top to bottom
-            all_words = @all_words.sort_by { |word| Geometry.get_min_max_y(word.polygon).min }
-            all_words.each do
-              parse_one(all_words, current, indexes, lines)
-              current = nil
-            end
-            lines
-          end
-
-          # Determine if two words are on the same line.
-          # @param current_word [Mindee::Parsing::Common::OCR::OCRWord]
-          # @param next_word [Mindee::Parsing::Common::OCR::OCRWord]
-          # @return [bool]
-          def words_on_same_line?(current_word, next_word)
-            current_in_next = current_word.polygon.point_in_y?(next_word.polygon.centroid)
-            next_in_current = next_word.polygon.point_in_y?(current_word.polygon.centroid) unless current_word.nil?
-            current_in_next || next_in_current
-          end
-        end
-
-        # OCR extraction from the entire document.
-        class OCR
-          # Mindee Vision v1 results.
-          # @return [Mindee::Parsing::Common::OCR::MVisionV1]
-          attr_reader :mvision_v1
-
-          # @param prediction [Hash]
-          def initialize(prediction)
-            @mvision_v1 = Mindee::Parsing::Common::OCR::MVisionV1.new(prediction['mvision-v1'])
-          end
-
-          # @return [String]
-          def to_s
-            @mvision_v1.to_s
-          end
-
-          # Constructs a line from a column, located underneath given coordinates
-          # @param coordinates [Array<Mindee::Geometry::Point>] Polygon or bounding box where the reconstruction should
-          # start
-          # @param page_id [Integer] ID of the page to start at
-          # @param x_margin [Float] Margin of misalignment for the x coordinate (default 10%)
-          # @return [Mindee::Parsing::Common::OCR::OCRLine]
-          def reconstruct_vertically(coordinates, page_id, x_margin = 0.05)
-            @mvision_v1.reconstruct_vertically(coordinates, page_id, x_margin)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/common/orientation.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  module Parsing
-    module Common
-      # Page orientation
-      class Orientation
-        # @return [Integer, nil]
-        attr_reader :page_id
-        # A prediction among these 3 possible outputs:
-        #   * 0 degrees: the page is already upright
-        #   * 90 degrees: the page must be rotated clockwise to be upright
-        #   * 270 degrees: the page must be rotated counterclockwise to be upright
-        # @return [Integer, nil]
-        attr_reader :value
-
-        # @param prediction [Hash]
-        # @param page_id [Integer, nil]
-        def initialize(prediction, page_id)
-          @value = prediction['value']
-          @page_id = page_id
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/common/page.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'product'
-require_relative 'extras'
-
-module Mindee
-  module Parsing
-    # Common fields used for most documents.
-    module Common
-      # Abstract wrapper class for prediction Pages
-      # Holds prediction for a page as well as it's orientation and  id.
-      class Page
-        # ID of the page (as given by the API).
-        # @return [Integer]
-        attr_reader :page_id
-        # Orientation of the page.
-        # @return [Mindee::Parsing::Common::Orientation]
-        attr_reader :orientation
-        # Page prediction
-        # @return [Mindee::Parsing::Common::Prediction]
-        attr_reader :prediction
-        # Additional page-level information.
-        # @return [Mindee::Parsing::Common::Extras::Extras]
-        attr_reader :extras
-
-        # @param raw_prediction [Hash]
-        def initialize(raw_prediction)
-          @page_id = raw_prediction['id']
-          @orientation = Mindee::Parsing::Common::Orientation.new(raw_prediction['orientation'], @page_id)
-          return if raw_prediction['extras'].nil?
-
-          @extras = Mindee::Parsing::Common::Extras::Extras.new(raw_prediction['extras'])
-        end
-
-        # @return [String]
-        def to_s
-          out_str = String.new
-          title = "Page #{@page_id}"
-          out_str << "#{title}\n"
-          out_str << ('-' * title.size)
-          out_str << @prediction.to_s
-          out_str
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/common/prediction.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  module Parsing
-    module Common
-      # Abstract class for all predictions
-      class Prediction
-        # @return [String]
-        def to_s
-          ''
-        end
-
-        def initialize(_ = nil, _ = nil); end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/common/product.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  module Parsing
-    module Common
-      # Product information
-      class Product
-        # @return [String] Name of the product.
-        attr_reader :name
-        # @return [String?] Type of product.
-        attr_reader :type
-        # @return [String] Product version.
-        attr_reader :version
-
-        # @param prediction [Hash]
-        def initialize(prediction)
-          @name = prediction['name']
-          @type = prediction['type']
-          @version = prediction['version']
-        end
-      end
-    end
-  end
-end

data/lib/mindee/parsing/common/workflow_response.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  module Parsing
-    module Common
-      # Represents the server response after a document is sent to a workflow.
-      class WorkflowResponse
-        # Set the prediction model used to parse the document.
-        # The response object will be instantiated based on this parameter.
-        # @return [Mindee::Parsing::Common::Execution]
-        attr_reader :execution
-        # @return [Mindee::Parsing::Common::ApiRequest]
-        attr_reader :api_request
-        # @return [String]
-        attr_reader :raw_http
-
-        # @param http_response [Hash]
-        # @param product_class [Mindee::Inference]
-        def initialize(product_class, http_response, raw_http)
-          @raw_http = raw_http.to_s
-          @api_request = Mindee::Parsing::Common::ApiRequest.new(http_response['api_request'])
-          product_class ||= Mindee::Product::Universal::Universal
-          @execution = Mindee::Parsing::Common::Execution.new(product_class, http_response['execution'])
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../geometry'
-
-module Mindee
-  module Parsing
-    module Standard
-      # Base BaseField object, upon which fields and feature fields are built
-      class AbstractField
-        # @return [Mindee::Geometry::Quadrilateral, nil]
-        attr_reader :bounding_box
-        # @return [Mindee::Geometry::Polygon, nil]
-        attr_reader :polygon
-        # @return [Integer, nil]
-        attr_reader :page_id
-        # The confidence score, value will be between 0.0 and 1.0
-        # @return [Float, nil]
-        attr_accessor :confidence
-
-        # @param prediction [Hash]
-        # @param page_id [Integer, nil]
-        def initialize(prediction, page_id)
-          @confidence = prediction['confidence'] if prediction.key?('confidence')
-          @polygon = Mindee::Geometry::Polygon.new(prediction['polygon']) if prediction.key?('polygon')
-          @bounding_box = Geometry.get_bounding_box(@polygon) unless @polygon.nil? || @polygon.empty?
-          @page_id = page_id || prediction['page_id']
-        end
-
-        # @return [String]
-        def to_s
-          @value ? @value.to_s : ''
-        end
-
-        # Multiply all the Mindee::Parsing::Standard::BaseField confidences in the array.
-        # @return [Float]
-        def self.array_confidence(field_array)
-          product = 1
-          field_array.each do |field|
-            return 0.0 if field.confidence.nil?
-
-            product *= field.confidence
-          end
-          product.to_f
-        end
-
-        # Add all the Mindee::Parsing::Standard::BaseField values in the array.
-        # @return [Float]
-        def self.array_sum(field_array)
-          arr_sum = 0
-          field_array.each do |field|
-            return 0.0 if field.value.nil?
-
-            arr_sum += field.value
-          end
-          arr_sum.to_f
-        end
-
-        # @param value [Float]
-        # @param min_precision [Integer]
-        # @return [String]
-        def self.float_to_string(value, min_precision = 2)
-          return String.new if value.nil?
-
-          precision = value.to_f.to_s.split('.')[1].size
-          precision = [precision, min_precision].max
-          format_string = "%.#{precision}f"
-          format(format_string, value)
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'string_field'
-
-module Mindee
-  module Parsing
-    module Standard
-      # Represents physical-address information.
-      class AddressField < Mindee::Parsing::Standard::StringField
-        # Street number
-        # @return [String, nil]
-        attr_reader :street_number
-        # Street name
-        # @return [String, nil]
-        attr_reader :street_name
-        # PO Box number
-        # @return [String, nil]
-        attr_reader :po_box
-        # Address complement
-        # @return [String, nil]
-        attr_reader :address_complement
-        #  City name.
-        # @return [String, nil]
-        attr_reader :city
-        # Postal or ZIP code.
-        # @return [String, nil]
-        attr_reader :postal_code
-        # State, province or region.
-        # @return [String, nil]
-        attr_reader :state
-        # Country.
-        # @return [String, nil]
-        attr_reader :country
-
-        def initialize(prediction, page_id = nil, reconstructed: false)
-          super
-          @street_number = prediction['street_number']
-          @street_name = prediction['street_name']
-          @po_box = prediction['po_box']
-          @address_complement = prediction['address_complement']
-          @city = prediction['city']
-          @postal_code = prediction['postal_code']
-          @state = prediction['state']
-          @country = prediction['country']
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_field'
-
-module Mindee
-  module Parsing
-    module Standard
-      # Represents tax information.
-      class AmountField < BaseField
-        # Amount value as 3 decimal float
-        # @return [Float, nil]
-        attr_reader :value
-
-        def initialize(prediction, page_id, reconstructed: false)
-          super
-          @value = @value.to_f.round(3).to_f unless @value.to_s.empty?
-        end
-
-        # @return [String]
-        def to_s
-          @value.nil? ? '' : BaseField.float_to_string(@value.to_f)
-        end
-      end
-    end
-  end
-end