mindee 4.12.0 → 5.0.0.beta1

data/lib/mindee/v2/product/classification/classification_inference.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'classification_result'
+require_relative '../../parsing/base_inference'
+
+module Mindee
+  module V2
+    module Product
+      module Classification
+        # The inference result for a classification utility request.
+        class ClassificationInference < Mindee::V2::Parsing::BaseInference
+          # @return [ClassificationResult] Parsed inference payload.
+          attr_reader :result
+
+          # @param server_response [Hash] Hash representation of the JSON returned by the service.
+          def initialize(server_response)
+            super
+
+            @result = ClassificationResult.new(server_response['result'])
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            [
+              super,
+              @result.to_s,
+              '',
+            ].join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/classification/classification_response.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing/base_response'
+require_relative 'classification_inference'
+require_relative 'params/classification_parameters'
+
+module Mindee
+  module V2
+    module Product
+      module Classification
+        # HTTP response wrapper that embeds a V2 Inference.
+        class ClassificationResponse < Mindee::V2::Parsing::BaseResponse
+          # @return [ClassificationInference] Parsed inference payload.
+          attr_reader :inference
+
+          # @param server_response [Hash] Hash parsed from the API JSON response.
+          def initialize(server_response)
+            super
+
+            @inference = ClassificationInference.new(server_response['inference'])
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            @inference.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/classification/classification_result.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'classification_classifier'
+
+module Mindee
+  module V2
+    module Product
+      module Classification
+        # Result of the document classifier inference.
+        class ClassificationResult
+          # @return [ClassificationClassifier] The document type, as identified on given classification values.
+          attr_reader :classification
+
+          # @param server_response [Hash] Hash representation of the JSON returned by the service.
+          def initialize(server_response)
+            @classification = ClassificationClassifier.new(server_response['classification'])
+          end
+
+          # @return [String] String representation.
+          def to_s
+            "Classification\n==============\n#{@classification}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/classification/params/classification_parameters.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V2
+    module Product
+      module Classification
+        # Classification parameters.
+        module Params
+          # Parameters accepted by the classification utility v2 endpoint.
+          class ClassificationParameters < Mindee::Input::BaseParameters
+            # @return [String] Slug for the endpoint.
+            def self.slug
+              'classification'
+            end
+
+            # @param [String] model_id ID of the model
+            # @param [String, nil] file_alias File alias, if applicable.
+            # @param [Array<String>, nil] webhook_ids List of webhook IDs to propagate the API response to.
+            # @param [Hash, nil] polling_options Options for polling. Set only if having timeout issues.
+            # @param [Boolean, nil] close_file Whether to close the file after parsing.
+            def initialize(
+              model_id,
+              file_alias: nil,
+              webhook_ids: nil,
+              polling_options: nil,
+              close_file: true
+            )
+              super
+            end
+
+            # Loads the parameters from a Hash.
+            # @param [Hash] params Parameters to provide as a hash.
+            # @return [ClassificationParameters]
+            def self.from_hash(params: {})
+              ClassificationParameters.new(
+                params.fetch(:model_id),
+                file_alias: params.fetch(:file_alias, nil),
+                webhook_ids: params.fetch(:webhook_ids, nil),
+                close_file: params.fetch(:close_file, true)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/crop/crop.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'crop_response'
+require_relative 'params/crop_parameters'
+
+module Mindee
+  module V2
+    module Product
+      # Crop module.
+      module Crop
+        # Crop product.
+        class Crop < BaseProduct
+          @slug = 'crop'
+          @params_type = Mindee::V2::Product::Crop::Params::CropParameters
+          @response_type = Mindee::V2::Product::Crop::CropResponse
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/crop/crop_inference.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'crop_result'
+
+module Mindee
+  module V2
+    module Product
+      module Crop
+        # The inference result for a crop utility request.
+        class CropInference < Mindee::V2::Parsing::BaseInference
+          # @return [CropResult] Parsed inference payload.
+          attr_reader :result
+
+          # @param server_response [Hash] Hash representation of the JSON returned by the service.
+          def initialize(server_response)
+            super
+
+            @result = CropResult.new(server_response['result'])
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            [
+              super,
+              @result.to_s,
+              '',
+            ].join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/crop/crop_item.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V2
+    module Product
+      module Crop
+        # Result of a cropped document region.
+        class CropItem
+          # @return [String] Type or classification of the detected object.
+          attr_reader :object_type
+          # @return [V2::Parsing::Field::FieldLocation] Coordinates of the detected object on the document.
+          attr_reader :location
+
+          # @param server_response [Hash] Hash representation of the JSON returned by the service.
+          def initialize(server_response)
+            @object_type = server_response['object_type']
+            @location = Mindee::V2::Parsing::Field::FieldLocation.new(server_response['location'])
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            "* :Location: #{location}\n  :Object Type: #{object_type}"
+          end
+
+          # Extract all crop items from this page
+          #
+          # @param input_source [Mindee::Input::Source::LocalInputSource] Local file to extract from
+          # @return [ExtractedImage]
+          def extract_from_file(input_source)
+            Image::ImageExtractor.extract_multiple_images_from_source(
+              input_source, @location.page, [@location.polygon]
+            )[0]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/crop/crop_response.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing/base_response'
+require_relative 'params/crop_parameters'
+require_relative 'crop_inference'
+
+module Mindee
+  module V2
+    module Product
+      module Crop
+        # HTTP response wrapper that embeds a V2 Inference.
+        class CropResponse < Mindee::V2::Parsing::BaseResponse
+          # @return [CropInference] Parsed inference payload.
+          attr_reader :inference
+
+          # @param server_response [Hash] Hash parsed from the API JSON response.
+          def initialize(server_response)
+            super
+
+            @inference = CropInference.new(server_response['inference'])
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            @inference.to_s
+          end
+
+          # Apply the crop inference to a file and return a list of extracted images.
+          #
+          # @param input_source [Mindee::Input::Source::LocalInputSource] Local file to extract from
+          # @return [FileOperation::CropFiles] List of extracted PDFs
+          def extract_from_file(input_source)
+            FileOperation::Crop.extract_crops(input_source, @inference.result.crops)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/crop/crop_result.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'crop_item'
+
+module Mindee
+  module V2
+    module Product
+      module Crop
+        # Result of a crop utility inference.
+        class CropResult
+          # @return [Array<Cropitem>] List of results of cropped document regions.
+          attr_reader :crops
+
+          # @param server_response [Hash] Hash representation of the JSON returned by the service.
+          def initialize(server_response)
+            @crops = if server_response.key?('crops')
+                       server_response['crops'].map do |crop|
+                         CropItem.new(crop)
+                       end
+                     end
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            crops_str = @crops.join("\n")
+
+            "Crops\n=====\n#{crops_str}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/crop/params/crop_parameters.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V2
+    module Product
+      module Crop
+        # Crop parameters.
+        module Params
+          # Parameters accepted by the crop utility v2 endpoint.
+          class CropParameters < Mindee::Input::BaseParameters
+            # @return [String] Slug for the endpoint.
+            def self.slug
+              'crop'
+            end
+
+            # @param [String] model_id ID of the model
+            # @param [String, nil] file_alias File alias, if applicable.
+            # @param [Array<String>, nil] webhook_ids List of webhook IDs to propagate the API response to.
+            # @param [Hash, nil] polling_options Options for polling. Set only if having timeout issues.
+            # @param [Boolean, nil] close_file Whether to close the file after parsing.
+            def initialize(
+              model_id,
+              file_alias: nil,
+              webhook_ids: nil,
+              polling_options: nil,
+              close_file: true
+            )
+              super
+            end
+
+            # Loads the parameters from a Hash.
+            # @param [Hash] params Parameters to provide as a hash.
+            # @return [CropParameters]
+            def self.from_hash(params: {})
+              CropParameters.new(
+                params.fetch(:model_id),
+                file_alias: params.fetch(:file_alias, nil),
+                webhook_ids: params.fetch(:webhook_ids, nil),
+                close_file: params.fetch(:close_file, true)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/extraction/extraction.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'extraction_response'
+require_relative 'params/extraction_parameters'
+
+module Mindee
+  module V2
+    module Product
+      # Extraction module.
+      module Extraction
+        # Extraction product.
+        # Note: currently a placeholder for the `Inference` class.
+        class Extraction < Product::BaseProduct
+          @slug = 'extraction'
+          @params_type = Product::Extraction::Params::ExtractionParameters
+          @response_type = Product::Extraction::ExtractionResponse
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/extraction/extraction_inference.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'extraction_response'
+require_relative 'extraction_result'
+require_relative 'params/extraction_parameters'
+
+module Mindee
+  module V2
+    module Product
+      module Extraction
+        # Extraction inference.
+        class ExtractionInference < Mindee::V2::Parsing::BaseInference
+          # @return [InferenceActiveOptions] Options which were activated during the inference.
+          attr_reader :active_options
+          # @return [ExtractionResult] Result contents.
+          attr_reader :result
+
+          # @param server_response [Hash] Hash representation of the JSON returned by the service.
+          def initialize(server_response)
+            super
+
+            @active_options = V2::Parsing::InferenceActiveOptions.new(server_response['active_options'])
+            @result = ExtractionResult.new(server_response['result'])
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            [
+              super,
+              @active_options.to_s,
+              @result.to_s,
+              '',
+            ].join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/extraction/extraction_response.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'extraction_inference'
+
+module Mindee
+  module V2
+    module Product
+      module Extraction
+        # HTTP response wrapper that embeds a V2 Inference.
+        class ExtractionResponse < Mindee::V2::Parsing::BaseResponse
+          # @return [ExtractionInference] Parsed inference payload.
+          attr_reader :inference
+
+          @slug = 'extraction'
+          @_params_type = Params::ExtractionParameters
+
+          def initialize(server_response)
+            super
+
+            @inference = Mindee::V2::Product::Extraction::ExtractionInference.new(server_response['inference'])
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            @inference.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/extraction/extraction_result.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../../parsing'
+
+module Mindee
+  module V2
+    module Product
+      module Extraction
+        # Result of an extraction utility inference.
+        class ExtractionResult
+          # @return [Mindee::V2::Parsing::Field::InferenceFields] Fields produced by the model.
+          attr_reader :fields
+          # @return [Mindee::V2::Parsing::RawText, nil] Optional extra data.
+          attr_reader :raw_text
+          # @return [Mindee::V2::Parsing::RAGMetadata, nil] Optional RAG metadata.
+          attr_reader :rag
+
+          # @param server_response [Hash] Hash version of the JSON returned by the API.
+          def initialize(server_response)
+            raise ArgumentError, 'server_response must be a Hash' unless server_response.is_a?(Hash)
+
+            @fields = Parsing::Field::InferenceFields.new(server_response['fields'])
+
+            @raw_text = server_response['raw_text'] ? Parsing::RawText.new(server_response['raw_text']) : nil
+            return unless server_response.key?('rag') && server_response['rag']
+
+            @rag = Parsing::RAGMetadata.new(server_response['rag'])
+          end
+
+          # String representation.
+          # @return [String]
+          def to_s
+            parts = [
+              'Fields',
+              '======',
+              @fields.to_s,
+            ]
+            parts.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/extraction/params/data_schema.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'data_schema_replace'
+
+module Mindee
+  module V2
+    module Product
+      module Extraction
+        # Extraction parameters.
+        module Params
+          # Modify the Data Schema.
+          class DataSchema
+            # @return [Mindee::V2::Product::Extraction::Params::DataSchemaReplace]
+            attr_reader :replace
+
+            # @param data_schema [Hash, String]
+            def initialize(data_schema)
+              case data_schema
+              when String
+                parsed = JSON.parse(data_schema.to_s, object_class: Hash)
+                parsed.transform_keys!(&:to_sym)
+                @replace = DataSchemaReplace.new(parsed[:replace])
+              when Hash
+                data_schema.transform_keys!(&:to_sym)
+                @replace = if data_schema[:replace].is_a?(DataSchemaReplace)
+                             data_schema[:replace]
+                           else
+                             DataSchemaReplace.new(data_schema[:replace])
+                           end
+              when DataSchema
+                @replace = data_schema.replace
+              else
+                raise TypeError, 'Invalid Data Schema provided.'
+              end
+            end
+
+            # @return [Hash]
+            def to_hash
+              { replace: @replace.to_hash }
+            end
+
+            # @return [String]
+            def to_s
+              to_hash.to_json
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/extraction/params/data_schema_field.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Mindee
+  module V2
+    module Product
+      module Extraction
+        module Params
+          # Data Schema Field.
+          class DataSchemaField
+            # @return [String] Display name for the field, also impacts inference results.
+            attr_reader :title
+            # @return [String] Name of the field in the data schema.
+            attr_reader :name
+            # @return [Boolean] Whether this field can contain multiple values.
+            attr_reader :is_array
+            # @return [String] Data type of the field.
+            attr_reader :type
+            # @return [Array<String>, nil] Allowed values when type is `classification`. Leave empty for other types.
+            attr_reader :classification_values
+            # @return [Boolean, nil] Whether to remove duplicate values in the array.
+            # Only applicable if `is_array` is True.
+            attr_reader :unique_values
+            # @return [String, nil] Detailed description of what this field represents.
+            attr_reader :description
+            # @return [String, nil] Optional extraction guidelines.
+            attr_reader :guidelines
+            # @return [Array<Hash>, nil] Nested fields.
+            attr_reader :nested_fields
+
+            # @param field [Hash]
+            def initialize(field)
+              field.transform_keys!(&:to_sym)
+              @name = field[:name]
+              @title = field[:title]
+              @is_array = field[:is_array]
+              @type = field[:type]
+              @classification_values = field[:classification_values]
+              @unique_values = field[:unique_values]
+              @description = field[:description]
+              @guidelines = field[:guidelines]
+              @nested_fields = field[:nested_fields]
+            end
+
+            # @return [Hash]
+            def to_hash
+              out = {
+                name: @name,
+                title: @title,
+                is_array: @is_array,
+                type: @type,
+              } # @type var out: Hash[Symbol, untyped]
+              out[:classification_values] = @classification_values unless @classification_values.nil?
+              out[:unique_values] = @unique_values unless @unique_values.nil?
+              out[:description] = @description unless @description.nil?
+              out[:guidelines] = @guidelines unless @guidelines.nil?
+              out[:nested_fields] = @nested_fields unless @nested_fields.nil?
+              out
+            end
+
+            # @return [String]
+            def to_s
+              to_hash.to_json
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mindee/v2/product/extraction/params/data_schema_replace.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'data_schema_field'
+
+module Mindee
+  module V2
+    module Product
+      module Extraction
+        module Params
+          # The structure to completely replace the data schema of the model.
+          class DataSchemaReplace
+            # @return [Array<DataSchemaField>] Subfields when type is `nested_object`. Leave empty for other types.
+            attr_reader :fields
+
+            # @param data_schema_replace [Hash]
+            def initialize(data_schema_replace)
+              data_schema_replace.transform_keys!(&:to_sym)
+              fields_list = data_schema_replace[:fields]
+              raise Mindee::Error::MindeeError, 'Invalid Data Schema provided.' if fields_list.nil?
+              raise TypeError, 'Data Schema replacement fields cannot be empty.' if fields_list.empty?
+
+              @fields = fields_list.map { |field| DataSchemaField.new(field) }
+            end
+
+            # @return [Hash]
+            def to_hash
+              { fields: @fields.map(&:to_hash) }
+            end
+
+            # @return [String]
+            def to_s
+              to_hash.to_json
+            end
+          end
+        end
+      end
+    end
+  end
+end