mindee 3.12.0 → 3.13.0

data/lib/mindee/extraction/tax_extractor.rb

@@ -1,322 +1,3 @@
 # frozen_string_literal: true
 
-require_relative 'ocr_extractor'
-
-module Mindee
-  module Extraction
-    # Tax extractor class
-    class TaxExtractor < OcrExtractor
-      # Extracts the most relevant candidate.
-      # @param candidates [Array<Hash>] a candidate for the tax.
-      # @param tax_names [Array<String>] list of all possible names the tax can have.
-      # @return [Hash, nil]
-      def self.pick_best(candidates, tax_names)
-        return candidates[0] if candidates.size == 1
-        return nil if candidates.empty?
-
-        picked = 0
-        picked_score = 0
-
-        candidates.each_with_index do |candidate, i|
-          next unless valid_candidate?(candidate, tax_names)
-
-          sum_fields_score = calculate_score(candidate, i)
-
-          if picked_score < sum_fields_score
-            picked_score = sum_fields_score
-            picked = i
-          end
-        end
-
-        candidates[picked]
-      end
-
-      # Checks whether a tax code has been properly read. Shouldn't trigger except in case of very specific regex breaks
-      # due to unsupported diacritics.
-      # @param candidate [Hash] A candidate for the tax.
-      # @param tax_names [Array<String>] list of all possible names the tax can have.
-      # @return [Boolean]
-      def self.valid_candidate?(candidate, tax_names)
-        return false if tax_names.empty? || candidate.nil? || candidate['code'].nil?
-
-        tax_names.each do |tax_name|
-          return true if remove_accents(tax_name.downcase) == remove_accents(candidate['code'].downcase)
-        end
-        false
-      end
-
-      # [Experimental] computes the score of a valid candidate for a tax.
-      # @param candidate [Hash] A candidate for the tax.
-      # @param index [Integer]
-      def self.calculate_score(candidate, index)
-        score = index + 1
-        unless candidate['rate'].nil?
-          score += 1
-          score -= 2 if candidate['rate'] > 100
-          score -= 1 if candidate['rate'] > 30
-        end
-        score += 4 unless candidate['value'].nil?
-        score += 1 unless candidate['base'].nil?
-        score
-      end
-
-      # Curates tax values based on simple rules to avoid improbable data
-      # @param found_hash [Hash] Hash of currently retrieved values
-      # @param min_rate_percentage [Integer] Minimum allowed rate on the tax.
-      # @param max_rate_percentage [Integer] Maximum allowed rate on the tax.
-      # @return [Hash]
-      def self.curate_values(found_hash, min_rate_percentage, max_rate_percentage)
-        reconstructed_hash = { 'code' => nil, 'page_id' => nil, 'rate' => nil, 'base' => nil, 'value' => nil }
-        return reconstructed_hash if found_hash.nil?
-
-        reconstructed_hash['code'] =
-          found_hash['code'].nil? ? found_hash['code'] : found_hash['code'].sub(%r{\s*\.*\s*$}, '')
-
-        if found_hash['rate'] && found_hash['rate'] < 1 && (found_hash['rate']).positive?
-          found_hash['rate'] =
-            found_hash['rate'] * 100
-        end
-        found_hash = swap_rates_if_needed(found_hash, min_rate_percentage, max_rate_percentage)
-        found_hash = decimate_rates_if_needed(found_hash)
-        found_hash = fix_rate(found_hash)
-        reconstructed_hash['rate'] = found_hash['rate']
-        set_base_and_value(reconstructed_hash, found_hash)
-      end
-
-      # Swaps the rate with base or value if rate is out of bounds
-      # @param found_hash [Hash] Hash of currently retrieved values
-      # @param min_rate_percentage [Integer] Minimum allowed rate on the tax.
-      # @param max_rate_percentage [Integer] Maximum allowed rate on the tax.
-      # @return [Hash]
-      def self.swap_rates_if_needed(found_hash, min_rate_percentage, max_rate_percentage)
-        if found_hash['rate'] && (found_hash['rate'] > max_rate_percentage || found_hash['rate'] < min_rate_percentage)
-          if valid_percentage?(found_hash['base'], min_rate_percentage, max_rate_percentage)
-            found_hash['rate'], found_hash['base'] = found_hash['base'], found_hash['rate']
-          elsif valid_percentage?(found_hash['value'], min_rate_percentage, max_rate_percentage)
-            found_hash['rate'], found_hash['value'] = found_hash['value'], found_hash['rate']
-          end
-        end
-        found_hash
-      end
-
-      # Rates can't be negative if set.
-      # @param found_hash [Hash] Hash of currently retrieved values
-      def self.fix_rate(found_hash)
-        found_hash['rate'] = found_hash['rate'].abs unless found_hash['rate'].nil?
-        found_hash
-      end
-
-      # Swaps the rate with base or value if rate is out of bounds
-      # @param found_hash [Hash] Hash of currently retrieved values
-      # @return [Hash]
-      def self.decimate_rates_if_needed(found_hash)
-        if found_hash['rate'] && found_hash['rate'] > 100
-          if !found_hash['base'].nil? && found_hash['rate'] > found_hash['base']
-            found_hash['rate'], found_hash['base'] = found_hash['base'], found_hash['rate']
-          elsif !found_hash['value'].nil? && found_hash['rate'] > found_hash['value']
-            found_hash['rate'], found_hash['value'] = found_hash['value'], found_hash['rate']
-          end
-        end
-        found_hash
-      end
-
-      # Sets the base and value in the reconstructed hash based on certain conditions
-      # @param reconstructed_hash [Hash] Hash being reconstructed with new values
-      # @param found_hash [Hash] Hash of currently retrieved values
-      # @return [Hash]
-      def self.set_base_and_value(reconstructed_hash, found_hash)
-        if found_hash['base'].nil?
-          reconstructed_hash['base'] = found_hash['base']
-          reconstructed_hash['value'] = found_hash['value']
-        elsif found_hash['value'].nil? && found_hash['base'] < found_hash['value']
-          reconstructed_hash['base'] = found_hash['value']
-          reconstructed_hash['value'] = found_hash['base']
-        else
-          reconstructed_hash['value'] = found_hash['value']
-        end
-        reconstructed_hash
-      end
-
-      # Extracts a single custom type of tax.
-      # For the sake of simplicity, this only extracts the first example, unless specifically instructed otherwise.
-      # @param ocr_result [Mindee::Parsing::Common::Ocr::Ocr] result of the OCR.
-      # @param tax_names [Array<String>] list of all possible names the tax can have.
-      # @param min_rate_percentage [Integer] Minimum allowed rate on the tax.
-      # @param max_rate_percentage [Integer] Maximum allowed rate on the tax.
-      # @return [Mindee::Parsing::Standard::TaxField, nil]
-      def self.extract_custom_tax(ocr_result, tax_names, min_rate_percentage = 0, max_rate_percentage = 100)
-        return nil if ocr_result.is_a?(Mindee::Parsing::Common::Ocr) || tax_names.empty?
-
-        tax_names.sort!
-        found_hash = pick_best(extract_horizontal_tax(ocr_result, tax_names), tax_names)
-        # a tax is considered found horizontally if it has a value, otherwise it is vertical
-        if found_hash.nil? || found_hash['value'].nil?
-          found_hash = extract_vertical_tax(ocr_result, tax_names,
-                                            found_hash)
-        end
-        found_hash = curate_values(found_hash, min_rate_percentage, max_rate_percentage)
-
-        return if found_hash.nil? || found_hash.empty?
-
-        create_tax_field(found_hash)
-      end
-
-      # Creates a tax field from a given hash.
-      # @param found_hash [Hash] Hash of currently retrieved values
-      # @return [Mindee::Parsing::Standard::TaxField]
-      def self.create_tax_field(found_hash)
-        Mindee::Parsing::Standard::TaxField.new(
-          found_hash,
-          found_hash.key?('page_id') ? found_hash['page_id'] : nil
-        )
-      end
-
-      # Extracts the rate and code, if found, from matches into the found_hash.
-      # @param matches [MatchData] RegEx matches of the values for taxes
-      # @param found_hash [Hash] Hash of currently retrieved values
-      # @param percent_first [Boolean] Whether the percentage was found before or after the tax name.
-      # @return [Hash]
-      def self.extract_percentage_from_tax(matches, found_hash, percent_first)
-        if percent_first
-          found_hash['code'] = matches[2].strip unless matches[2].nil?
-          found_hash['rate'] = parse_amount(matches[1].gsub('%', '')) unless matches[1].nil?
-        else
-          found_hash['code'] = matches[1].strip unless matches[1].nil?
-          found_hash['rate'] = parse_amount(matches[2].gsub('%', '')) unless matches[2].nil?
-        end
-        found_hash
-      end
-
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
-
-      # Extracts the basis and value of a tax from regex matches, independent of the order.
-      # @param matches [MatchData] RegEx matches of the values for taxes
-      # @param found_hash [Hash] Hash of currently retrieved values
-      # @return [Hash]
-      def self.extract_basis_and_value(matches, found_hash)
-        if matches[4].nil? && !matches[3].nil?
-          found_hash['value'] = parse_amount(matches[3]) unless matches[3].nil?
-        elsif matches[3].nil? && !matches[4].nil?
-          found_hash['value'] = parse_amount(matches[4]) unless matches[4].nil?
-        elsif !matches[3].nil? && !matches[4].nil?
-          found_hash['base'] = parse_amount(matches[3]) unless matches[3].nil?
-          found_hash['value'] = parse_amount(matches[4]) unless matches[4].nil?
-        end
-        found_hash
-      end
-
-      # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
-
-      # Extracts tax information from a horizontal line.
-      # @param line [String] Line to be processed.
-      # @param pattern [Regexp] RegEx pattern to search the line with.
-      # @param percent_first [Boolean] Whether the percentage was found before or after the tax name.
-      # @return [Hash]
-      def self.extract_tax_from_horizontal_line(line, pattern, page_id, percent_first)
-        found_hash = {}
-
-        matches = line.match(pattern)
-
-        # Edge case for when the tax is split-up between two pages, we'll consider that
-        # the answer belongs to the first one.
-        found_hash['page_id'] = page_id unless found_hash.key?('page_id')
-        return found_hash if matches.nil?
-
-        found_hash = extract_percentage_from_tax(matches, found_hash, percent_first)
-        extract_basis_and_value(matches, found_hash)
-      end
-
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
-
-      # Processes a horizontal line for tax extraction. Returns a hash of collected values.
-      # @param ocr_result [Mindee::Parsing::Common::Ocr::Ocr] Processed OCR results.
-      # @param tax_names [Array<String>] Possible tax names candidates.
-      # @return [Array<Hash>]
-      def self.extract_horizontal_tax(ocr_result, tax_names)
-        candidates = [{ 'code' => nil, 'value' => nil, 'base' => nil, 'rate' => nil }]
-        linear_pattern_percent_first = %r{
-          ((?:\s*-\s*)?(?:\d*[.,])*\d+[ ]?%?|%?[ ]?(?:\s*-\s*)?(?:\d*[.,])*\d+)?[ .]?
-          ([a-zA-ZÀ-ÖØ-öø-ÿ .]*[a-zA-ZÀ-ÖØ-öø-ÿ]?)[ .]?
-          ((?:\s*-\s*)?(?:\d*[.,])+\d{2,})?[ .]*
-          ((?:\s*-\s*)?(\d*[.,])*\d{2,})?
-        }x
-        linear_pattern_percent_second = %r{
-          ([a-zA-ZÀ-ÖØ-öø-ÿ .]*[a-zA-ZÀ-ÖØ-öø-ÿ]?)[ .]*
-          ((?:\s*-\s*)?(?:\d*[.,])*\d+[ ]?%?|%?[ ]?(?:\s*-\s*)?(?:\d*[.,])*\d+)?[ .]?
-          ((?:\s*-\s*)?(?:\d*[.,])+\d{2,})?[ .]*
-          ((?:\s*-\s*)?(\d*[.,])*\d{2,})?
-        }x
-        ocr_result.mvision_v1.pages.each.with_index do |page, page_id|
-          page.all_lines.each do |line|
-            clean_line = remove_currency_symbols(line.to_s.scrub.gsub(%r{[+(\[)\]¿?*_]}, '')).gsub(%r{\.{2,}}, ' ')
-                                                                                             .gsub(%r{ +}, ' ').strip
-
-            next if match_index(clean_line, tax_names).nil?
-
-            unless clean_line.match(linear_pattern_percent_second).nil?
-              candidates.append(extract_tax_from_horizontal_line(clean_line[match_index(clean_line, tax_names)..],
-                                                                 linear_pattern_percent_second, page_id, false))
-            end
-            if clean_line.include?('%') && !clean_line.match(linear_pattern_percent_first).nil?
-              candidates.append(extract_tax_from_horizontal_line(clean_line[clean_line.index(%r{\d*[.,]?\d* ?%})..],
-                                                                 linear_pattern_percent_first, page_id, true))
-            elsif !clean_line.match(linear_pattern_percent_first).nil?
-              candidates.append(extract_tax_from_horizontal_line(clean_line,
-                                                                 linear_pattern_percent_first, page_id, true))
-            end
-          end
-        end
-        candidates
-      end
-      # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
-
-      # Processes a vertical reconstructed line for tax extraction. Returns a hash of collected values.
-      # @param line [Mindee::Parsing::Common::Ocr::OcrLine] Processed OCR results.
-      # @param found_hash [Hash] Hash containing previously found values, if any.
-      # @return [Hash]
-      def self.extract_vertical_tax_values(line, found_hash)
-        amounts = []
-        line.each do |reconstructed_word|
-          amounts.push(parse_amount(reconstructed_word.text)) unless parse_amount(reconstructed_word.text).nil?
-        end
-        if amounts.length == 1 && !found_hash.key?('value')
-          found_hash['value'] = amounts[0]
-        else
-          found_hash['rate'] = amounts[0] if found_hash['rate'].nil?
-          found_hash['value'] = amounts[1] if found_hash['value'].nil?
-        end
-        found_hash
-      end
-
-      # Extracts tax data from a vertical reconstructed row.
-      # @param ocr_result [Mindee::Parsing::Common::Ocr] OCR raw results
-      # @param tax_names [Array<String>] Array of possible names a tax can have
-      # @param found_hash [Hash] Hash of currently retrieved values
-      def self.extract_vertical_tax(ocr_result, tax_names, found_hash)
-        found_hash = { 'code' => nil, 'page_id' => nil } if found_hash.nil?
-
-        ocr_result.mvision_v1.pages.each_with_index do |page, page_id|
-          page.all_words.each do |word|
-            next if match_index(word.text, tax_names).nil?
-
-            reconstructed_line = ocr_result.reconstruct_vertically(word.polygon, page_id)
-            found_hash['page_id'] = page_id if found_hash['page_id'].nil?
-            found_hash['code'] = word.text.strip if found_hash['code'].nil?
-            found_hash = extract_vertical_tax_values(reconstructed_line, found_hash)
-          end
-        end
-        found_hash
-      end
-
-      private_class_method :extract_percentage_from_tax, :extract_basis_and_value, :extract_tax_from_horizontal_line,
-                           :extract_horizontal_tax, :extract_vertical_tax_values, :extract_vertical_tax,
-                           :create_tax_field, :fix_rate, :pick_best, :calculate_score, :curate_values,
-                           :decimate_rates_if_needed, :extract_basis_and_value, :set_base_and_value, :valid_candidate?,
-                           :swap_rates_if_needed
-    end
-  end
-end
+require_relative 'tax_extractor/tax_extractor'

