mindee 3.19.1 → 4.0.0

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

@@ -0,0 +1,28 @@
+# 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/common.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
+require_relative 'common/api_request'
 require_relative 'common/api_response'
 require_relative 'common/document'
 require_relative 'common/execution'
 require_relative 'common/execution_file'
 require_relative 'common/execution_priority'
 require_relative 'common/inference'
+require_relative 'common/job'
 require_relative 'common/ocr'
 require_relative 'common/prediction'
 require_relative 'common/orientation'
 require_relative 'common/page'
+require_relative 'common/workflow_response'

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

@@ -0,0 +1,72 @@
+# 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 = Geometry.polygon_from_prediction(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/amount_field.rb

@@ -6,7 +6,7 @@ module Mindee
   module Parsing
     module Standard
       # Represents tax information.
-      class AmountField < Field
+      class AmountField < BaseField
         # Amount value as 3 decimal float
         # @return [Float, nil]
         attr_reader :value
@@ -18,7 +18,7 @@ module Mindee
 
         # @return [String]
         def to_s
-          Field.float_to_string(@value)
+          BaseField.float_to_string(@value)
         end
       end
     end

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

@@ -1,107 +1,28 @@
 # frozen_string_literal: true
 
 require_relative '../../geometry'
+require_relative 'abstract_field'
 
 module Mindee
   module Parsing
     module Standard
-      # Base Field 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 = Geometry.polygon_from_prediction(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::Field 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::Field 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
-
       # Base field object.
-      class Field < AbstractField
-        # @return [String, Float, Integer, Boolean]
+      class BaseField < Mindee::Parsing::Standard::AbstractField
+        # @return [String, Float, Integer, bool]
         attr_reader :value
         # true if the field was reconstructed or computed using other fields.
-        # @return [Boolean]
+        # @return [bool]
         attr_reader :reconstructed
 
         # @param prediction [Hash]
         # @param page_id [Integer, nil]
-        # @param reconstructed [Boolean]
+        # @param reconstructed [bool]
         def initialize(prediction, page_id, reconstructed: false)
           super(prediction, page_id)
           @value = prediction['value']
           @reconstructed = reconstructed
         end
       end
-
-      # Feature field object wrapper for specialized methods.
-      class FeatureField < AbstractField
-        # Format strings for display by shortening long strings and assigning empty ones.
-        # @param in_str [String, Boolean, nil]
-        # @param max_col_size [int, nil]
-        # @return [String]
-        def format_for_display(in_str, max_col_size = nil)
-          return 'True' if in_str == true
-          return 'False' if in_str == false
-          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
     end
   end
 end

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

@@ -6,15 +6,16 @@ module Mindee
   module Parsing
     module Standard
       # Represents basic text information.
-      class BooleanField < Field
-        # Value as Boolean
-        # @return [Boolean, nil]
+      class BooleanField < BaseField
+        # Value as bool
+        # @return [bool, nil]
         attr_reader :value
 
         def initialize(prediction, page_id = nil, reconstructed: false)
           super
         end
 
+        # @return [String]
         def to_s
           return '' if value.nil?
 

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

@@ -6,7 +6,7 @@ module Mindee
   module Parsing
     module Standard
       # Represents a classifier value.
-      class ClassificationField < Field
+      class ClassificationField < BaseField
         # Value as String
         # @return [String]
         attr_reader :value

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

@@ -4,28 +4,33 @@ module Mindee
   module Parsing
     module Standard
       # Company registration number or code, and its type.
-      class CompanyRegistrationField < Field
+      class CompanyRegistrationField < BaseField
         # @return [String]
         attr_reader :type
 
         # @param prediction [Hash]
         # @param page_id [Integer, nil]
-        # @param reconstructed [Boolean]
+        # @param reconstructed [bool]
         def initialize(prediction, page_id, reconstructed: false)
           super
           @type = prediction['type']
         end
 
+        # Table line representation of the values.
+        # @return [String] The formatted table line, as a string.
         def to_table_line
           printable = printable_values
           format('| %<type>-15s | %<value>-20s ', type: printable['type'], value: printable['value'])
         end
 
+        # @return [String]
         def to_s
           printable = printable_values
           format('Type: %<type>s, Value: %<value>s', type: printable['type'], value: printable['value'])
         end
 
+        # Hashed representation of the values.
+        # @return [Hash] Hash of the values.
         def printable_values
           printable = {}
           printable['type'] = type

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

@@ -8,7 +8,7 @@ module Mindee
   module Parsing
     module Standard
       # Represents a date.
-      class DateField < Field
+      class DateField < BaseField
         # The date as a standard Ruby `Date` object.
         # @return [Date, nil]
         attr_reader :date_object
@@ -19,7 +19,7 @@ module Mindee
         # @return [String, nil]
         attr_reader :raw
         # Whether the field was computed or retrieved directly from the document.
