mindee 4.12.0 → 5.0.0.beta1

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

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../common'
-
-module Mindee
-  module Parsing
-    # Universal fields and functions.
-    module Universal
-      # A JSON-like object, with miscellaneous values.
-      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 [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[String | Symbol, untyped]
-          item_page_id = nil
-          raw_prediction.each do |name, value|
-            case name
-            when 'page_id'
-              item_page_id = value
-            when 'polygon', 'rectangle', 'quadrangle', 'bounding_box'
-              handle_position_field(name, value, item_page_id)
-            when 'confidence'
-              @confidence = value
-            when 'raw_value'
-              @raw_value = value
-            else
-              handle_default_field(name, value)
-            end
-            @page_id = page_id || item_page_id
-          end
-        end
-
-        # String representation that takes into account the level of indentation.
-        def str_level(level = 0)
-          indent = "  #{'  ' * level}"
-          out_str = ''
-          @all_values.each do |attr, value|
-            str_value = value.nil? ? '' : value.to_s
-            out_str += "\n#{indent}:#{attr}: #{str_value}".rstrip
-          end
-          "\n#{indent}#{out_str.strip}"
-        end
-
-        # Necessary overload of the method_missing method to allow for direct access to dynamic attributes without
-        # changing the user usage too much.
-        # Returns the corresponding attribute when asked.
-        #
-        # Otherwise, raises a NoMethodError.
-        #
-        # @param method_name [Symbol] The name of the method being called.
-        # @param _args [Array] Arguments passed to the method.
-        # @return [Object] The value associated with the method name in @all_values.
-        def method_missing(method_name, *_args)
-          super unless @all_values.key?(method_name.to_s)
-          @all_values[method_name.to_s]
-        end
-
-        # Necessary overload of the respond_to_missing? method to allow for direct access to dynamic attributes without
-        # 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 [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
-
-        # String representation
-        def to_s
-          str_level
-        end
-
-        private
-
-        def handle_position_field(name, value, item_page_id)
-          @all_values[name.to_s] =
-            Mindee::Parsing::Standard::PositionField.new(
-              { name.to_s => value }, item_page_id
-            )
-        end
-
-        def handle_default_field(name, value)
-          @all_values[name] = value&.to_s
-        end
-      end
-
-      def self.universal_object?(str_dict)
-        common_keys = [
-          'value',
-          'polygon',
-          'rectangle',
-          'page_id',
-          'confidence',
-          'quadrangle',
-          'values',
-          'raw_value',
-        ]
-        str_dict.each_key { |key| return true unless common_keys.include?(key.to_s) }
-        false
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# 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_item.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  module Parsing
-    module V2
-      # Individual error item.
-      class ErrorItem
-        # @return [String, nil] A JSON Pointer to the location of the body property.
-        attr_reader :pointer
-        # @return [String, nil] Explicit information on the issue.
-        attr_reader :detail
-
-        # @param server_response [Hash] Raw JSON parsed into a Hash.
-        def initialize(server_response)
-          @pointer = server_response['pointer']
-          @detail = server_response['detail']
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Mindee
-  module Parsing
-    module V2
-      # Encapsulates information returned by the API when an error occurs.
-      class ErrorResponse
-        # @return [Integer] The HTTP status code returned by the server.
-        attr_reader :status
-        # @return [String] A human-readable explanation specific to the occurrence of the problem.
-        attr_reader :detail
-        # @return [String] A short, human-readable summary of the problem.
-        attr_reader :title
-        # @return [String] A machine-readable code specific to the occurrence of the problem.
-        attr_reader :code
-        # @return [Array<ErrorItem>] A list of explicit error details.
-        attr_reader :errors
-
-        # @param server_response [Hash] Raw JSON parsed into a Hash.
-        def initialize(server_response)
-          @status = server_response['status']
-          @detail = server_response['detail']
-          @title = server_response['title']
-          @code = server_response['code']
-          @errors = if server_response.key?('errors')
-                      server_response['errors'].map do |error|
-                        ErrorItem.new(error)
-                      end
-                    else
-                      []
-                    end
-        end
-
-        # String representation.
-        # @return [String]
-        def to_s
-          "HTTP #{@status} - #{@title} :: #{@code} - #{@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

@@ -1,63 +0,0 @@
-# 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['confidence']
-            @confidence = FieldConfidence.new(confidence) unless confidence.nil? || confidence.empty?
-
-            locations = raw_prediction['locations']
-            @locations = if locations.nil? || locations.empty?
-                           []
-                         else
-                           locations.map do |location|
-                             FieldLocation.new(location)
-                           end
-                         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

@@ -1,128 +0,0 @@
-# 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)
-            case value
-            when 'Certain' then @value = CERTAIN
-            when 'High' then @value = HIGH
-            when 'Medium' then @value = MEDIUM
-            when 'Low' then @value = LOW
-            else
-              raise ArgumentError,
-                    "Invalid confidence level: '#{value}'. Must be one of: #{VALID_VALUES.join(', ')}"
-            end
-
-            @value = value
-          end
-
-          # String representation of the confidence level.
-          # @return [String] The confidence level value.
-          def to_s
-            @value
-          end
-
-          # String representation of the confidence level.
-          # @return [Integer] The confidence level value as an integer: 1 is LOW, 4 is HIGH.
-          def to_i
-            val_to_i(@value)
-          end
-
-          # Inspect method for debugging.
-          # @return [String] Debug representation.
-          def inspect
-            "#<#{self.class.name}:#{@value}>"
-          end
-
-          # Using 'case' breaks steep ...
-          # rubocop:disable Style/CaseLikeIf
-
-          # Equality of two FieldConfidence instances.
-          # @param other [String, Integer, FieldConfidence] The other confidence to compare.
-          # @return [Boolean] `true` if they have the same value.
-          def ==(other)
-            if other.is_a?(FieldConfidence)
-              @value == other.value
-            elsif other.is_a?(String)
-              @value == other
-            elsif other.is_a?(Integer)
-              to_i == other
-            else
-              raise ArgumentError, "Invalid type: #{other.class}"
-            end
-          end
-
-          # Greater than or equality of two FieldConfidence instances.
-          # @param other [String, Integer, FieldConfidence] The other confidence to compare.
-          def >=(other)
-            if other.is_a?(FieldConfidence)
-              to_i >= val_to_i(other.value)
-            elsif other.is_a?(String)
-              to_i >= val_to_i(other)
-            elsif other.is_a?(Integer)
-              to_i >= other
-            else
-              raise ArgumentError, "Invalid type: #{other.class}"
-            end
-          end
-
-          # less than or equality of two FieldConfidence instances.
-          # # @param other [String, Integer, FieldConfidence] The other confidence to compare.
-          def <=(other)
-            if other.is_a?(FieldConfidence)
-              to_i <= val_to_i(other.value)
-            elsif other.is_a?(String)
-              to_i <= val_to_i(other)
-            elsif other.is_a?(Integer)
-              to_i <= other
-            else
-              raise ArgumentError, "Invalid type: #{other.class}"
-            end
-          end
-
-          # rubocop:enable Style/CaseLikeIf
-
-          # Aliases for the comparison operators.
-          alias eql? ==
-          alias gteql? >=
-          alias lteql? <=
-
-          protected
-
-          def val_to_i(value)
-            case value
-            when CERTAIN then 4
-            when HIGH then 3
-            when MEDIUM then 2
-            when LOW then 1
-            else
-              raise ArgumentError,
-                    "Invalid confidence level: '#{value}'. Must be one of: #{VALID_VALUES.join(', ')}"
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-# 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 = Mindee::Geometry::Polygon.new(server_response['polygon'])
-            @page = server_response['page']
-          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

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base_field'
-
-module Mindee
-  module Parsing
-    module V2
-      module Field
-        # Represents a hash-like collection of inference fields, providing methods for
-        # retrieval and string representation.
-        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
-
-          # Get a field by key and ensure it is a SimpleField.
-          # @param key [String] Field key to retrieve.
-          # @return [SimpleField] The SimpleField.
-          # @raise [TypeError] If the field is not a SimpleField.
-          def get_simple_field(key)
-            field = self[key]
-            raise TypeError, "Field #{key} is not a SimpleField" unless field.is_a?(SimpleField)
-
-            field
-          end
-
-          # Get a field by key and ensure it is a ListField.
-          # @param key [String] Field key to retrieve.
-          # @return [ListField] The ListField.
-          # @raise [TypeError] If the field is not a ListField.
-          def get_list_field(key)
-            field = self[key]
-            raise TypeError, "Field #{key} is not a ListField" unless field.is_a?(ListField)
-
-            field
-          end
-
-          # Get a field by key and ensure it is an ObjectField.
-          # @param key [String] Field key to retrieve.
-          # @return [ObjectField] The ObjectField.
-          # @raise [TypeError] If the field is not an ObjectField.
-          def get_object_field(key)
-            field = self[key]
-            raise TypeError, "Field #{key} is not a ObjectField" unless field.is_a?(ObjectField)
-
-            field
-          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', '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

@@ -1,79 +0,0 @@
-# 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
-          # @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
-
-          # Return only simple fields.
-          # @return [Array<SimpleField>] Simple fields contained in the list.
-          # @raise [TypeError] If the fields are not SimpleField.
-          def simple_items
-            fields = []
-            @items.each do |item|
-              raise TypeError, "Invalid field type detected: #{item.class}" unless item.is_a?(SimpleField)
-
-              fields << item
-            end
-            fields
-          end
-
-          # Return only object fields.
-          # @return [Array<ObjectField>] Object fields contained in the list.
-          # @raise [TypeError] If the fields are not ObjectField.
-          def object_items
-            fields = []
-            @items.each do |item|
-              raise TypeError, "Invalid field type detected: #{item.class}" unless item.is_a?(ObjectField)
-
-              fields << item
-            end
-            fields
-          end
-
-          # String representation of the list field.
-          # @return [String] Formatted string with bullet points for each item.
-          def to_s
-            return '' unless @items && !@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
-        end
-      end
-    end
-  end
-end