data/lib/mindee/extraction.rb

@@ -1,3 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'extraction/tax_extractor'
+require_relative 'extraction/multi_receipts_extractor'
+require_relative 'extraction/common'
+require_relative 'extraction/pdf_extractor'

data/lib/mindee/http/endpoint.rb

@@ -48,12 +48,19 @@ module Mindee
       # Call the prediction API.
       # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::UrlInputSource]
       # @param all_words [Boolean] Whether the full word extraction needs to be performed
+      # @param full_text [Boolean] Whether to include the full OCR text response in compatible APIs
       # @param close_file [Boolean] Whether the file will be closed after reading
       # @param cropper [Boolean] Whether a cropping operation will be applied
       # @return [Array]
-      def predict(input_source, all_words, close_file, cropper)
+      def predict(input_source, all_words, full_text, close_file, cropper)
         check_api_key
-        response = predict_req_post(input_source, all_words: all_words, close_file: close_file, cropper: cropper)
+        response = predict_req_post(
+          input_source,
+          all_words: all_words,
+          full_text: full_text,
+          close_file: close_file,
+          cropper: cropper
+        )
         hashed_response = JSON.parse(response.body, object_class: Hash)
         return [hashed_response, response.body] if ResponseValidation.valid_sync_response?(response)
 
@@ -65,12 +72,13 @@ module Mindee
       # Call the prediction API.
       # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::UrlInputSource]
       # @param all_words [Boolean] Whether the full word extraction needs to be performed
