✨ add optional features

Author: ianardee

lib/mindee/http/mindee_api_v2.rb

@@ -124,7 +124,13 @@ def enqueue(input_source, params)
                       [['file', file_data, file_metadata]] # : Array[untyped]
                     end
         form_data.push ['model_id', params.model_id]
-        form_data.push ['rag', 'true'] if params.rag
+
+        # deal with optional features
+        form_data.push ['rag', params.rag.to_s.downcase] unless params.rag.nil?
+        form_data.push ['raw_text', params.rag.to_s.downcase] unless params.raw_text.nil?
+        form_data.push ['polygon', params.rag.to_s.downcase] unless params.polygon.nil?
+        form_data.push ['confidence', params.rag.to_s.downcase] unless params.confidence.nil?
+
         form_data.push ['file_alias', params.file_alias] if params.file_alias
         unless params.webhook_ids.nil? || params.webhook_ids.empty?
           form_data.push ['webhook_ids', params.webhook_ids.join(',')]

lib/mindee/input/inference_parameters.rb

@@ -7,9 +7,19 @@ class InferenceParameters
       # @return [String] ID of the model (required).
       attr_reader :model_id
 
-      # @return [Boolean, nil] Enable Retrieval-Augmented Generation.
+      # @return [Boolean, nil] Enhance extraction accuracy with Retrieval-Augmented Generation.
       attr_reader :rag
 
+      # @return [Boolean, nil] Extract the full text content from the document as strings, and fill the raw_text` attribute.
+      attr_reader :raw_text
+
+      # @return [Boolean, nil] Calculate bounding box polygons for all fields, and fill their `locations` attribute.
+      attr_reader :polygon
+
+      # @return [Boolean, nil] Boost the precision and accuracy of all extractions.
+      # Calculate confidence scores for all fields, and fill their confidence attribute.
+      attr_reader :confidence
+
       # @return [String, nil] Optional alias for the file.
       attr_reader :file_alias
 
@@ -23,16 +33,32 @@ class InferenceParameters
       attr_reader :close_file
 
       # @param [String] model_id ID of the model
-      # @param [FalseClass] rag Whether to enable rag.
+      # @param [nil] rag Whether to enable RAG.
+      # @param [nil] raw_text Whether to enable rax text.
+      # @param [nil] polygon Whether to enable polygons.
+      # @param [nil] confidence Whether to enable confidence scores.
       # @param [nil] file_alias File alias, if applicable.
       # @param [nil] webhook_ids
       # @param [nil] polling_options
       # @param [TrueClass] close_file
-      def initialize(model_id, rag: false, file_alias: nil, webhook_ids: nil, polling_options: nil, close_file: true)
+      def initialize(
+        model_id,
+        rag: nil,
+        raw_text: nil,
+        polygon: nil,
+        confidence: nil,
+        file_alias: nil,
+        webhook_ids: nil,
+        polling_options: nil,
+        close_file: true
+      )
         raise Errors::MindeeInputError, 'Model ID is required.' if model_id.empty? || model_id.nil?
 
         @model_id = model_id
-        @rag = rag || false
+        @rag = rag
+        @raw_text = raw_text
+        @polygon = polygon
+        @confidence = confidence
         @file_alias = file_alias
         @webhook_ids = webhook_ids || []
         @polling_options = get_clean_polling_options(polling_options)
@@ -70,7 +96,10 @@ def self.from_hash(params: {})
         end
 
         model_id = params.fetch(:model_id)
-        rag = params.fetch(:rag, false)
+        rag = params.fetch(:rag, nil)
+        raw_text = params.fetch(:raw_text, nil)
+        polygon = params.fetch(:polygon, nil)
+        confidence = params.fetch(:confidence, nil)
         file_alias = params.fetch(:file_alias, nil)
         webhook_ids = params.fetch(:webhook_ids, [])
         polling_options_input = params.fetch(:page_options, PollingOptions.new)
@@ -83,8 +112,8 @@ def self.from_hash(params: {})
           )
         end
         close_file = params.fetch(:close_file, true)
-        InferenceParameters.new(model_id, rag: rag, file_alias: file_alias, webhook_ids: webhook_ids,
-                                          close_file: close_file)
+        InferenceParameters.new(model_id, rag: rag, raw_text: raw_text, polygon: polygon, confidence: confidence,
+                                          file_alias: file_alias, webhook_ids: webhook_ids, close_file: close_file)
       end
 
       private

sig/mindee/input/inference_parameters.rbs

@@ -3,15 +3,21 @@ module Mindee
   module Input
     class InferenceParameters
       attr_reader close_file: bool
+      attr_reader confidence: bool?
       attr_reader file_alias: String?
       attr_reader model_id: String
       attr_reader polling_options: PollingOptions
+      attr_reader polygon: bool?
       attr_reader rag: bool?
