dspy 0.22.0 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7897711c81ee7a4b72dd86a8fbeee9faf4cdf3e398b9878435e0da5750b0fc1
-  data.tar.gz: '079cfdea700a852a94d08415bbdbbe2ff4c4e7d61e4dfae5e739fb88dec29c79'
+  metadata.gz: a74fa7e459b97d25d515492a9c8ef786981ca5212dcfe970b9f8311e5a2b7be4
+  data.tar.gz: 7cf45b5f12849e55b1a180f3b39e9054357a23477bbc8dacad4b85be35bc234a
 SHA512:
-  metadata.gz: b81f7fefb5727bbdbc5f94b6618ba7de9cbea26de78324d2ed5f29f6aa1722f5a4e0191d99e3a1393962f5fe224198e25fe3b73fe34b59e99bd486f08bab1189
-  data.tar.gz: 89515f64f64e681ae9cee83ffdad853b7e29409381351528324047b9a60627ed4721b79dd1943cee1ab3300996521aeb595e7a3ce57c90ad09cda47489acca77
+  metadata.gz: d7610ab7261fb039264acf5c2de69b70c7cc33932335faf70b97ba65e459a0d2048a428e8b1f49b6ccd73de3455ad4adc9351bb2e5dc58acfac47323086b7c3d
+  data.tar.gz: de8c212916e2135c27e881be529f12121439b12bbc8effca7dd98d6aa912f6057ae304e9d1aa5eee6c2dd2fafee904b3665cde4569f61d91360cacb6acbc2e43

data/lib/dspy/events/subscriber_mixin.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module DSPy
+  module Events
+    # Mixin for adding class-level event subscriptions
+    # Provides a clean way to subscribe to events at the class level
+    # instead of requiring instance-based subscriptions
+    #
+    # Usage:
+    #   class MyTracker
+    #     include DSPy::Events::SubscriberMixin
+    #     
+    #     add_subscription('llm.*') do |name, attrs|
+    #       # Handle LLM events globally for this class
+    #     end
+    #   end
+    module SubscriberMixin
+      extend T::Sig
+
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_eval do
+          @event_subscriptions = []
+          @subscription_mutex = Mutex.new
+          
+          # Initialize subscriptions when the class is first loaded
+          @subscriptions_initialized = false
+        end
+      end
+
+      module ClassMethods
+        extend T::Sig
+
+        # Add a class-level event subscription
+        sig { params(pattern: String, block: T.proc.params(arg0: String, arg1: T::Hash[T.any(String, Symbol), T.untyped]).void).returns(String) }
+        def add_subscription(pattern, &block)
+          subscription_mutex.synchronize do
+            subscription_id = DSPy.events.subscribe(pattern, &block)
+            event_subscriptions << subscription_id
+            subscription_id
+          end
+        end
+
+        # Remove all subscriptions for this class
+        sig { void }
+        def unsubscribe_all
+          subscription_mutex.synchronize do
+            event_subscriptions.each { |id| DSPy.events.unsubscribe(id) }
+            event_subscriptions.clear
+          end
+        end
+
+        # Get list of active subscription IDs
+        sig { returns(T::Array[String]) }
+        def subscriptions
+          subscription_mutex.synchronize do
+            event_subscriptions.dup
+          end
+        end
+
+        private
+
+        # Thread-safe access to subscriptions array
+        sig { returns(T::Array[String]) }
+        def event_subscriptions
+          @event_subscriptions ||= []
+        end
+
+        # Thread-safe access to mutex
+        sig { returns(Mutex) }
+        def subscription_mutex
+          @subscription_mutex ||= Mutex.new
+        end
+      end
+    end
+  end
+end

data/lib/dspy/memory/local_embedding_engine.rb

@@ -53,22 +53,9 @@ module DSPy
       def embed_batch(texts)
         ensure_ready!
         
-        # Preprocess all texts
-        cleaned_texts = texts.map { |text| preprocess_text(text) }
-        
-        # Generate embeddings in batch
-        results = @model.call(cleaned_texts)
-        
-        # Extract and normalize embeddings
-        results.map do |result|
-          # Handle both single embeddings and batch results
-          embedding = case result
-                     when Array
-                       result.flatten  # Flatten in case of nested arrays
-                     else
-                       result.to_a.flatten
-                     end
-          normalize_vector(embedding)
+        # Generate embeddings one by one (informers doesn't support true batch processing)
+        texts.map do |text|
+          embed(text)
         end
       end
 

data/lib/dspy/mixins/type_coercion.rb

@@ -140,8 +140,28 @@ module DSPy
         # Convert string keys to symbols
         symbolized_hash = value.transform_keys(&:to_sym)
         
+        # Get struct properties to understand what fields are expected
+        struct_props = struct_class.props
+        
+        # Remove the _type field that DSPy adds for discriminating structs,
+        # but only if it's NOT a legitimate field in the struct definition
+        if !struct_props.key?(:_type) && symbolized_hash.key?(:_type)
+          symbolized_hash = symbolized_hash.except(:_type)
+        end
+        
+        # Recursively coerce nested struct fields
+        coerced_hash = symbolized_hash.map do |key, val|
+          prop_info = struct_props[key]
+          if prop_info && prop_info[:type]
+            coerced_value = coerce_value_to_type(val, prop_info[:type])
+            [key, coerced_value]
+          else
+            [key, val]
+          end
+        end.to_h
+        
         # Create the struct instance
-        struct_class.new(**symbolized_hash)
+        struct_class.new(**coerced_hash)
       rescue ArgumentError => e
         # If struct creation fails, return the original value
         DSPy.logger.debug("Failed to coerce to struct #{struct_class}: #{e.message}")

data/lib/dspy/prediction.rb

@@ -54,7 +54,7 @@ module DSPy
 
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h
-      @_struct.to_h
+      @_struct.serialize
     end
 
     private