+      # @param full_text [Boolean] Whether to include the full OCR text response in compatible APIs.
       # @param close_file [Boolean] Whether the file will be closed after reading
       # @param cropper [Boolean] Whether a cropping operation will be applied
       # @return [Array]
-      def predict_async(input_source, all_words, close_file, cropper)
+      def predict_async(input_source, all_words, full_text, close_file, cropper)
         check_api_key
-        response = document_queue_req_get(input_source, all_words, close_file, cropper)
+        response = document_queue_req_get(input_source, all_words, full_text, close_file, cropper)
         hashed_response = JSON.parse(response.body, object_class: Hash)
         return [hashed_response, response.body] if ResponseValidation.valid_async_response?(response)
 
@@ -97,14 +105,16 @@ module Mindee
 
       # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::UrlInputSource]
       # @param all_words [Boolean] Whether the full word extraction needs to be performed
+      # @param full_text [Boolean] Whether to include the full OCR text response in compatible APIs.
       # @param close_file [Boolean] Whether the file will be closed after reading
       # @param cropper [Boolean] Whether a cropping operation will be applied
       # @return [Net::HTTPResponse, nil]
-      def predict_req_post(input_source, all_words: false, close_file: true, cropper: false)
+      def predict_req_post(input_source, all_words: false, full_text: false, close_file: true, cropper: false)
         uri = URI("#{@url_root}/predict")
 
         params = {}
         params[:cropper] = 'true' if cropper
