mindee 3.11.0 → 3.13.0

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/input/sources.rb

@@ -118,6 +118,14 @@ module Mindee
           @io_stream.close if close
           ['document', data, { filename: Mindee::Input::Source.convert_to_unicode_escape(@filename) }]
         end
+
+        def count_pdf_pages
+          return 1 unless pdf?
+
+          @io_stream.seek(0)
+          pdf_processor = Mindee::PDF::PdfProcessor.open_pdf(@io_stream)
+          pdf_processor.pages.size
+        end
       end
 
       # Load a document from a path.

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/parsing/standard/company_registration_field.rb

@@ -15,6 +15,23 @@ module Mindee
           super
           @type = prediction['type']
         end
+
+        def to_table_line
+          printable = printable_values
+          format('| %<type>-15s | %<value>-20s ', type: printable['type'], value: printable['value'])
+        end
+
+        def to_s
+          printable = printable_values
+          format('Type: %<type>s, Value: %<value>s', type: printable['type'], value: printable['value'])
+        end
+
+        def printable_values
+          printable = {}
+          printable['type'] = type
+          printable['value'] = value
+          printable
+        end
       end
     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

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+
+module Mindee
+  module Product
+    module BillOfLading
+      # The shipping company responsible for transporting the goods.
+      class BillOfLadingV1Carrier < Mindee::Parsing::Standard::FeatureField
+        include Mindee::Parsing::Standard
+        # The name of the carrier.
+        # @return [String]
+        attr_reader :name
+        # The professional number of the carrier.
+        # @return [String]
+        attr_reader :professional_number
+        # The Standard Carrier Alpha Code (SCAC) of the carrier.
+        # @return [String]
+        attr_reader :scac
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          super(prediction, page_id)
+          @name = prediction['name']
+          @professional_number = prediction['professional_number']
+          @scac = prediction['scac']
+          @page_id = page_id
+        end
+
+        # @return [Hash]
+        def printable_values
+          printable = {}
+          printable[:name] = format_for_display(@name)
+          printable[:professional_number] = format_for_display(@professional_number)
+          printable[:scac] = format_for_display(@scac)
+          printable
+        end
+
+        # @return [String]
+        def to_s
+          printable = printable_values
+          out_str = String.new
+          out_str << "\n  :Name: #{printable[:name]}"
+          out_str << "\n  :Professional Number: #{printable[:professional_number]}"
+          out_str << "\n  :SCAC: #{printable[:scac]}"
+          out_str
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+
+module Mindee
+  module Product
+    module BillOfLading
+      # The goods being shipped.
+      class BillOfLadingV1CarrierItem < Mindee::Parsing::Standard::FeatureField
+        include Mindee::Parsing::Standard
+        # A description of the item.
+        # @return [String]
+        attr_reader :description
+        # The gross weight of the item.
+        # @return [Float]
+        attr_reader :gross_weight
+        # The measurement of the item.
+        # @return [Float]
+        attr_reader :measurement
+        # The unit of measurement for the measurement.
+        # @return [String]
+        attr_reader :measurement_unit
+        # The quantity of the item being shipped.
+        # @return [Float]
+        attr_reader :quantity
+        # The unit of measurement for weights.
+        # @return [String]
+        attr_reader :weight_unit
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          super(prediction, page_id)
+          @description = prediction['description']
+          @gross_weight = prediction['gross_weight']
+          @measurement = prediction['measurement']
+          @measurement_unit = prediction['measurement_unit']
+          @quantity = prediction['quantity']
+          @weight_unit = prediction['weight_unit']
+          @page_id = page_id
+        end
+
+        # @return [Hash]
+        def printable_values
+          printable = {}
+          printable[:description] = format_for_display(@description)
+          printable[:gross_weight] = @gross_weight.nil? ? '' : Field.float_to_string(@gross_weight)
+          printable[:measurement] = @measurement.nil? ? '' : Field.float_to_string(@measurement)
+          printable[:measurement_unit] = format_for_display(@measurement_unit)
+          printable[:quantity] = @quantity.nil? ? '' : Field.float_to_string(@quantity)
+          printable[:weight_unit] = format_for_display(@weight_unit)
+          printable
+        end
+
+        # @return [Hash]
+        def table_printable_values
+          printable = {}
+          printable[:description] = format_for_display(@description, 36)
+          printable[:gross_weight] = @gross_weight.nil? ? '' : Field.float_to_string(@gross_weight)
+          printable[:measurement] = @measurement.nil? ? '' : Field.float_to_string(@measurement)
+          printable[:measurement_unit] = format_for_display(@measurement_unit, nil)
+          printable[:quantity] = @quantity.nil? ? '' : Field.float_to_string(@quantity)
+          printable[:weight_unit] = format_for_display(@weight_unit, nil)
+          printable
+        end
+
+        # @return [String]
+        def to_table_line
+          printable = table_printable_values
+          out_str = String.new
+          out_str << format('| %- 37s', printable[:description])
+          out_str << format('| %- 13s', printable[:gross_weight])
+          out_str << format('| %- 12s', printable[:measurement])
+          out_str << format('| %- 17s', printable[:measurement_unit])
+          out_str << format('| %- 9s', printable[:quantity])
+          out_str << format('| %- 12s', printable[:weight_unit])
+          out_str << '|'
+        end
+
+        # @return [String]
+        def to_s
+          printable = printable_values
+          out_str = String.new
+          out_str << "\n  :Description: #{printable[:description]}"
+          out_str << "\n  :Gross Weight: #{printable[:gross_weight]}"
+          out_str << "\n  :Measurement: #{printable[:measurement]}"
+          out_str << "\n  :Measurement Unit: #{printable[:measurement_unit]}"
+          out_str << "\n  :Quantity: #{printable[:quantity]}"
+          out_str << "\n  :Weight Unit: #{printable[:weight_unit]}"
+          out_str
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+
+module Mindee
+  module Product
+    module BillOfLading
+      # The party to whom the goods are being shipped.
+      class BillOfLadingV1Consignee < Mindee::Parsing::Standard::FeatureField
+        include Mindee::Parsing::Standard
+        # The address of the consignee.
+        # @return [String]
+        attr_reader :address
+        # The  email of the shipper.
+        # @return [String]
+        attr_reader :email
+        # The name of the consignee.
+        # @return [String]
+        attr_reader :name
+        # The phone number of the consignee.
+        # @return [String]
+        attr_reader :phone
+
+        # @param prediction [Hash]
+        # @param page_id [Integer, nil]
+        def initialize(prediction, page_id)
+          super(prediction, page_id)
+          @address = prediction['address']
+          @email = prediction['email']
+          @name = prediction['name']
+          @phone = prediction['phone']
+          @page_id = page_id
+        end
+
+        # @return [Hash]
+        def printable_values
+          printable = {}
+          printable[:address] = format_for_display(@address)
+          printable[:email] = format_for_display(@email)
+          printable[:name] = format_for_display(@name)
+          printable[:phone] = format_for_display(@phone)
+          printable
+        end
+
+        # @return [String]
+        def to_s
+          printable = printable_values
+          out_str = String.new
+          out_str << "\n  :Address: #{printable[:address]}"
+          out_str << "\n  :Email: #{printable[:email]}"
+          out_str << "\n  :Name: #{printable[:name]}"
+          out_str << "\n  :Phone: #{printable[:phone]}"
+          out_str
+        end
+      end
+    end
+  end
+end