-        # @return [Boolean, nil]
+        # @return [bool, nil]
         attr_reader :is_computed
 
         # @param prediction [Hash]

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module Standard
+      # Feature field object wrapper for specialized methods.
+      class FeatureField < AbstractField
+        # Format strings for display by shortening long strings and assigning empty ones.
+        # @param in_str [String, bool, nil]
+        # @param max_col_size [int, nil]
+        # @return [String]
+        def format_for_display(in_str, max_col_size = nil)
+          return 'True' if in_str == true
+          return 'False' if in_str == false
+          return '' if in_str.nil?
+          return in_str.to_s if max_col_size.nil?
+
+          in_str = in_str.to_s.gsub(%r{[\n\r\t]}, "\n" => '\\n', "\r" => '\\r', "\t" => '\\t')
+          in_str.to_s.length <= max_col_size.to_i ? in_str.to_s : "#{in_str[0..max_col_size.to_i - 4]}..."
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Mindee
   module Parsing
     module Standard
       # Represents payment details for invoices and receipts
-      class PaymentDetailsField < Field
+      class PaymentDetailsField < BaseField
         # @return [String, nil]
         attr_reader :account_number
         # @return [String, nil]
@@ -18,7 +18,7 @@ module Mindee
 
         # @param prediction [Hash]
         # @param page_id [Integer, nil]
-        # @param reconstructed [Boolean]
+        # @param reconstructed [bool]
         def initialize(prediction, page_id, reconstructed: false)
           super
           @account_number = prediction['account_number']

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

@@ -49,7 +49,9 @@ module Mindee
         private
 
         def to_quadrilateral(prediction, key)
-          Geometry.quadrilateral_from_prediction(prediction[key]) unless prediction[key].nil? || prediction[key].empty?
+          return if prediction[key].nil? || prediction[key].empty?
+
+          Mindee::Geometry.quadrilateral_from_prediction(prediction[key])
         end
       end
     end

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

@@ -6,7 +6,7 @@ module Mindee
   module Parsing
     module Standard
       # Represents basic text information.
-      class StringField < Field
+      class StringField < Mindee::Parsing::Standard::BaseField
         # Value as String
         # @return [String, nil]
         attr_reader :value

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

@@ -6,7 +6,7 @@ module Mindee
   module Parsing
     module Standard
       # Represents tax information.
-      class TaxField < Field
+      class TaxField < BaseField
         # Tax value as 3 decimal float
         # @return [Float, nil]
         attr_reader :value

data/lib/mindee/parsing/standard.rb

@@ -6,6 +6,7 @@ require_relative 'standard/boolean_field'
 require_relative 'standard/classification_field'
 require_relative 'standard/company_registration_field'
 require_relative 'standard/date_field'
+require_relative 'standard/feature_field'
 require_relative 'standard/payment_details_field'
 require_relative 'standard/position_field'
 require_relative 'standard/tax_field'

data/lib/mindee/parsing/{generated/generated_list_field.rb → universal/universal_list_field.rb}

@@ -1,38 +1,38 @@
 # frozen_string_literal: true
 
-require_relative 'generated_object_field'
+require_relative 'universal_object_field'
 
 module Mindee
   module Parsing
-    module Generated
-      # A list of values or objects, used in generated APIs.
-      class GeneratedListField
+    module Universal
+      # A list of values or objects, used in universal APIs.
+      class UniversalListField
         include Mindee::Parsing::Standard
-        include Mindee::Parsing::Generated
+        include Mindee::Parsing::Universal
 
-        # Id of the page (as given by the API).
+        # ID of the page (as given by the API).
         # @return [Integer]
         attr_accessor :page_id
 
         # List of word values
-        # @return [Array<GeneratedObjectField, StringField>]
+        # @return [Array<UniversalObjectField, StringField>]
         attr_accessor :values
 
-        # Id of the page the object was found on.
+        # ID of the page the object was found on.
         # List of word values.
 
         def initialize(raw_prediction, page_id = nil)
-          @values = []
+          @values = [] # : Array[UniversalObjectField | Parsing::Standard::StringField]
 
           raw_prediction.each do |value|
             page_id = value['page_id'] if value.key?('page_id') && !value['page_id'].nil?
 
-            if Generated.generated_object?(value)
-              @values.push(GeneratedObjectField.new(value, page_id))
+            if Universal.universal_object?(value)
+              @values.push(Mindee::Parsing::Universal::UniversalObjectField.new(value, page_id))
             else
               value_str = value.dup
               value_str['value'] = value_str['value'].to_s if value_str.key?('value') && !value_str['value'].nil?
-              @values.push(StringField.new(value_str, page_id))
+              @values.push(Mindee::Parsing::Standard::StringField.new(value_str, page_id))
             end
           end
         end

data/lib/mindee/parsing/{generated/generated_object_field.rb → universal/universal_object_field.rb}

@@ -4,19 +4,26 @@ require_relative '../common'
 
 module Mindee
   module Parsing
-    # Generated fields and functions.
-    module Generated
+    # Universal fields and functions.
+    module Universal
       # A JSON-like object, with miscellaneous values.
