mindee 3.19.1 → 4.0.0

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module Common
+      # HTTP request response.
+      class ApiRequest
+        # @return [Hash]
+        attr_reader :error
+        # @return [Array<String>]
+        attr_reader :ressources
+        # @return [RequestStatus, Symbol]
+        attr_reader :status
+        # @return [Integer]
+        attr_reader :status_code
+        # @return [String]
+        attr_reader :url
+
+        def initialize(server_response)
+          @error = server_response['error']
+          @ressources = server_response['ressources']
+
+          @status = if server_response['status'] == 'failure'
+                      RequestStatus::FAILURE
+                    elsif server_response['status'] == 'success'
+                      RequestStatus::SUCCESS
+                    else
+                      server_response['status']&.to_sym
+                    end
+          @status_code = server_response['status_code']
+          @url = server_response['url']
+        end
+      end
+    end
+  end
+end

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

@@ -1,21 +1,17 @@
 # frozen_string_literal: true
 
 require_relative 'document'
-require 'time'
+require_relative '../../logging'
 
 module Mindee
   module Parsing
     module Common
       # Potential values for queue in asynchronous calls.
       module JobStatus
-        # Document is waiting to be processed.
-        WAITING = :waiting
-        # Document is currently being parsed.
+        WAITING    = :waiting
         PROCESSING = :processing
-        # Document parsing is complete.
-        COMPLETED = :completed
-        # Job failed
-        FAILURE = :failed
+        COMPLETED  = :completed
+        FAILURE    = :failed
       end
 
       # Potential values for requests.
@@ -26,72 +22,6 @@ module Mindee
         SUCCESS = :success
       end
 
-      # Job (queue) information on async parsing.
-      class Job
-        # @return [String] Mindee ID of the document
-        attr_reader :id
-        # @return [Mindee::Parsing::Standard::DateField]
-        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
-
-      # HTTP request response.
-      class ApiRequest
-        # @return [Hash]
-        attr_reader :error
-        # @return [Array<String>]
-        attr_reader :ressources
-        # @return [RequestStatus, Symbol]
-        attr_reader :status
-        # @return [Integer]
-        attr_reader :status_code
-        # @return [String]
-        attr_reader :url
-
-        def initialize(server_response)
-          @error = server_response['error']
-          @ressources = server_response['ressources']
-
-          @status = if server_response['status'] == 'failure'
-                      RequestStatus::FAILURE
-                    elsif server_response['status'] == 'success'
-                      RequestStatus::SUCCESS
-                    else
-                      server_response['status']&.to_sym
-                    end
-          @status_code = server_response['status_code']
-          @url = server_response['url']
-        end
-      end
-
       # Wrapper class for all predictions (synchronous and asynchronous)
       class ApiResponse
         # @return [Mindee::Parsing::Common::Document, nil]
@@ -107,8 +37,9 @@ module Mindee
         # @param http_response [Hash]
         # @param raw_http [String]
         def initialize(product_class, http_response, raw_http)
+          logger.debug('Handling API response')
           @raw_http = raw_http.to_s
-          raise 'Invalid response format.' unless http_response.key?('api_request')
+          raise Errors::MindeeAPIError, 'Invalid response format.' unless http_response.key?('api_request')
 
           @api_request = Mindee::Parsing::Common::ApiRequest.new(http_response['api_request'])
 
@@ -121,27 +52,6 @@ module Mindee
           @job = Mindee::Parsing::Common::Job.new(http_response['job']) if http_response.key?('job')
         end
       end
-
-      # 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 = (product_class || Product::Generated::GeneratedV1)
-          @execution = Mindee::Parsing::Common::Execution.new(product_class, http_response['execution'])
-        end
-      end
     end
   end
 end

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

@@ -16,25 +16,29 @@ module Mindee
         attr_reader :id
         # @return [Mindee::Parsing::Common::Extras::Extras] Potential Extras fields sent back along the prediction.
         attr_reader :extras
