♻️ use hashes for request parameters

lib/mindee/v2/client_options/base_product_parameters.rb

@@ -78,13 +78,15 @@ def self.load_from_hash(params: {})
           params
         end
 
-        # Appends base form data to the provided array.
-        # @param [Array] form_data Array of form fields
-        # @return [Array]
-        def append_form_data(form_data)
-          form_data.push(['alias', @file_alias]) if @file_alias
-          webhook_ids = @webhook_ids || []
-          form_data.push(['webhook_ids', webhook_ids.join(',')]) unless @webhook_ids.nil? || webhook_ids.empty?
+        # Gets the base request parameters for the endpoint.
+        # @return [Hash{String => String, Array<String>}]
+        def request_parameters
+          form_data = {} # : Hash[String, String | Array[String]]
+          form_data['model_id'] = @model_id
+          file_alias = @file_alias
+          form_data['alias'] = file_alias if file_alias
+          webhook_ids = @webhook_ids
+          form_data['webhook_ids'] = webhook_ids.join(',') if webhook_ids && !webhook_ids.empty?
           form_data
         end
       end

lib/mindee/v2/http/mindee_api_v2.rb

@@ -156,22 +156,27 @@ def poll(url)
         def enqueue(input_source, params)
           uri = URI("#{@settings.base_url}/v2/products/#{params.slug}/enqueue")
 
-          form_data = if input_source.is_a?(Mindee::Input::Source::URLInputSource)
-                        [['url', input_source.url]] # : Array[Array[untyped]]
-                      else
-                        file_data, file_metadata = input_source.read_contents(close: params.close_file)
-                        [['file', file_data, file_metadata]] # : Array[Array[untyped]]
-                      end
-          form_data.push(['model_id', params.model_id])
-          form_data = params.append_form_data(form_data)
+          form_data = {} # : Hash[String, untyped]
+          if input_source.is_a?(Mindee::Input::Source::URLInputSource)
+            form_data['url'] = input_source.url
+          else
+            file_data, file_metadata = input_source.read_contents(close: params.close_file)
+            form_data['file'] = [file_data, file_metadata]
+          end
+          form_data.merge!(params.request_parameters)
+
+          # Convert hash to the array format required by Net::HTTP multipart
+          form_data_list = form_data.map do |k, v|
+            v.is_a?(Array) ? [k.to_s, *v] : [k.to_s, v]
+          end
 
           headers = {
             'Authorization' => @settings.api_key,
             'User-Agent' => @settings.user_agent,
           }
           req = Net::HTTP::Post.new(uri, headers)
 
-          req.set_form(form_data, 'multipart/form-data')
+          req.set_form(form_data_list, 'multipart/form-data')
           req['Transfer-Encoding'] = 'chunked'
 
           Net::HTTP.start(uri.hostname, uri.port,

lib/mindee/v2/product/extraction/params/extraction_parameters.rb

@@ -76,20 +76,20 @@ def initialize(
               # rubocop:enable Metrics/ParameterLists
             end
 
-            # Appends inference-specific form data to the provided array.
-            # @param [Array] form_data Array of form fields
-            # @return [Array]
-            def append_form_data(form_data)
-              new_form_data = super
+            # Gets inference-specific request parameters.
+            # @return [Hash{String => String, Array<String>}]
+            def request_parameters
+              form_data = super
 
-              new_form_data.push(['rag', @rag.to_s]) unless @rag.nil?
-              new_form_data.push(['raw_text', @raw_text.to_s]) unless @raw_text.nil?
-              new_form_data.push(['polygon', @polygon.to_s]) unless @polygon.nil?
-              new_form_data.push(['confidence', @confidence.to_s]) unless @confidence.nil?
-              new_form_data.push(['text_context', @text_context]) if @text_context
-              new_form_data.push(['data_schema', @data_schema.to_s]) if @data_schema
+              form_data['rag'] = @rag.to_s unless @rag.nil?
+              form_data['raw_text'] = @raw_text.to_s unless @raw_text.nil?
+              form_data['polygon'] = @polygon.to_s unless @polygon.nil?
+              form_data['confidence'] = @confidence.to_s unless @confidence.nil?
+              text_context = @text_context
+              form_data['text_context'] = text_context if text_context
+              form_data['data_schema'] = @data_schema.to_s if @data_schema
 
-              new_form_data
+              form_data
             end
 
             # Loads a prediction from a Hash.

lib/mindee/v2/search/models/model_search_parameters.rb

@@ -44,7 +44,6 @@ def request_parameters
             model_type = @model_type
             params['name'] = name unless name.nil?
             params['model_type'] = model_type unless model_type.nil?
-
             params
           end
         end

lib/mindee/v2/search/rag_documents/rag_document_search_parameters.rb

@@ -42,7 +42,6 @@ def request_parameters
             params['model_id'] = @model_id
             filename = @filename
             params['filename'] = filename unless filename.nil?
-
             params
           end
         end

sig/mindee/v2/client_options/base_product_parameters.rbs

@@ -24,7 +24,7 @@ module Mindee
             ?close_file: bool?
           ) -> void
 
-        def append_form_data: (Array[Array[untyped]]) -> Array[Array[untyped]]
+        def request_parameters: -> Hash[String, String | Array[String]]
       end
     end
   end

sig/mindee/v2/product/extraction/params/extraction_parameters.rbs

@@ -28,7 +28,7 @@ module Mindee
               ) -> void
 
             def self.from_hash: (params: Hash[String | Symbol, untyped]) -> ExtractionParameters
