mindee 4.6.0 → 4.7.0.pre.rc1

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

@@ -8,7 +8,7 @@ module Mindee
         # @return [Hash]
         attr_reader :error
         # @return [Array<String>]
-        attr_reader :ressources
+        attr_reader :resources
         # @return [RequestStatus, Symbol]
         attr_reader :status
         # @return [Integer]
@@ -18,7 +18,7 @@ module Mindee
 
         def initialize(server_response)
           @error = server_response['error']
-          @ressources = server_response['ressources']
+          @resources = server_response['resources']
 
           @status = if server_response['status'] == 'failure'
                       RequestStatus::FAILURE

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

@@ -8,9 +8,13 @@ module Mindee
     module Common
       # Potential values for queue in asynchronous calls.
       module JobStatus
+        # Job is waiting.
         WAITING    = :waiting
+        # Job is processing.
         PROCESSING = :processing
+        # Job is done.
         COMPLETED  = :completed
+        # Job failed.
         FAILURE    = :failed
       end
 

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

@@ -21,7 +21,7 @@ module Mindee
         # @return [Mindee::Inference]
         attr_reader :inference
         # Priority of the execution.
-        # @return [ExecutionPriority]
+        # @return [ExecutionPriority, Symbol, nil]
         attr_reader :priority
         # The time at which the file was tagged as reviewed.
         # @return [Time, nil]

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

@@ -11,7 +11,7 @@ module Mindee
         class Extras
           # @return [CropperExtra, nil]
           attr_reader :cropper
-          # @return [Mindee::Parsing::Common::Extras::FullTextOCRExtra, nil]
+          # @return [Mindee::Parsing::Common::Extras::FullTextOCRExtra]
           attr_reader :full_text_ocr
           # @return [RAGExtra, nil]
           attr_reader :rag
@@ -26,7 +26,7 @@ module Mindee
             @rag = Mindee::Parsing::Common::Extras::RAGExtra.new(raw_prediction['rag']) if raw_prediction['rag']
 
             raw_prediction.each do |key, value|
-              instance_variable_set("@#{key}", value) unless ['cropper', 'full_text_ocr', 'rag'].include?(key)
+              instance_variable_set("@#{key}", value) unless ['cropper', 'full_text_ocr', 'rag'].include?(key.to_s)
             end
           end
 

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

@@ -14,6 +14,8 @@ module Mindee
             @matching_document_id = raw_prediction['matching_document_id'] if raw_prediction['matching_document_id']
           end
 
+          # String representation.
+          # @return [String]
           def to_s
             @matching_document_id || ''
           end

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

@@ -11,7 +11,7 @@ module Mindee
         class OCRWord
           # The confidence score, value will be between 0.0 and 1.0
           # @return [Float]
-          attr_accessor :confidence
+          attr_reader :confidence
           # @return [String]
           attr_reader :text
           # @return [Mindee::Geometry::Quadrilateral]
@@ -36,7 +36,7 @@ module Mindee
         # A list of words which are on the same line.
         class OCRLine < Array
           # @param prediction [Hash, nil]
-          # @param from_array [Array, nil]
+          # @param from_array [Array<OCRWord>, nil]
           def initialize(prediction = nil, from_array = nil)
             if !prediction.nil?
               super(prediction.map { |word_prediction| OCRWord.new(word_prediction) })
@@ -48,9 +48,7 @@ module Mindee
           # Sort the words on the line from left to right.
           # @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
+            from_array = sort_by { |word| Geometry.get_min_max_x(word.polygon).min }
             OCRLine.new(nil, from_array)
           end
 
@@ -104,7 +102,7 @@ module Mindee
           # @param indexes [Array<Integer>]
           # @param lines [Array<OCRLine>]
           def parse_one(sorted_words, current, indexes, lines)
-            line = OCRLine.new([])
+            line = OCRLine.new(nil, [])
             sorted_words.each_with_index do |word, idx|
               next if indexes.include?(idx)
 

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

@@ -5,7 +5,7 @@ module Mindee
     module Common
       # Page orientation
       class Orientation
-        # @return [Integer]
+        # @return [Integer, nil]
         attr_reader :page_id
         # A prediction among these 3 possible outputs:
         #   * 0 degrees: the page is already upright
@@ -15,7 +15,7 @@ module Mindee
         attr_reader :value
 
         # @param prediction [Hash]
-        # @param page_id [Integer]
+        # @param page_id [Integer, nil]
         def initialize(prediction, page_id)
           @value = prediction['value']
           @page_id = page_id

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

@@ -5,7 +5,12 @@ module Mindee
     module Common
       # Product information
       class Product