-        # @return [Mindee::Parsing::Common::Ocr::Ocr, nil] OCR text results (limited availability)
+        # @return [Mindee::Parsing::Common::OCR::OCR, nil] OCR text results (limited availability)
         attr_reader :ocr
         # @return [Integer] Amount of pages of the document
         attr_reader :n_pages
 
-        # @param http_response [Hash]
-        # @return [Mindee::Parsing::Common::Ocr::Ocr]
+        # Loads the MVision OCR response.
+        # @param http_response [Hash] Full HTTP contents of the response.
+        # @return [Mindee::Parsing::Common::OCR::OCR]
         def self.load_ocr(http_response)
           ocr_prediction = http_response.fetch('ocr', nil)
           return nil if ocr_prediction.nil? || ocr_prediction.fetch('mvision-v1', nil).nil?
 
-          Ocr::Ocr.new(ocr_prediction)
+          OCR::OCR.new(ocr_prediction)
         end
 
-        def self.load_extras(http_response)
+        # Loads extras into the document prediction.
+        # @param http_response [Hash] Full HTTP contents of the response.
+        # @return [Mindee::Parsing::Common::OCR::OCR]
+        def self.extract_extras(http_response)
           extras_prediction = http_response['inference'].fetch('extras', nil)
           return nil if extras_prediction.nil? || extras_prediction.fetch('mvision-v1', nil).nil?
 
-          Extras::Extras::Extras.new(extras_prediction)
+          Mindee::Parsing::Common::Extras::Extras.new(extras_prediction)
         end
 
         # @param product_class [Mindee::Inference]
@@ -44,7 +48,7 @@ module Mindee
           @name = http_response['name']
           @inference = product_class.new(http_response['inference'])
           @ocr = self.class.load_ocr(http_response)
-          @extras = self.class.load_extras(http_response)
+          @extras = self.class.extract_extras(http_response)
           inject_full_text_ocr(http_response)
           @n_pages = http_response['n_pages']
         end
@@ -69,7 +73,7 @@ module Mindee
           end
           artificial_text_obj = { 'content' => full_text_ocr }
           if @extras.nil? || @extras.empty?
-            @extras = Extras::Extras.new({ 'full_text_ocr' => artificial_text_obj })
+            @extras = Mindee::Parsing::Common::Extras::Extras.new({ 'full_text_ocr' => artificial_text_obj })
           else
             @extras.add_artificial_extra({ 'full_text_ocr' => artificial_text_obj })
           end

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

@@ -30,7 +30,7 @@ module Mindee
         # @return [Time, nil]
         attr_reader :available_at
         # Reviewed fields and values.
-        # @return [Mindee::Product::Generated::GeneratedV1Document]
+        # @return [Mindee::Product::Universal::UniversalDocument]
         attr_reader :reviewed_prediction
         # Execution Status.
         # @return [String]
@@ -59,7 +59,9 @@ module Mindee
           @reviewed_at = Time.iso8601(http_response['reviewed_at']) if http_response['reviewed_at']
           @available_at = Time.iso8601(http_response['available_at']) if http_response['available_at']
           if http_response['reviewed_prediction']
-            @reviewed_prediction = GeneratedV1Document.new(http_response['reviewed_prediction'])
+            @reviewed_prediction = Mindee::Product::Universal::UniversalDocument.new(
+              http_response['reviewed_prediction']
+            )
           end
           @status = http_response['status']
           @type = http_response['type']

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

@@ -5,8 +5,14 @@ module Mindee
     module Common
       # Execution policy priority values.
       module ExecutionPriority
+        # Low priority execution.
+        # @return [Symbol] :low
         LOW = :low
+        # Medium priority execution.
+        # @return [Symbol] :low
         MEDIUM = :medium
+        # High priority execution.
+        # @return [Symbol] :low
         HIGH = :high
 
         # Sets the priority to one of its possibly values, defaults to nil otherwise.

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

@@ -13,12 +13,13 @@ module Mindee
           attr_reader :croppings
 
           def initialize(raw_prediction, page_id = nil)