-      class GeneratedObjectField
-        include Mindee::Parsing::Standard
-        attr_accessor :page_id, :confidence, :raw_value
+      class UniversalObjectField
+        # ID of the page (as given by the API).
+        # @return [Integer]
+        attr_reader :page_id
+        # The confidence score, value will be between 0.0 and 1.0
+        # @return [Float]
+        attr_reader :confidence
+        # Value as String
+        # @return [Hash<Symbol | String, untyped>, nil]
+        attr_accessor :raw_value
 
-        # Id of the page the object was found on.
+        # ID of the page the object was found on.
         # Confidence with which the value was assessed.
         # Raw unprocessed value, as it was sent by the server.
 
         def initialize(raw_prediction, page_id = nil)
-          @all_values = {}
+          @all_values = {} # : Hash[Symbol | String, untyped]
           item_page_id = nil
           raw_prediction.each do |name, value|
             case name
@@ -47,7 +54,7 @@ module Mindee
         end
 
         # Necessary overload of the method_missing method to allow for direct access to dynamic attributes without
-        # complicating usage too much
+        # changing the user usage too much.
         # Returns the corresponding attribute when asked.
         #
         # Otherwise, raises a NoMethodError.
@@ -61,14 +68,14 @@ module Mindee
         end
 
         # Necessary overload of the respond_to_missing? method to allow for direct access to dynamic attributes without
-        # complicating usage too much
+        # changing the user usage too much.
         # Returns true if the method name exists as a key in @all_values,
         # indicating that the object can respond to the method.
         # Otherwise, calls super to fallback to the default behavior.
         #
         # @param method_name [Symbol] The name of the method being checked.
-        # @param include_private [Boolean] Whether to include private methods in the check.
-        # @return [Boolean] True if the method can be responded to, false otherwise.
+        # @param include_private [bool] Whether to include private methods in the check.
+        # @return [bool] True if the method can be responded to, false otherwise.
         def respond_to_missing?(method_name, include_private = false)
           @all_values.key?(method_name.to_s) || super
         end
@@ -82,7 +89,9 @@ module Mindee
 
         def handle_position_field(name, value, item_page_id)
           @all_values[name.to_s] =
-            PositionField.new({ name.to_s => value }, value_key: name.to_s, page_id: item_page_id)
+            Mindee::Parsing::Standard::PositionField.new(
+              { name.to_s => value }, item_page_id
+            )
         end
 
         def handle_default_field(name, value)
@@ -90,7 +99,7 @@ module Mindee
         end
       end
 
-      def self.generated_object?(str_dict)
+      def self.universal_object?(str_dict)
         common_keys = [
           'value',
           'polygon',
@@ -101,7 +110,7 @@ module Mindee
           'values',
           'raw_value',
         ]
-        str_dict.each_key { |key| return true unless common_keys.include?(key) }
+        str_dict.each_key { |key| return true unless common_keys.include?(key.to_s) }
         false
       end
     end

data/lib/mindee/parsing/universal.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'universal/universal_object_field'
+require_relative 'universal/universal_list_field'

data/lib/mindee/parsing.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 require_relative 'parsing/standard'
-require_relative 'parsing/custom'
 require_relative 'parsing/common'
-require_relative 'parsing/generated'
+require_relative 'parsing/universal'

data/lib/mindee/{extraction/pdf_extractor → pdf}/extracted_pdf.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module Mindee
-  # Pdf Extraction Module.
-  module Extraction
-    module PdfExtractor
+  # PDF Extraction Module.
+  module PDF
+    module PDFExtractor
       # An extracted sub-Pdf.
-      class ExtractedPdf
+      class ExtractedPDF
         # Byte contents of the pdf
         # @return [StreamIO]
         attr_reader :pdf_bytes
@@ -24,19 +24,22 @@ module Mindee
         # Retrieves the page count for a given pdf.
         # @return [Integer]
         def page_count
-          current_pdf = Mindee::PDF::PdfProcessor.open_pdf(pdf_bytes)
+          current_pdf = Mindee::PDF::PDFProcessor.open_pdf(pdf_bytes)
           current_pdf.pages.size
-        rescue TypeError
-          raise 'Could not retrieve page count from Extracted PDF object.'
+        rescue TypeError, Origami::InvalidPDFError
+          raise Errors::MindeePDFError, 'Could not retrieve page count from Extracted PDF object.'
         end
 
         # Writes the contents of the current PDF object to a file.
         # @param output_path [String] Path to write to.
-        def write_to_file(output_path)
-          raise 'Provided path is not a file' if File.directory?(destination)
-          raise 'Invalid save path provided' unless File.exist?(File.expand_path('..', output_path))
-
-          if File.extname(output_path).downcase == '.pdf'
+        # @param override [bool] Whether to override the destination file.
+        def write_to_file(output_path, override: false)
+          raise Errors::MindeePDFError, 'Provided path is not a file' if File.directory?(output_path)
+          raise Errors::MindeePDFError, 'Invalid save path provided' unless File.exist?(
+            File.expand_path('..', output_path)
+          ) && !override
+
+          if File.extname(output_path).downcase == 'pdf'
             base_path = File.expand_path('..', output_path)
             output_path = File.expand_path("#{File.basename(output_path)}.pdf", base_path)
           end