-        attr_reader :name, :type, :version
+        # @return [String] Name of the product.
+        attr_reader :name
+        # @return [String?] Type of product.
+        attr_reader :type
+        # @return [String] Product version.
+        attr_reader :version
 
         # @param prediction [Hash]
         def initialize(prediction)

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

@@ -13,12 +13,12 @@ module Mindee
 
         def initialize(prediction, page_id, reconstructed: false)
           super
-          @value = @value.round(3) unless @value.nil?
+          @value = @value.to_f.round(3).to_f unless @value.to_s.empty?
         end
 
         # @return [String]
         def to_s
-          BaseField.float_to_string(@value)
+          @value.nil? ? '' : BaseField.float_to_string(@value.to_f)
         end
       end
     end

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

@@ -16,7 +16,7 @@ module Mindee
           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]}..."
+          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

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

@@ -52,7 +52,7 @@ module Mindee
           out_h[:code] = @code.nil? ? '' : @code
           out_h[:base] = @base.nil? ? '' : print_float(@base)
           out_h[:rate] = @rate.nil? ? '' : print_float(@rate).to_s
-          out_h[:value] = @value.nil? ? '' : print_float(@value).to_s
+          out_h[:value] = @value.to_s.empty? ? '' : print_float(@value.to_f).to_s
           out_h
         end
 

data/lib/mindee/parsing/universal/universal_list_field.rb

@@ -12,11 +12,11 @@ module Mindee
 
         # ID of the page (as given by the API).
         # @return [Integer]
-        attr_accessor :page_id
+        attr_reader :page_id
 
         # List of word values
         # @return [Array<UniversalObjectField, StringField>]
-        attr_accessor :values
+        attr_reader :values
 
         # ID of the page the object was found on.
         # List of word values.

data/lib/mindee/parsing/universal/universal_object_field.rb

@@ -15,15 +15,18 @@ module Mindee
         # @return [Float]
         attr_reader :confidence
         # Value as String
-        # @return [Hash<Symbol | String, untyped>, nil]
-        attr_accessor :raw_value
+        # @return [String]
+        attr_reader :raw_value
+        # All values
+        # @return [Hash]
+        attr_reader :all_values
 
         # 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 = {} # : Hash[Symbol | String, untyped]
+          @all_values = {} # : Hash[String | Symbol, untyped]
           item_page_id = nil
           raw_prediction.each do |name, value|
             case name