-            @croppings = []
+            @croppings = [] # : Array[Mindee::Parsing::Standard::PositionField]
             raw_prediction['cropping']&.each do |crop|
               @croppings.push(Mindee::Parsing::Standard::PositionField.new(crop, page_id))
             end
           end
 
+          # @return [String]
           def to_s
             @croppings.map(&:to_s).join("\n           ")
           end

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

@@ -11,18 +11,23 @@ module Mindee
         class Extras
           # @return [CropperExtra, nil]
           attr_reader :cropper
-          # @return [FullTextOCRExtra, nil]
+          # @return [Mindee::Parsing::Common::Extras::FullTextOCRExtra, nil]
           attr_reader :full_text_ocr
 
           def initialize(raw_prediction)
-            @cropper = CropperExtra.new(raw_prediction['cropper']) if raw_prediction['cropper']
-            @full_text_ocr = FullTextOCRExtra.new(raw_prediction['full_text_ocr']) if raw_prediction['full_text_ocr']
+            if raw_prediction['cropper']
+              @cropper = Mindee::Parsing::Common::Extras::CropperExtra.new(raw_prediction['cropper'])
+            end
+            if raw_prediction['full_text_ocr']
+              @full_text_ocr = Mindee::Parsing::Common::Extras::FullTextOCRExtra.new(raw_prediction['full_text_ocr'])
+            end
 
             raw_prediction.each do |key, value|
               instance_variable_set("@#{key}", value) unless ['cropper', 'full_text_ocr'].include?(key)
             end
           end
 
+          # @return [String]
           def to_s
             out_str = String.new
             instance_variables.each do |var|
@@ -37,7 +42,7 @@ module Mindee
           def add_artificial_extra(raw_prediction)
             return unless raw_prediction['full_text_ocr']
 
-            @full_text_ocr << FullTextOCRExtra.new(raw_prediction)
+            @full_text_ocr << Mindee::Parsing::Common::Extras::FullTextOCRExtra.new(raw_prediction)
           end
         end
 

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

@@ -22,6 +22,7 @@ module Mindee
             @language = raw_prediction['language']
           end
 
+          # @return [String]
           def to_s
             @contents || ''
           end

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

@@ -9,7 +9,7 @@ module Mindee
       # Abstract class for prediction Inferences
       # Holds prediction for a page or entire document.
       class Inference
-        # @return [Boolean]
+        # @return [bool]
         attr_reader :is_rotation_applied
         # @return [Array<Mindee::Parsing::Common::Page>]
         attr_reader :pages
@@ -17,12 +17,29 @@ module Mindee
         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
+
+        @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 = []
+          @pages = [] # : Array[Page]
         end
 
         # @return [String]
@@ -34,8 +51,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" unless @pages.empty?
-          out_str << @pages.map(&:to_s).join("\n\n")
+          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

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

@@ -0,0 +1,46 @@
+# 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

@@ -3,18 +3,18 @@
 module Mindee
   module Parsing
     module Common
-      module Ocr
+      module OCR
         # Mindee Vision V1.
         class MVisionV1
           # List of pages.
-          # @return [Array<OcrPage>]
+          # @return [Array<OCRPage>]
           attr_reader :pages
 
           # @param prediction [Hash]
           def initialize(prediction)
-            @pages = []
+            @pages = [] # : Array[Mindee::Parsing::Common::OCR::OCRPage]
             prediction['pages'].each do |page_prediction|
-              @pages.push(OcrPage.new(page_prediction))
+              @pages.push(OCRPage.new(page_prediction))
             end
           end
 
@@ -33,9 +33,9 @@ module Mindee
           # 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]
+          # @return [Mindee::Parsing::Common::OCR::OCRLine]
           def reconstruct_vertically(coordinates, page_id, x_margin)
-            line_arr = OcrLine.new([])
+            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)

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

@@ -6,9 +6,9 @@ module Mindee
   module Parsing
     module Common
       # Ocr-specific parsing fields and options
-      module Ocr
+      module OCR
         # A single word.
-        class OcrWord
+        class OCRWord
           # The confidence score, value will be between 0.0 and 1.0
           # @return [Float]
           attr_accessor :confidence