+      attr_reader raw_text: bool?
       attr_reader webhook_ids: Array[String]?
 
       def initialize: (
           String,
           ?rag: bool?,
+          ?raw_text: bool?,
+          ?polygon: bool?,
+          ?confidence: bool?,
           ?file_alias: String?,
           ?webhook_ids: Array[String]?,
           ?polling_options: Hash[Symbol | String, untyped] | PollingOptions?,

spec/client_v2_integration.rb

@@ -17,49 +17,90 @@
       max_retries: 80
     )
 
-    params = Mindee::Input::InferenceParameters.new(model_id,
-                                                    rag: false,
-                                                    file_alias: 'ruby-integration-test',
-                                                    polling_options: polling)
+    params = Mindee::Input::InferenceParameters.new(
+      model_id,
+      rag: false,
+      raw_text: true,
+      polygon: false,
+      confidence: false,
+      file_alias: 'ruby-integration-test',
+      polling_options: polling
+    )
 
     response = client.enqueue_and_get_inference(input, params)
 
     expect(response).not_to be_nil
     expect(response.inference).not_to be_nil
 
-    expect(response.inference.file).not_to be_nil
-    expect(response.inference.file.name).to eq('multipage_cut-2.pdf')
+    file = response.inference.file
+    expect(file).not_to be_nil
+    expect(file).to be_a(Mindee::Parsing::V2::InferenceFile)
+    expect(file.name).to eq('multipage_cut-2.pdf')
+    expect(file.page_count).to eq(2)
+
+    model = response.inference.model
+    expect(model).not_to be_nil
+    expect(model).to be_a(Mindee::Parsing::V2::InferenceModel)
+    expect(model.id).to eq(model_id)
 
-    expect(response.inference.model).not_to be_nil
-    expect(response.inference.model.id).to eq(model_id)
+    active_options = response.inference.active_options
+    expect(active_options).not_to be_nil
+    expect(active_options).to be_a(Mindee::Parsing::V2::InferenceActiveOptions)
+    expect(active_options.raw_text).to eq(true)
+    expect(active_options.polygon).to eq(false)
+    expect(active_options.confidence).to eq(false)
+    expect(active_options.rag).to eq(false)
 
-    expect(response.inference.active_options).not_to be_nil
+    result = response.inference.result
+    expect(result).not_to be_nil
 
-    expect(response.inference.result).not_to be_nil
-    expect(response.inference.result.raw_text).to be_nil
-    expect(response.inference.result.fields).not_to be_nil
+    expect(result.raw_text).not_to be_nil
+    expect(result.raw_text.pages.length).to eq(2)
+
+    expect(result.fields).not_to be_nil
   end
 
   it 'parses a filled single-page image successfully' do
     src_path = File.join(__dir__ || './', 'data', 'products', 'financial_document', 'default_sample.jpg')
     input = Mindee::Input::Source::FileInputSource.new(File.open(src_path, 'rb'), 'default_sample.jpg')
 
-    params = Mindee::Input::InferenceParameters.new(model_id,
-                                                    rag: false,
-                                                    file_alias: 'ruby-integration-test')
+    params = Mindee::Input::InferenceParameters.new(
+      model_id,
+      raw_text: false,
+      polygon: false,
+      confidence: false,
+      rag: false,
+      file_alias: 'ruby-integration-test'
+    )
 
     response = client.enqueue_and_get_inference(input, params)
     expect(response).not_to be_nil
 
-    expect(response.inference).not_to be_nil
-    expect(response.inference.file.name).to eq('default_sample.jpg')
+    file = response.inference.file
+    expect(file).not_to be_nil
+    expect(file).to be_a(Mindee::Parsing::V2::InferenceFile)
+    expect(file.name).to eq('default_sample.jpg')
+    expect(file.page_count).to eq(1)
+
+    model = response.inference.model
+    expect(model).not_to be_nil
+    expect(model).to be_a(Mindee::Parsing::V2::InferenceModel)
+    expect(model.id).to eq(model_id)
+
+    active_options = response.inference.active_options
+    expect(active_options).not_to be_nil
+    expect(active_options).to be_a(Mindee::Parsing::V2::InferenceActiveOptions)
+    expect(active_options.raw_text).to eq(true)
+    expect(active_options.polygon).to eq(false)
+    expect(active_options.confidence).to eq(false)
+    expect(active_options.rag).to eq(false)
 
-    expect(response.inference.model).not_to be_nil
-    expect(response.inference.model.id).to eq(model_id)
+    result = response.inference.result
+    expect(result).not_to be_nil
 
-    expect(response.inference.active_options).not_to be_nil
+    expect(result.raw_text).to be_nil
 
-    fields = response.inference.result.fields
+    fields = result.fields
     expect(fields).not_to be_nil
     expect(fields['supplier_name']).not_to be_nil
     expect(fields['supplier_name'].value).to eq('John Smith')