vellum_ai 0.3.15 → 0.14.75

data/lib/vellum_ai/types/test_case_string_variable_value.rb

@@ -1,50 +1,78 @@
 # frozen_string_literal: true
-
+require "ostruct"
 require "json"
 
 module Vellum
+# A string value for a variable in a Test Case.
   class TestCaseStringVariableValue
-    attr_reader :variable_id, :value, :additional_properties
+  # @return [String] 
+    attr_reader :variable_id
+  # @return [String] 
+    attr_reader :name
+  # @return [String] 
+    attr_reader :type
+  # @return [String] 
+    attr_reader :value
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
 
-    # @param variable_id [String]
-    # @param value [String]
+    # @param variable_id [String] 
+    # @param name [String] 
+    # @param type [String] 
+    # @param value [String] 
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [TestCaseStringVariableValue]
-    def initialize(variable_id:, value: nil, additional_properties: nil)
-      # @type [String]
+    # @return [Vellum::TestCaseStringVariableValue]
+    def initialize(variable_id:, name:, type:, value: OMIT, additional_properties: nil)
       @variable_id = variable_id
-      # @type [String]
-      @value = value
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @name = name
+      @type = type
+      @value = value if value != OMIT
       @additional_properties = additional_properties
+      @_field_set = { "variable_id": variable_id, "name": name, "type": type, "value": value }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of TestCaseStringVariableValue
+# Deserialize a JSON object to an instance of TestCaseStringVariableValue
     #