@@ -34,24 +34,24 @@ module Mindee
         end
 
         # A list of words which are on the same line.
-        class OcrLine < Array
+        class OCRLine < Array
           # @param prediction [Hash, nil]
           # @param from_array [Array, nil]
           def initialize(prediction = nil, from_array = nil)
             if !prediction.nil?
-              super(prediction.map { |word_prediction| OcrWord.new(word_prediction) })
+              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]
+          # @return [OCRLine]
           def sort_on_x
             from_array = sort do |word1, word2|
               Geometry.get_min_max_x(word1.polygon).min <=> Geometry.get_min_max_x(word2.polygon).min
             end
-            OcrLine.new(nil, from_array)
+            OCRLine.new(nil, from_array)
           end
 
           # @return [String]
@@ -61,24 +61,24 @@ module Mindee
         end
 
         # OCR extraction for a single page.
-        class OcrPage
+        class OCRPage
           # All the words on the page, in semi-random order.
-          # @return [Array<OcrWord>]
+          # @return [Array<OCRWord>]
           attr_reader :all_words
-          # @return [Array<OcrLine>]
+          # @return [Array<OCRLine>]
           attr_reader :lines
 
           # @param prediction [Hash]
           def initialize(prediction)
-            @lines = []
-            @all_words = []
+            @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))
+              @all_words.push(OCRWord.new(word_prediction))
             end
           end
 
           # All the words on the page, ordered in lines.
-          # @return [Array<OcrLine>]
+          # @return [Array<OCRLine>]
           def all_lines
             @lines = to_lines if @lines.empty?
             @lines
@@ -99,19 +99,19 @@ module Mindee
           private
 
           # Helper function that iterates through all the words and compares them to a candidate
-          # @param sorted_words [Array<OcrWord>]
-          # @param current [OcrWord]
+          # @param sorted_words [Array<OCRWord>]
+          # @param current [OCRWord]
           # @param indexes [Array<Integer>]
-          # @param lines [Array<OcrLine>]
+          # @param lines [Array<OCRLine>]
           def parse_one(sorted_words, current, indexes, lines)
-            line = OcrLine.new([])
+            line = OCRLine.new([])
             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 = OCRLine.new([])
                 line.push(word)
               elsif words_on_same_line?(current, word)
                 line.push(word)
@@ -122,11 +122,11 @@ module Mindee
           end
 
           # Order all the words on the page into lines.
-          # @return [Array<OcrLine>]
+          # @return [Array<OCRLine>]
           def to_lines
             current = nil
-            indexes = []
-            lines = []
+            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 }
@@ -138,25 +138,25 @@ module Mindee
           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 [Boolean]
+          # @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)
+            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
+        class OCR
           # Mindee Vision v1 results.
-          # @return [Mindee::Parsing::Common::Ocr::MVisionV1]
+          # @return [Mindee::Parsing::Common::OCR::MVisionV1]
           attr_reader :mvision_v1
 
           # @param prediction [Hash]
           def initialize(prediction)
-            @mvision_v1 = MVisionV1.new(prediction['mvision-v1'])
+            @mvision_v1 = Mindee::Parsing::Common::OCR::MVisionV1.new(prediction['mvision-v1'])
           end
 
           # @return [String]
@@ -169,7 +169,7 @@ module Mindee
           # 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]
+          # @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

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

@@ -10,7 +10,7 @@ module Mindee
       # 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).
+        # ID of the page (as given by the API).
         # @return [Integer]
         attr_reader :page_id
         # Orientation of the page.
@@ -26,8 +26,10 @@ module Mindee
         # @param raw_prediction [Hash]
         def initialize(raw_prediction)
           @page_id = raw_prediction['id']
-          @orientation = Orientation.new(raw_prediction['orientation'], @page_id)
-          @extras = Extras::Extras.new(raw_prediction['extras']) unless raw_prediction['extras'].nil?
+          @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]

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

@@ -9,6 +9,8 @@ module Mindee
         def to_s
           ''
         end
+
+        def initialize(_ = nil, _ = nil); end
       end
     end
   end