+        params[:full_text_ocr] = 'true' if full_text
         uri.query = URI.encode_www_form(params)
 
         headers = {
@@ -129,14 +139,16 @@ module Mindee
 
       # @param input_source [Mindee::Input::Source::LocalInputSource, Mindee::Input::Source::UrlInputSource]
       # @param all_words [Boolean] Whether the full word extraction needs to be performed
+      # @param full_text [Boolean] Whether to include the full OCR text response in compatible APIs.
       # @param close_file [Boolean] Whether the file will be closed after reading
       # @param cropper [Boolean] Whether a cropping operation will be applied
       # @return [Net::HTTPResponse, nil]
-      def document_queue_req_get(input_source, all_words, close_file, cropper)
+      def document_queue_req_get(input_source, all_words, full_text, close_file, cropper)
         uri = URI("#{@url_root}/predict_async")
 
         params = {}
         params[:cropper] = 'true' if cropper
+        params[:full_text_ocr] = 'true' if full_text
         uri.query = URI.encode_www_form(params)
 
         headers = {

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

@@ -103,7 +103,7 @@ module Mindee
         # @return [String]
         attr_reader :raw_http
 
-        # @param product_class [Class<Mindee::Product>]
+        # @param product_class [Mindee::Inference]
         # @param http_response [Hash]
         # @param raw_http [String]
         def initialize(product_class, http_response, raw_http)

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'inference'
+require_relative 'extras'
 
 module Mindee
   module Parsing
@@ -13,6 +14,8 @@ module Mindee
         attr_reader :name
         # @return [String] Mindee ID of the document
         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)
         attr_reader :ocr
         # @return [Integer] Amount of pages of the document
@@ -27,13 +30,22 @@ module Mindee
           Ocr::Ocr.new(ocr_prediction)
         end
 
-        # @param product_class [Class<Mindee::Product>]
+        def self.load_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)
+        end
+
+        # @param product_class [Mindee::Inference]
         # @param http_response [Hash]
         def initialize(product_class, http_response)
           @id = http_response['id']
           @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)
