dspy 0.34.2 → 0.34.4

data/lib/dspy/prompt.rb

@@ -5,6 +5,7 @@ require 'sorbet-runtime'
 require 'sorbet/toon'
 
 require_relative 'few_shot_example'
+require_relative 'utils/serialization'
 require_relative 'schema/sorbet_toon_adapter'
 
 module DSPy
@@ -26,24 +27,14 @@ module DSPy
     sig { returns(T.nilable(String)) }
     attr_reader :signature_class_name
 
-    # Returns the effective schema format
-    # Precedence: instance variable (if not :json default) > config.lm > :json
     sig { returns(Symbol) }
     def schema_format
-      # If @schema_format was explicitly set to something other than :json, respect it
-      return @schema_format if @schema_format && @schema_format != :json
-
-      # Otherwise, read from config if available
-      DSPy.config.lm&.schema_format || @schema_format || :json
+      @schema_format || :json
     end
 
     sig { returns(Symbol) }
     def data_format
-      return @data_format if @data_format && @data_format != :json
-
-      lm = DSPy.config.lm
-      lm_format = lm&.respond_to?(:data_format) ? lm.data_format : nil
-      lm_format || @data_format || :json
+      @data_format || :json
     end
 
     sig { returns(T.nilable(T.class_of(Signature))) }
@@ -56,20 +47,20 @@ module DSPy
         output_schema: T::Hash[Symbol, T.untyped],
         few_shot_examples: T::Array[FewShotExample],
         signature_class_name: T.nilable(String),
-        schema_format: Symbol,
+        schema_format: T.nilable(Symbol),
         signature_class: T.nilable(T.class_of(Signature)),
-        data_format: Symbol
+        data_format: T.nilable(Symbol)
       ).void
     end
-    def initialize(instruction:, input_schema:, output_schema:, few_shot_examples: [], signature_class_name: nil, schema_format: :json, signature_class: nil, data_format: :json)
+    def initialize(instruction:, input_schema:, output_schema:, few_shot_examples: [], signature_class_name: nil, schema_format: nil, signature_class: nil, data_format: nil)
       @instruction = instruction
       @few_shot_examples = few_shot_examples.freeze
       @input_schema = input_schema.freeze
       @output_schema = output_schema.freeze
       @signature_class_name = signature_class_name
-      @schema_format = schema_format
+      @schema_format = resolve_schema_format(schema_format)
       @signature_class = signature_class
-      @data_format = data_format
+      @data_format = resolve_data_format(data_format)
     end
 
     # Immutable update methods for optimization
@@ -107,6 +98,34 @@ module DSPy
       with_examples(combined_examples)
     end
 
+    sig { params(new_schema_format: Symbol).returns(Prompt) }
+    def with_schema_format(new_schema_format)
+      self.class.new(
+        instruction: @instruction,
+        input_schema: @input_schema,
+        output_schema: @output_schema,
+        few_shot_examples: @few_shot_examples,
+        signature_class_name: @signature_class_name,
+        schema_format: new_schema_format,
+        signature_class: @signature_class,
+        data_format: @data_format
+      )
+    end
+
+    sig { params(new_data_format: Symbol).returns(Prompt) }
+    def with_data_format(new_data_format)
+      self.class.new(
+        instruction: @instruction,
+        input_schema: @input_schema,
+        output_schema: @output_schema,
+        few_shot_examples: @few_shot_examples,
+        signature_class_name: @signature_class_name,
+        schema_format: @schema_format,
+        signature_class: @signature_class,
+        data_format: new_data_format
+      )
+    end
+
     # Core prompt rendering methods
     sig { returns(String) }
     def render_system_prompt
@@ -223,7 +242,7 @@ module DSPy
       else
         sections << "## Input Values"
         sections << "```json"
-        sections << JSON.pretty_generate(serialize_for_json(input_values))
+        sections << JSON.pretty_generate(DSPy::Utils::Serialization.deep_serialize(input_values))
         sections << "```"
         sections << ""
         sections << "Respond with the corresponding output schema fields wrapped in a ```json ``` block,"
@@ -233,15 +252,6 @@ module DSPy
       sections.join("\n")
     end
 