-            def append_form_data: (Array[Array[untyped]]) -> Array[Array[untyped]]
+            def request_parameters: -> Hash[String, String | Array[String]]
           end
         end
       end

spec/v2/product/extraction/extraction_parameter_spec.rb

@@ -1,19 +1,27 @@
 # frozen_string_literal: true
 
+require 'json'
+require_relative '../../../data'
+
 require 'mindee/v2/product/extraction/params/data_schema'
 require 'mindee/v2/product/extraction/params/extraction_parameters'
 
 describe Mindee::V2::Product::Extraction::Params::ExtractionParameters do
-  let(:extracted_schema_content) do
-    File.read(File.join(V2_PRODUCT_DATA_DIR, 'extraction', 'data_schema_replace_param.json'))
+  let(:replace_path) { File.join(V2_PRODUCT_DATA_DIR, 'extraction', 'data_schema_replace_param.json') }
+  let(:data_schema_dict) { JSON.parse(File.read(replace_path)) }
+  let(:data_schema_string) { data_schema_dict.to_json }
+  let(:data_schema_instance) { Mindee::V2::Product::Extraction::Params::DataSchema.new(data_schema_dict) }
+
+  it 'should init with minimum values' do
+    model_id = 'dummy-model'
+    product_params = Mindee::V2::Product::Extraction::Params::ExtractionParameters.new(model_id)
+    expect(product_params.model_id).to eq(model_id)
+    expect(product_params.request_parameters['model_id']).to eq(model_id)
   end
-  let(:extracted_schema_hash) { JSON.parse(extracted_schema_content) }
-  let(:extracted_schema_str) { extracted_schema_hash.to_json }
-  let(:extracted_schema_object) { Mindee::V2::Product::Extraction::Params::DataSchema.new(extracted_schema_hash) }
 
   describe 'Data Schema' do
     describe "shouldn't replace when unset" do
-      it 'should initialize with a data schema' do
+      it 'should leave unset when not provided' do
         param = Mindee::V2::Product::Extraction::Params::ExtractionParameters.new(
           'dummy-model'
         )
@@ -23,26 +31,50 @@
       it 'should initialize with string' do
         param = Mindee::V2::Product::Extraction::Params::ExtractionParameters.new(
           'dummy-model',
-          data_schema: extracted_schema_str
+          data_schema: data_schema_string
         )
-        expect(param.data_schema.to_s).to eq(extracted_schema_str)
+        expect(param.data_schema.to_s).to eq(data_schema_string)
       end
 
       it 'should initialize with hash' do
         param = Mindee::V2::Product::Extraction::Params::ExtractionParameters.new(
           'dummy-model',
-          data_schema: extracted_schema_hash
+          data_schema: data_schema_dict
         )
-        expect(param.data_schema.to_s).to eq(extracted_schema_str)
+        expect(param.data_schema.to_s).to eq(data_schema_string)
       end
 
       it 'should initialize with DataSchema object' do
         param = Mindee::V2::Product::Extraction::Params::ExtractionParameters.new(
           'dummy-model',
-          data_schema: extracted_schema_object
+          data_schema: data_schema_instance
         )
-        expect(param.data_schema.to_s).to eq(extracted_schema_str)
+        expect(param.data_schema.to_s).to eq(data_schema_string)
       end
     end
   end
+
+  describe 'request_parameters' do
+    it 'returns hash with correct parameters' do
+      param = Mindee::V2::Product::Extraction::Params::ExtractionParameters.new(
+        'dummy-model',
+        text_context: 'sample context',
+        webhook_ids: ['hook-1', 'hook-2'],
+        file_alias: 'my_file',
+        rag: true,
+        raw_text: false,
+        polygon: true,
+        confidence: false
+      )
+      params = param.request_parameters
+      expect(params['model_id']).to eq('dummy-model')
+      expect(params['alias']).to eq('my_file')
+      expect(params['webhook_ids']).to eq('hook-1,hook-2')
+      expect(params['text_context']).to eq('sample context')
+      expect(params['rag']).to eq('true')
+      expect(params['raw_text']).to eq('false')
+      expect(params['polygon']).to eq('true')
+      expect(params['confidence']).to eq('false')
+    end
+  end
 end

spec/v2/search/model_search_spec.rb

@@ -33,3 +33,14 @@
     expect(last_item.id).to eq('e14e0923-ee55-ee55-a335-8d2110917d7b')
   end
 end
+
+describe Mindee::V2::Search::Models::ModelSearchParameters do
+  it 'builds request parameters' do
+    search_parameters = described_class.new(name: 'my-model', model_type: 'extraction', page: 2, per_page: 10)
+    request_parameters = search_parameters.request_parameters
+    expect(request_parameters['page']).to eq('2')
+    expect(request_parameters['per_page']).to eq('10')
+    expect(request_parameters['name']).to eq('my-model')
+    expect(request_parameters['model_type']).to eq('extraction')
+  end
+end

spec/v2/search/rag_document_search_spec.rb

@@ -46,3 +46,14 @@
     expect(third_item.status).to eq('Active')
   end
 end
+
+describe Mindee::V2::Search::RAGDocuments::RAGDocumentSearchParameters do
+  it 'builds request parameters' do
+    search_params = described_class.new(model_id: 'my-model-id', filename: 'test.pdf', page: 1, per_page: 25)
+    request_parameters = search_params.request_parameters
+    expect(request_parameters['page']).to eq('1')
+    expect(request_parameters['per_page']).to eq('25')
+    expect(request_parameters['model_id']).to eq('my-model-id')
+    expect(request_parameters['filename']).to eq('test.pdf')
+  end
+end