+          inject_full_text_ocr(http_response)
           @n_pages = http_response['n_pages']
         end
 
@@ -45,6 +57,24 @@ module Mindee
           out_str << "\n:Filename: #{@name}"
           out_str << "\n\n#{@inference}"
         end
+
+        private
+
+        def inject_full_text_ocr(raw_prediction)
+          return unless raw_prediction.dig('inference', 'pages') &&
+                        raw_prediction['inference']['pages'][0]['extras']['full_text_ocr']
+
+          full_text_ocr = String.new
+          raw_prediction.dig('inference', 'pages').each do |page|
+            full_text_ocr << (page['extras']['full_text_ocr']['content'])
+          end
+          artificial_text_obj = { 'content' => full_text_ocr }
+          if @extras.nil? || @extras.empty?
+            @extras = Extras::Extras.new({ 'full_text_ocr' => artificial_text_obj })
+          else
+            @extras.add_artificial_extra({ 'full_text_ocr' => artificial_text_obj })
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../../standard/position_field'
+
+module Mindee
+  module Parsing
+    module Common
+      module Extras
+        # Contains information on the cropping of a prediction.
+        class CropperExtra
+          # Cropper extra initialization.
+          # @return [Array<Mindee::Parsing::Standard::PositionField>]
+          attr_reader :croppings
+
+          def initialize(raw_prediction, page_id = nil)
+            @croppings = []
+            raw_prediction['cropping']&.each do |crop|
+              @croppings.push(Mindee::Parsing::Standard::PositionField.new(crop, page_id))
+            end
+          end
+
+          def to_s
+            @croppings.map(&:to_s).join("\n           ")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../../standard/position_field'
+
+module Mindee
+  module Parsing
+    module Common
+      # Extras namespace.
+      module Extras
+        # Extra information added to the prediction.
+        class Extras
+          # @return [CropperExtra, nil]
+          attr_reader :cropper
+          # @return [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']
+
+            raw_prediction.each do |key, value|
+              instance_variable_set("@#{key}", value) unless ['cropper', 'full_text_ocr'].include?(key)
+            end
+          end
+
+          def to_s
+            out_str = String.new
+            instance_variables.each do |var|
+              out_str << "#{var}: #{instance_variable_get(var)}"
+            end
+            out_str
+          end
+
+          # Adds artificial extra data for reconstructed extras. Currently only used for full_text_ocr.
+          #
+          # @param [Hash] raw_prediction Raw prediction used by the document.
+          def add_artificial_extra(raw_prediction)
+            return unless raw_prediction['full_text_ocr']
+
+            @full_text_ocr << FullTextOCRExtra.new(raw_prediction)
+          end
+        end
+
+        def empty?
+          instance_variables.all? { |var| instance_variable_get(var).nil? }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../standard/position_field'
+
+module Mindee
+  module Parsing
+    module Common
+      module Extras
+        # Full Text OCR result.
+        class FullTextOCRExtra
+          # Contents of the full text OCR result.
+          # @return [String, nil]
+          attr_reader :contents
+          # Language used on the page.
+          # @return [String, nil]
+          attr_reader :language
+
+          def initialize(raw_prediction)
+            @contents = raw_prediction['content'] if raw_prediction['content']
+            return unless raw_prediction['language']
+
+            @language = raw_prediction['language']
+          end
+
+          def to_s
+            @contents || ''
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'extras/extras'
+require_relative 'extras/cropper_extra'
+require_relative 'extras/full_text_ocr_extra'

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'product'
+require_relative 'extras'
 
 module Mindee
   module Parsing