data/lib/mindee/parsing/v2/common_response.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module V2
+      # Base class for inference and job responses on the V2 API.
+      class CommonResponse
+        # @return [Hash]
+        attr_reader :raw_http
+
+        # @param http_response [Hash]
+        def initialize(http_response)
+          @raw_http = http_response
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/v2/error_response.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module V2
+      # Encapsulates information returned by the API when an error occurs.
+      class ErrorResponse
+        # @return [Integer] HTTP status code.
+        attr_reader :status
+        # @return [String] Error detail.
+        attr_reader :detail
+
+        # @param server_response [Hash] Raw JSON parsed into a Hash.
+        def initialize(server_response)
+          @status = server_response['status']
+          @detail = server_response['detail']
+        end
+
+        # String representation.
+        # @return [String]
+        def to_s
+          "Error\n=====\n:Status: #{@status}\n:Detail: #{@detail}"
+        end
+
+        # Hash representation
+        # @return [Hash] Hash representation of the object.
+        def as_hash
+          {
+            status: @status,
+            detail: @detail,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/v2/field/base_field.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module V2
+      # Field submodule for V2.
+      module Field
+        # Base class for V2 fields.
+        class BaseField
+          # @return [Integer] Level of indentation for rst display.
+          attr_reader :indent_level
+
+          # @return [FieldConfidence, nil] Confidence score for the field.
+          attr_reader :confidence
+
+          # @return [Array<FieldLocation>] List of locations the field was found at.
+          attr_reader :locations
+
+          # @param raw_prediction [Hash] Raw prediction hash.
+          # @param indent_level [Integer] Level of indentation for rst display.
+          def initialize(raw_prediction, indent_level = 0)
+            @indent_level = indent_level
+            @confidence = raw_prediction.key?('confidence') ? raw_prediction['confidence'] : nil
+            @locations = if raw_prediction.key?('locations')
+                           raw_prediction['locations'].map do |location|
+                             FieldLocation.new(location)
+                           end
+                         else
+                           []
+                         end
+          end
+
+          # Factory method to create appropriate field types.
+          # @param raw_prediction [Hash] Raw prediction hash.
+          # @param indent_level [Integer] Level of indentation for rst display.
+          # @return [BaseField] Appropriate field instance.
+          # @raise [MindeeError] If the field type isn't recognized.
+          def self.create_field(raw_prediction, indent_level = 0)
+            if raw_prediction.key?('items')
+              require_relative 'list_field'
+              return ListField.new(raw_prediction, indent_level)
+            end
+
+            if raw_prediction.key?('fields')
+              require_relative 'object_field'
+              return ObjectField.new(raw_prediction, indent_level)
+            end
+
+            if raw_prediction.key?('value')
+              require_relative 'simple_field'
+              return SimpleField.new(raw_prediction, indent_level)
+            end
+
+            raise Errors::MindeeError, "Unrecognized field format in #{raw_prediction.to_json}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/v2/field/field_confidence.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Mindee
+  module Parsing
+    module V2
+      module Field
+        # Confidence level of a field as returned by the V2 API.
+        class FieldConfidence
+          # @return [String] The confidence level value.
+          attr_reader :value
+
+          # Absolute certainty about the field's extraction.
+          CERTAIN = 'Certain'
+          # High certainty about the field's extraction.
+          HIGH = 'High'
+          # Medium certainty about the field's extraction.
+          MEDIUM = 'Medium'
+          # Low certainty about the field's extraction.
+          LOW = 'Low'
+
+          # List of valid values, as frozen strings.
+          VALID_VALUES = [CERTAIN, HIGH, MEDIUM, LOW].freeze
+
+          # @param value [String] The confidence level value.
+          # @raise [ArgumentError] If the value is not a valid confidence level.
+          def initialize(value)
+            unless VALID_VALUES.include?(value)
+              raise ArgumentError,
+                    "Invalid confidence level: #{value}. Must be one of: #{VALID_VALUES.join(', ')}"
+            end
+
+            @value = value
+          end
+
+          # Create a FieldConfidence from a string value.
+          # @param value [String] The confidence level string.
+          # @return [FieldConfidence] The confidence instance.
+          def self.from_string(value)
+            new(value)
+          end
+
+          # Check if this is a certain confidence level.
+          # @return [Boolean] True if confidence is certain.
+          def certain?
+            @value == CERTAIN
+          end
+
+          # Check if this is a high confidence level.
+          # @return [Boolean] True if confidence is high.
+          def high?
+            @value == HIGH
+          end
+
+          # Check if this is a medium confidence level.
+          # @return [Boolean] True if confidence is medium.
+          def medium?
+            @value == MEDIUM
+          end
+
+          # Check if this is a low confidence level.
+          # @return [Boolean] True if confidence is low.
+          def low?
+            @value == LOW
+          end
+
+          # String representation of the confidence level.
+          # @return [String] The confidence level value.
+          def to_s
+            @value
+          end
+
+          # Compare two FieldConfidence instances.
+          # @param other [FieldConfidence] The other confidence to compare.
+          # @return [Boolean] True if they have the same value.
+          def ==(other)
+            other.is_a?(FieldConfidence) && @value == other.value
+          end
+
+          # Make instances comparable and hashable
+          alias eql? ==
+
+          # Inspect method for debugging.
+          # @return [String] Debug representation.
+          def inspect
+            "#<#{self.class.name}:#{@value}>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/v2/field/field_location.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../../../geometry/polygon'
+
+module Mindee
+  module Parsing
+    module V2
+      module Field
+        # Location of a field.
+        class FieldLocation
+          # @return [Mindee::Geometry::Polygon, nil] Polygon corresponding to the field location.
+          attr_reader :polygon
+
+          # @return [Integer, nil] Page on which the field is located.
+          attr_reader :page
+
+          # @param server_response [Hash] Raw server response hash.
+          def initialize(server_response)
+            polygon_data = server_response['polygon'] || server_response[:polygon]
+            @polygon = polygon_data ? Mindee::Geometry::Polygon.new(polygon_data) : nil
+
+            page_id = server_response['page'] || server_response[:page]
+            @page = page_id.is_a?(Float) || page_id.is_a?(Integer) ? page_id.to_i : nil
+          end
+
+          # String representation of the polygon (empty string when none).
+          #
+          # @return [String]
+          def to_s
+            @polygon ? @polygon.to_s : ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/v2/field/inference_fields.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative 'base_field'
+
+module Mindee
+  module Parsing
+    module V2
+      module Field
+        # Collection of inference fields that extends Hash functionality.
+        class InferenceFields < Hash
+          # @return [Integer] Level of indentation for rst display.
+          attr_reader :indent_level
+
+          # @param server_response [Hash] Raw server response hash.
+          # @param indent_level [Integer] Level of indentation for rst display.
+          def initialize(server_response, indent_level = 0)
+            super()
+            @indent_level = indent_level
+
+            server_response.each do |key, value|
+              self[key.to_s] = BaseField.create_field(value, 1)
+            end
+          end
+
+          # Get a field by key with nil fallback.
+          # @param key [String] Field key to retrieve.
+          # @return [BaseField, nil] The field or nil if not found.
+          def get(key)
+            self[key]
+          end
+
+          # Allow dot notation access to fields.
+          # @param method_name [Symbol] The method name (field key).
+          # @return [BaseField, nil] The field or nil if not found.
+          def method_missing(method_name, *args, &block)
+            key = method_name.to_s
+            if key?(key)
+              self[key]
+            else
+              super
+            end
+          end
+
+          # Check if method_missing should handle the method.
+          # @param method_name [Symbol] The method name.
+          # @return [Boolean] True if the method should be handled.
+          def respond_to_missing?(method_name, include_private = false)
+            key?(method_name.to_s) || super
+          end
+
+          # rubocop:disable Metrics/CyclomaticComplexity
+          # rubocop:disable Metrics/PerceivedComplexity
+          # Convert the fields to a string representation.
+          # @param indent [Integer, nil] Optional indentation level.
+          # @return [String] String representation of all fields.
+          def to_s(indent = 0)
+            return '' if empty?
+
+            indent ||= @indent_level
+            padding = '  ' * indent
+            lines = []
+
+            each do |field_key, field_value|
+              line = "#{padding}:#{field_key}:"
+
+              case (field_value.class.name || '').split('::').last
+              when 'ListField'
+                # Check if ListField has items and they're not empty
+                list_f = field_value # @type var list_f: ListField
+                if defined?(list_f.items) && list_f.items && !list_f.items.empty?
+                  line += list_f.to_s
+                end
+              when 'ObjectField'
+                line += field_value.to_s
+              when 'SimpleField'
+                # Check if SimpleField has a non-empty value
+                simple_f = field_value # @type var simple_f: SimpleField
+                if defined?(simple_f.value) && simple_f.value && !simple_f.value.to_s.empty?
+                  line += " #{simple_f}"
+                end
+              else
+                logger.debug("Unknown value was passed to the field creator: #{field_key} : #{field_value}")
+              end
+
+              lines << line
+            end
+
+            lines.join("\n").rstrip
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity
+          # rubocop:enable Metrics/PerceivedComplexity
+        end
+      end
+    end
+  end
+end

data/lib/mindee/parsing/v2/field/list_field.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative 'base_field'
+
+module Mindee
+  module Parsing
+    module V2
+      module Field
+        # Represents a field that contains a list of items.
+        class ListField < BaseField
+          include Enumerable
+          # @return [Array<ListField | ObjectField | SimpleField>] Items contained in the list.
+          attr_reader :items
+
+          # @param server_response [Hash] Raw server response hash.
+          # @param indent_level [Integer] Level of indentation for rst display.
+          # @raise [MindeeError] If the 'items' key is missing or not an array.
+          def initialize(server_response, indent_level = 0)
+            super
+
+            unless server_response.key?('items') && server_response['items'].is_a?(Array)
+              raise Errors::MindeeError,
+                    "Expected \"items\" to be an array in #{server_response.to_json}."
+            end
+
+            @items = []
+            server_response['items'].each do |item|
+              @items << BaseField.create_field(item, indent_level + 1)
+            end
+          end
+
+          # String representation of the list field.
+          # @return [String] Formatted string with bullet points for each item.
+          def to_s
+            return "\n" if @items.empty?
+
+            parts = ['']
+            @items.each do |item|
+              next unless item
+
+              parts << if item.is_a?(ObjectField)
+                         item.to_s_from_list
+                       else
+                         item.to_s
+                       end
+            end
+
+            parts.join("\n  * ")
+          end
+
+          # Check if the list is empty.
+          # @return [Boolean] True if the list has no items.
+          def empty?
+            @items.empty?
+          end
+
+          # Get the number of items in the list.
+          # @return [Integer] Number of items.
+          def size
+            @items.size
+          end
+
+          # Get the number of items in the list (alias for size).
+          # @return [Integer] Number of items.
+          def length
+            @items.length
+          end
+
+          # Get an item by index.
+          # @param index [Integer] The index of the item to retrieve.
+          # @return [BaseField, nil] The item at the given index.
+          def [](index)
+            @items[index]
+          end
+
+          # Iterator for Enumerator inheritance.
+          # NOTE: Untyped due to incomplete support in steep.
+          def each(&block)
+            return to_enum(:each) unless block_given?
+
+            @items.each(&block)
+            self
+          end
+        end
+      end
+    end
+  end
+end