-    # @param json_object [JSON]
-    # @return [TestCaseStringVariableValue]
+    # @param json_object [String] 
+    # @return [Vellum::TestCaseStringVariableValue]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
-      JSON.parse(json_object)
-      variable_id = struct.variable_id
-      value = struct.value
-      new(variable_id: variable_id, value: value, additional_properties: struct)
+      parsed_json = JSON.parse(json_object)
+      variable_id = parsed_json["variable_id"]
+      name = parsed_json["name"]
+      type = parsed_json["type"]
+      value = parsed_json["value"]
+      new(
+        variable_id: variable_id,
+        name: name,
+        type: type,
+        value: value,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of TestCaseStringVariableValue to a JSON object
+# Serialize an instance of TestCaseStringVariableValue to a JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "variable_id": @variable_id, "value": @value }.to_json
+    # @return [String]
+    def to_json
+      @_field_set&.to_json
     end
-
-    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+# Leveraged for Union-type generation, validate_raw attempts to parse the given
+#  hash and check each fields type against the current object's property
+#  definitions.
     #
-    # @param obj [Object]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
       obj.variable_id.is_a?(String) != false || raise("Passed value for field obj.variable_id is not the expected type, validation failed.")
+      obj.name.is_a?(String) != false || raise("Passed value for field obj.name is not the expected type, validation failed.")
+      obj.type.is_a?(String) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
       obj.value&.is_a?(String) != false || raise("Passed value for field obj.value is not the expected type, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/test_case_variable_value.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 require "json"
 require_relative "test_case_string_variable_value"
 require_relative "test_case_number_variable_value"
@@ -7,136 +6,149 @@ require_relative "test_case_json_variable_value"
 require_relative "test_case_chat_history_variable_value"
 require_relative "test_case_search_results_variable_value"
 require_relative "test_case_error_variable_value"
+require_relative "test_case_function_call_variable_value"
+require_relative "test_case_array_variable_value"
 
 module Vellum
   class TestCaseVariableValue
-    attr_reader :member, :discriminant
 
-    private_class_method :new
-    alias kind_of? is_a?
-    # @param member [Object]
-    # @param discriminant [String]
-    # @return [TestCaseVariableValue]
-    def initialize(member:, discriminant:)
-      # @type [Object]
-      @member = member
-      # @type [String]
-      @discriminant = discriminant
-    end
 
-    # Deserialize a JSON object to an instance of TestCaseVariableValue
+# Deserialize a JSON object to an instance of TestCaseVariableValue
     #
-    # @param json_object [JSON]
-    # @return [TestCaseVariableValue]
+    # @param json_object [String] 
+    # @return [Vellum::TestCaseVariableValue]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
-      member = case struct.type
-               when "STRING"
-                 TestCaseStringVariableValue.from_json(json_object: json_object)
-               when "NUMBER"
-                 TestCaseNumberVariableValue.from_json(json_object: json_object)
-               when "JSON"
-                 TestCaseJsonVariableValue.from_json(json_object: json_object)
-               when "CHAT_HISTORY"
-                 TestCaseChatHistoryVariableValue.from_json(json_object: json_object)
-               when "SEARCH_RESULTS"
-                 TestCaseSearchResultsVariableValue.from_json(json_object: json_object)
-               when "ERROR"
-                 TestCaseErrorVariableValue.from_json(json_object: json_object)
-               else
-                 TestCaseStringVariableValue.from_json(json_object: json_object)
-               end
-      new(member: member, discriminant: struct.type)
-    end
-
-    # For Union Types, to_json functionality is delegated to the wrapped member.
-    #
-    # @return [JSON]
-    def to_json(*_args)
-      case @discriminant
-      when "STRING"
-        { **@member.to_json, type: @discriminant }.to_json
-      when "NUMBER"
-        { **@member.to_json, type: @discriminant }.to_json
-      when "JSON"
-        { **@member.to_json, type: @discriminant }.to_json
-      when "CHAT_HISTORY"
-        { **@member.to_json, type: @discriminant }.to_json
-      when "SEARCH_RESULTS"
-        { **@member.to_json, type: @discriminant }.to_json
-      when "ERROR"
-        { **@member.to_json, type: @discriminant }.to_json
-      else
-        { "type": @discriminant, value: @member }.to_json
-      end
-      @member.to_json
+      begin
+        Vellum::TestCaseStringVariableValue.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::TestCaseStringVariableValue.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::TestCaseNumberVariableValue.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::TestCaseNumberVariableValue.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::TestCaseJsonVariableValue.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::TestCaseJsonVariableValue.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::TestCaseChatHistoryVariableValue.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::TestCaseChatHistoryVariableValue.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::TestCaseSearchResultsVariableValue.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::TestCaseSearchResultsVariableValue.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::TestCaseErrorVariableValue.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::TestCaseErrorVariableValue.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::TestCaseFunctionCallVariableValue.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::TestCaseFunctionCallVariableValue.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+      begin
+        Vellum::TestCaseArrayVariableValue.validate_raw(obj: struct)
+        unless struct.nil?
+  return Vellum::TestCaseArrayVariableValue.from_json(json_object: struct)
+else
+  return nil
+end
+      rescue StandardError
+        # noop
+      end
+ return struct
     end
-
-    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+# Leveraged for Union-type generation, validate_raw attempts to parse the given
+#  hash and check each fields type against the current object's property
+#  definitions.
     #
-    # @param obj [Object]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
-      case obj.type
-      when "STRING"
-        TestCaseStringVariableValue.validate_raw(obj: obj)
-      when "NUMBER"
-        TestCaseNumberVariableValue.validate_raw(obj: obj)
-      when "JSON"
-        TestCaseJsonVariableValue.validate_raw(obj: obj)
-      when "CHAT_HISTORY"
-        TestCaseChatHistoryVariableValue.validate_raw(obj: obj)
-      when "SEARCH_RESULTS"
-        TestCaseSearchResultsVariableValue.validate_raw(obj: obj)
-      when "ERROR"
-        TestCaseErrorVariableValue.validate_raw(obj: obj)
-      else
-        raise("Passed value matched no type within the union, validation failed.")
+      begin
+        return Vellum::TestCaseStringVariableValue.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
       end
-    end
-
-    # For Union Types, is_a? functionality is delegated to the wrapped member.
-    #
-    # @param obj [Object]
-    # @return [Boolean]
-    def is_a?(obj)
-      @member.is_a?(obj)
-    end
-
-    # @param member [TestCaseStringVariableValue]
-    # @return [TestCaseVariableValue]
-    def self.string(member:)
-      new(member: member, discriminant: "STRING")
-    end
-
-    # @param member [TestCaseNumberVariableValue]
-    # @return [TestCaseVariableValue]
-    def self.number(member:)
-      new(member: member, discriminant: "NUMBER")
-    end
-
-    # @param member [TestCaseJsonVariableValue]
-    # @return [TestCaseVariableValue]
-    def self.json(member:)
-      new(member: member, discriminant: "JSON")
-    end
-
-    # @param member [TestCaseChatHistoryVariableValue]
-    # @return [TestCaseVariableValue]
-    def self.chat_history(member:)
-      new(member: member, discriminant: "CHAT_HISTORY")
-    end
-
-    # @param member [TestCaseSearchResultsVariableValue]
-    # @return [TestCaseVariableValue]
-    def self.search_results(member:)
-      new(member: member, discriminant: "SEARCH_RESULTS")
-    end
-
-    # @param member [TestCaseErrorVariableValue]
-    # @return [TestCaseVariableValue]
-    def self.error(member:)
-      new(member: member, discriminant: "ERROR")
+      begin
+        return Vellum::TestCaseNumberVariableValue.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::TestCaseJsonVariableValue.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::TestCaseChatHistoryVariableValue.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::TestCaseSearchResultsVariableValue.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::TestCaseErrorVariableValue.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::TestCaseFunctionCallVariableValue.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      begin
+        return Vellum::TestCaseArrayVariableValue.validate_raw(obj: obj)
+      rescue StandardError
+        # noop
+      end
+      raise("Passed value matched no type within the union, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/test_suite_run_deployment_release_tag_exec_config.rb

@@ -1,57 +1,81 @@
 # frozen_string_literal: true
-
 require_relative "test_suite_run_deployment_release_tag_exec_config_data"
+require "ostruct"
 require "json"
 
 module Vellum
-  # Execution configuration for running a Test Suite against a Prompt Deployment
+# Execution configuration for running a Test Suite against a Prompt Deployment
   class TestSuiteRunDeploymentReleaseTagExecConfig
-    attr_reader :data, :test_case_ids, :additional_properties
+  # @return [String] 
+    attr_reader :type
+  # @return [Vellum::TestSuiteRunDeploymentReleaseTagExecConfigData] 
+    attr_reader :data
+  # @return [Array<String>] Optionally specify a subset of test case ids to run. If not provided, all test
+#  cases within the test suite will be run by default.
+    attr_reader :test_case_ids
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
 
-    # @param data [TestSuiteRunDeploymentReleaseTagExecConfigData]
-    # @param test_case_ids [Array<String>] Optionally specify a subset of test case ids to run. If not provided, all test cases within the test suite will be run by default.
+    # @param type [String] 
+    # @param data [Vellum::TestSuiteRunDeploymentReleaseTagExecConfigData] 
+    # @param test_case_ids [Array<String>] Optionally specify a subset of test case ids to run. If not provided, all test
+#  cases within the test suite will be run by default.
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [TestSuiteRunDeploymentReleaseTagExecConfig]
-    def initialize(data:, test_case_ids: nil, additional_properties: nil)
-      # @type [TestSuiteRunDeploymentReleaseTagExecConfigData]
+    # @return [Vellum::TestSuiteRunDeploymentReleaseTagExecConfig]
+    def initialize(type:, data:, test_case_ids: OMIT, additional_properties: nil)
+      @type = type
       @data = data
-      # @type [Array<String>] Optionally specify a subset of test case ids to run. If not provided, all test cases within the test suite will be run by default.
-      @test_case_ids = test_case_ids
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @test_case_ids = test_case_ids if test_case_ids != OMIT
       @additional_properties = additional_properties
+      @_field_set = { "type": type, "data": data, "test_case_ids": test_case_ids }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of TestSuiteRunDeploymentReleaseTagExecConfig
+# Deserialize a JSON object to an instance of
+#  TestSuiteRunDeploymentReleaseTagExecConfig
     #
-    # @param json_object [JSON]
-    # @return [TestSuiteRunDeploymentReleaseTagExecConfig]
+    # @param json_object [String] 
+    # @return [Vellum::TestSuiteRunDeploymentReleaseTagExecConfig]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
       parsed_json = JSON.parse(json_object)
-      if parsed_json["data"].nil?
-        data = nil
-      else
+      type = parsed_json["type"]
+      unless parsed_json["data"].nil?
         data = parsed_json["data"].to_json
-        data = TestSuiteRunDeploymentReleaseTagExecConfigData.from_json(json_object: data)
+        data = Vellum::TestSuiteRunDeploymentReleaseTagExecConfigData.from_json(json_object: data)
+      else
+        data = nil
       end
-      test_case_ids = struct.test_case_ids
-      new(data: data, test_case_ids: test_case_ids, additional_properties: struct)
+      test_case_ids = parsed_json["test_case_ids"]
+      new(
+        type: type,
+        data: data,
+        test_case_ids: test_case_ids,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of TestSuiteRunDeploymentReleaseTagExecConfig to a JSON object
+# Serialize an instance of TestSuiteRunDeploymentReleaseTagExecConfig to a JSON
+#  object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "data": @data, "test_case_ids": @test_case_ids }.to_json
+    # @return [String]
+    def to_json
+      @_field_set&.to_json
     end
-
-    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+# Leveraged for Union-type generation, validate_raw attempts to parse the given
+#  hash and check each fields type against the current object's property
+#  definitions.
     #
-    # @param obj [Object]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
-      TestSuiteRunDeploymentReleaseTagExecConfigData.validate_raw(obj: obj.data)
+      obj.type.is_a?(String) != false || raise("Passed value for field obj.type is not the expected type, validation failed.")
+      Vellum::TestSuiteRunDeploymentReleaseTagExecConfigData.validate_raw(obj: obj.data)
       obj.test_case_ids&.is_a?(Array) != false || raise("Passed value for field obj.test_case_ids is not the expected type, validation failed.")
     end
   end
-end
+end

data/lib/vellum_ai/types/test_suite_run_deployment_release_tag_exec_config_data.rb

@@ -1,50 +1,67 @@
 # frozen_string_literal: true
-
+require "ostruct"
 require "json"
 
 module Vellum
   class TestSuiteRunDeploymentReleaseTagExecConfigData
-    attr_reader :deployment_id, :tag, :additional_properties
+  # @return [String] The ID of the Prompt Deployment to run the Test Suite against.
+    attr_reader :deployment_id
+  # @return [String] A tag identifying which release of the Prompt Deployment to run the Test Suite
+#  against. Useful for testing past versions of the Prompt Deployment
+    attr_reader :tag
+  # @return [OpenStruct] Additional properties unmapped to the current class definition
+    attr_reader :additional_properties
+  # @return [Object] 
+    attr_reader :_field_set
+    protected :_field_set
+
+    OMIT = Object.new
 
     # @param deployment_id [String] The ID of the Prompt Deployment to run the Test Suite against.
-    # @param tag [String] A tag identifying which release of the Prompt Deployment to run the Test Suite against. Useful for testing past versions of the Prompt Deployment
+    # @param tag [String] A tag identifying which release of the Prompt Deployment to run the Test Suite
+#  against. Useful for testing past versions of the Prompt Deployment
     # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-    # @return [TestSuiteRunDeploymentReleaseTagExecConfigData]
-    def initialize(deployment_id:, tag: nil, additional_properties: nil)
-      # @type [String] The ID of the Prompt Deployment to run the Test Suite against.
+    # @return [Vellum::TestSuiteRunDeploymentReleaseTagExecConfigData]
+    def initialize(deployment_id:, tag: OMIT, additional_properties: nil)
       @deployment_id = deployment_id
-      # @type [String] A tag identifying which release of the Prompt Deployment to run the Test Suite against. Useful for testing past versions of the Prompt Deployment
-      @tag = tag
-      # @type [OpenStruct] Additional properties unmapped to the current class definition
+      @tag = tag if tag != OMIT
       @additional_properties = additional_properties
+      @_field_set = { "deployment_id": deployment_id, "tag": tag }.reject do | _k, v |
+  v == OMIT
+end
     end
-
-    # Deserialize a JSON object to an instance of TestSuiteRunDeploymentReleaseTagExecConfigData
+# Deserialize a JSON object to an instance of
+#  TestSuiteRunDeploymentReleaseTagExecConfigData
     #
-    # @param json_object [JSON]
-    # @return [TestSuiteRunDeploymentReleaseTagExecConfigData]
+    # @param json_object [String] 
+    # @return [Vellum::TestSuiteRunDeploymentReleaseTagExecConfigData]
     def self.from_json(json_object:)
       struct = JSON.parse(json_object, object_class: OpenStruct)
-      JSON.parse(json_object)
-      deployment_id = struct.deployment_id
-      tag = struct.tag
-      new(deployment_id: deployment_id, tag: tag, additional_properties: struct)
+      parsed_json = JSON.parse(json_object)
+      deployment_id = parsed_json["deployment_id"]
+      tag = parsed_json["tag"]
+      new(
+        deployment_id: deployment_id,
+        tag: tag,
+        additional_properties: struct
+      )
     end
-
-    # Serialize an instance of TestSuiteRunDeploymentReleaseTagExecConfigData to a JSON object
+# Serialize an instance of TestSuiteRunDeploymentReleaseTagExecConfigData to a
+#  JSON object
     #
-    # @return [JSON]
-    def to_json(*_args)
-      { "deployment_id": @deployment_id, "tag": @tag }.to_json
+    # @return [String]
+    def to_json
+      @_field_set&.to_json
     end
-
-    # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
+# Leveraged for Union-type generation, validate_raw attempts to parse the given
+#  hash and check each fields type against the current object's property
+#  definitions.
     #
-    # @param obj [Object]
+    # @param obj [Object] 
     # @return [Void]
     def self.validate_raw(obj:)
       obj.deployment_id.is_a?(String) != false || raise("Passed value for field obj.deployment_id is not the expected type, validation failed.")
       obj.tag&.is_a?(String) != false || raise("Passed value for field obj.tag is not the expected type, validation failed.")
     end
   end
-end
+end