@@ -18,11 +19,15 @@ module Mindee
         # 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 = Orientation.new(raw_prediction['orientation'], @page_id)
+          @extras = Extras::Extras.new(raw_prediction['extras']) unless raw_prediction['extras'].nil?
         end
 
         # @return [String]

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

@@ -98,6 +98,7 @@ module Mindee
           return '' if in_str.nil?
           return in_str if max_col_size.nil?
 
+          in_str = in_str.gsub(%r{[\n\r\t]}, "\n" => '\\n', "\r" => '\\r', "\t" => '\\t')
           in_str.length <= max_col_size ? in_str : "#{in_str[0..max_col_size - 4]}..."
         end
       end

data/lib/mindee/product/bill_of_lading/bill_of_lading_v1.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+require_relative 'bill_of_lading_v1_document'
+require_relative 'bill_of_lading_v1_page'
+
+module Mindee
+  module Product
+    # Bill of Lading module.
+    module BillOfLading
+      # Bill of Lading API version 1 inference prediction.
+      class BillOfLadingV1 < Mindee::Parsing::Common::Inference
+        @endpoint_name = 'bill_of_lading'
+        @endpoint_version = '1'
+
+        # @param prediction [Hash]
+        def initialize(prediction)
+          super
+          @prediction = BillOfLadingV1Document.new(prediction['prediction'], nil)
+          @pages = []
+          prediction['pages'].each do |page|
+            if page.key?('prediction') && !page['prediction'].nil? && !page['prediction'].empty?
+              @pages.push(BillOfLadingV1Page.new(page))
+            end
+          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