-    # Generate messages for LM adapter
-    sig { params(input_values: T::Hash[Symbol, T.untyped]).returns(T::Array[T::Hash[Symbol, String]]) }
-    def to_messages(input_values)
-      [
-        { role: 'system', content: render_system_prompt },
-        { role: 'user', content: render_user_prompt(input_values) }
-      ]
-    end
-
     # Serialization for persistence and optimization
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h
@@ -280,10 +290,6 @@ module DSPy
       ).returns(Prompt)
     end
     def self.from_signature(signature_class, schema_format: nil, data_format: nil)
-      lm = DSPy.config.lm
-      schema_format ||= lm&.schema_format || :json
-      data_format ||= (lm&.respond_to?(:data_format) ? lm.data_format : nil) || :json
-
       new(
         instruction: signature_class.description || "Complete this task.",
         input_schema: signature_class.input_json_schema,
@@ -371,51 +377,6 @@ module DSPy
       "# Please install: gem install sorbet-baml"
     end
 
-    # Recursively serialize complex objects for JSON representation
-    sig { params(obj: T.untyped).returns(T.untyped) }
-    def serialize_for_json(obj)
-      case obj
-      when T::Struct
-        # Convert T::Struct to hash using to_h method if available
-        if obj.respond_to?(:to_h)
-          serialize_for_json(obj.to_h)
-        else
-          # Fallback: serialize using struct properties
-          serialize_struct_to_hash(obj)
-        end
-      when Hash
-        # Recursively serialize hash values
-        obj.transform_values { |v| serialize_for_json(v) }
-      when Array
-        # Recursively serialize array elements
-        obj.map { |item| serialize_for_json(item) }
-      when T::Enum
-        # Serialize enums to their string representation
-        obj.serialize
-      else
-        # For basic types (String, Integer, Float, Boolean, etc.), return as-is
-        obj
-      end
-    end
-
-    # Fallback method to serialize T::Struct to hash when to_h is not available
-    sig { params(struct_obj: T::Struct).returns(T::Hash[Symbol, T.untyped]) }
-    def serialize_struct_to_hash(struct_obj)
-      result = {}
-      
-      # Use struct's props method to get all properties
-      if struct_obj.class.respond_to?(:props)
-        struct_obj.class.props.each do |prop_name, _prop_info|
-          if struct_obj.respond_to?(prop_name)
-            value = struct_obj.public_send(prop_name)
-            result[prop_name] = serialize_for_json(value)
-          end
-        end
-      end
-      
-      result
-    end
-
     def toon_data_format_enabled?
       data_format == :toon && @signature_class
     end
@@ -506,5 +467,20 @@ module DSPy
       base = 'value' if base.empty?
       "example_#{base}"
     end
+
+    def resolve_schema_format(schema_format)
+      return schema_format unless schema_format.nil?
+
+      lm = DSPy.respond_to?(:current_lm) ? DSPy.current_lm : DSPy.config.lm
+      lm&.schema_format || :json
+    end
+
+    def resolve_data_format(data_format)
+      return data_format unless data_format.nil?
+
+      lm = DSPy.respond_to?(:current_lm) ? DSPy.current_lm : DSPy.config.lm
+      lm_format = lm&.respond_to?(:data_format) ? lm.data_format : nil
+      lm_format || :json
+    end
   end
 end

data/lib/dspy/propose/dataset_summary_generator.rb

@@ -157,7 +157,7 @@ module DSPy
 
               observations += output.observations
             end
-          rescue => e
+          rescue StandardError => e
             if verbose
               puts "Error during observation refinement: #{e.message}. Using observations from past round for summary."
             end

data/lib/dspy/propose/grounded_proposer.rb

@@ -160,7 +160,7 @@ module DSPy
               DSPy.current_lm,
               verbose: @config.verbose
             )
-          rescue => e
+          rescue StandardError => e
             DSPy.logger.warn("Failed to generate dataset summary: #{e.message}")
             @dataset_summary = nil
           end
@@ -189,7 +189,7 @@ module DSPy
         # This is a simplified version - could be enhanced with method_source gem
         code = "Program: #{klass.name}\nSource: #{file}:#{line}"
         code
-      rescue => e
+      rescue StandardError => e
         DSPy.logger.warn("Could not extract program source: #{e.message}")
         nil
       end
@@ -506,7 +506,7 @@ module DSPy
             instruction = result.instruction.strip
 
             candidates << instruction if instruction.length > 0
-          rescue => error
+          rescue StandardError => error
             DSPy.logger.warn("Failed to generate instruction candidate #{i + 1}: #{error.message}")
           end
         end