active_genie 0.25.1 → 0.26.0

data/lib/active_genie/configuration.rb

@@ -38,23 +38,19 @@ module ActiveGenie
       @llm ||= Config::LlmConfig.new
     end
 
+    SUB_CONFIGS = %w[log providers llm ranking scoring data_extractor battle].freeze
+
     def merge(config_params = {})
       return config_params if config_params.is_a?(Configuration)
 
       new_configuration = dup
 
-      %w[log providers llm ranking scoring data_extractor battle].each do |key|
+      SUB_CONFIGS.each do |key|
         config = new_configuration.send(key)
 
         next unless config.respond_to?(:merge)
 
-        new_config = if config_params.key?(key.to_s)
-                       config.merge(config_params[key.to_s])
-                     elsif config_params.key?(key.to_sym)
-                       config.merge(config_params[key.to_sym])
-                     else
-                       config.merge(config_params)
-                     end
+        new_config = sub_config_merge(config, key, config_params)
 
         new_configuration.send("#{key}=", new_config)
       end
@@ -62,6 +58,16 @@ module ActiveGenie
       new_configuration
     end
 
+    def sub_config_merge(config, key, config_params)
+      if config_params.key?(key.to_s)
+        config.merge(config_params[key.to_s])
+      elsif config_params.key?(key.to_sym)
+        config.merge(config_params[key.to_sym])
+      else
+        config.merge(config_params)
+      end
+    end
+
     attr_writer :log, :providers, :ranking, :scoring, :data_extractor, :battle, :llm
   end
 end

data/lib/active_genie/data_extractor/from_informal.json

@@ -0,0 +1,11 @@
+
+{
+  "message_litote": {
+    "type": "boolean",
+    "description": "Return true if the message is a litote. A litote is a figure of speech that uses understatement to emphasize a point by stating a negative to further affirm a positive, often incorporating double negatives for effect."
+  },
+  "litote_rephrased": {
+    "type": "string",
+    "description": "The true meaning of the litote. Rephrase the message to a positive and active statement."
+  }
+}

data/lib/active_genie/data_extractor/from_informal.rb

@@ -37,8 +37,8 @@ module ActiveGenie
       def call
         response = Generalist.call(@text, data_to_extract_with_litote, config: @config)
 
-        if response['message_litote']
-          response = Generalist.call(response['litote_rephrased'], @data_to_extract, config: @config)
+        if response[:message_litote]
+          response = Generalist.call(response[:litote_rephrased], @data_to_extract, config: @config)
         end
 
         response
@@ -47,17 +47,9 @@ module ActiveGenie
       private
 
       def data_to_extract_with_litote
-        {
-          **@data_to_extract,
-          message_litote: {
-            type: 'boolean',
-            description: 'Return true if the message is a litote. A litote is a figure of speech that uses understatement to emphasize a point by stating a negative to further affirm a positive, often incorporating double negatives for effect.'
-          },
-          litote_rephrased: {
-            type: 'string',
-            description: 'The true meaning of the litote. Rephrase the message to a positive and active statement.'
-          }
-        }
+        parameters = JSON.parse(File.read(File.join(__dir__, 'from_informal.json')), symbolize_names: true)
+
+        @data_to_extract.merge(parameters)
       end
     end
   end

data/lib/active_genie/data_extractor/generalist.json

@@ -0,0 +1,9 @@
+{
+  "name": "data_extractor",
+  "description": "Extract structured and typed data from text",
+  "parameters": {
+    "type": "object",
+    "properties": {},
+    "required": {}
+  }
+}

data/lib/active_genie/data_extractor/generalist.rb

@@ -42,15 +42,9 @@ module ActiveGenie
 
         properties = data_to_extract_with_explanation
 
-        function = {
-          name: 'data_extractor',
-          description: 'Extract structured and typed data from text',
-          parameters: {
-            type: 'object',
-            properties:,
-            required: properties.keys
-          }
-        }
+        function = JSON.parse(File.read(File.join(__dir__, 'generalist.json')), symbolize_names: true)
+        function[:parameters][:properties] = properties
+        function[:parameters][:required] = properties.keys
 
         response = function_calling(messages, function)
 
@@ -68,11 +62,18 @@ module ActiveGenie
           with_explanation[key] = value
           with_explanation["#{key}_explanation"] = {
             type: 'string',
-            description: "The chain of thought that led to the conclusion about: #{key}. Can be blank if the user didn't provide any context"
+            description: "
+            The chain of thought that led to the conclusion about: #{key}.
+            Can be blank if the user didn't provide any context
+            "
           }
           with_explanation["#{key}_accuracy"] = {
             type: 'integer',
-            description: 'The accuracy of the extracted data, what is the percentage of confidence? When 100 it means the data is explicitly stated in the text. When 0 it means is no way to discover the data from the text'
+            description: '
+            The accuracy of the extracted data, what is the percentage of confidence?
+            When 100 it means the data is explicitly stated in the text.
+            When 0 it means is no way to discover the data from the text
+            '
           }
         end
 

data/lib/active_genie/errors/invalid_log_output_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveGenie
+  class InvalidLogOutputError < StandardError
+    TEXT = <<~TEXT
+      Invalid log output option. Must be a callable object. Given: %<output>s
+      Example:
+        ```ruby
+        ActiveGenie.configure do |config|
+          config.log.output = ->(log) { puts log }
+        end
+        ```
+    TEXT
+
+    def initialize(output)
+      super(format(TEXT, output:))
+    end
+  end
+end

data/lib/active_genie/logger.rb

@@ -16,27 +16,35 @@ module ActiveGenie
       }
 
       persist!(log)
-      $stdout.puts log
-      ActiveGenie.configuration.log.call_observers(log)
+      config.output_call(log)
 
       log
     end
 
-    def with_context(context)
+    def with_context(context, observer: nil)
       @context ||= {}
       begin
         @context = @context.merge(context)
+        config.add_observer(observers: [observer])
         yield if block_given?
       ensure
         @context.delete_if { |key, _| context.key?(key) }
+        config.remove_observer([observer])
       end
     end
 
     attr_accessor :context
 
     def persist!(log)
-      FileUtils.mkdir_p('log')
-      File.write('log/active_genie.log', "#{JSON.generate(log)}\n", mode: 'a')
+      file_path = log.key?(:fine_tune) && log[:fine_tune] ? config.fine_tune_file_path : config.file_path
+      folder_path = File.dirname(file_path)
+
+      FileUtils.mkdir_p(folder_path)
+      File.write(file_path, "#{JSON.generate(log)}\n", mode: 'a')
+    end
+
+    def config
+      ActiveGenie.configuration.log
     end
   end
 end

data/lib/active_genie/{concerns → ranking/concerns}/loggable.rb

@@ -20,11 +20,8 @@ module ActiveGenie
           end
         end
 
-        def logger(data)
-          log = ActiveGenie::Logger.call(data)
-          @config&.log&.call_observers(log)
-
-          log
+        def logger(...)
+          ActiveGenie::Logger.call(...)
         end
       end
     end

data/lib/active_genie/ranking/elo_round.rb

@@ -16,38 +16,29 @@ module ActiveGenie
         @criteria = criteria
         @config = config
         @tmp_defenders = []
-        @start_time = Time.now
         @total_tokens = 0
         @previous_elo = {}
         @previous_highest_elo = @defender_tier.max_by(&:elo).elo
       end
 
       def call
+        @previous_elo = @players.to_h { |player| [player.id, player.elo] }
+
         ActiveGenie::Logger.with_context(log_context) do
-          save_previous_elo
-          matches.each do |player_1, player_2|
+          matches.each do |player_a, player_b|
             # TODO: battle can take a while, can be parallelized
-            winner, loser = battle(player_1, player_2)
-            next if winner.nil? || loser.nil?
-
-            winner.elo = calculate_new_elo(winner.elo, loser.elo, 1)
-            loser.elo = calculate_new_elo(loser.elo, winner.elo, 0)
+            winner, loser = battle(player_a, player_b)
+            update_players_elo(winner, loser)
           end
         end
 
-        ActiveGenie::Logger.call({ code: :elo_round_report, **report })
-
-        report
+        build_report
       end
 
-      private
-
       BATTLE_PER_PLAYER = 3
       K = 32
 
-      def save_previous_elo
-        @previous_elo = @players.map { |player| [player.id, player.elo] }.to_h
-      end
+      private
 
       def matches
         @relegation_tier.each_with_object([]) do |attack_player, matches|
@@ -63,18 +54,18 @@ module ActiveGenie
         @tmp_defenders.pop
       end
 
-      def battle(player_1, player_2)
-        ActiveGenie::Logger.with_context({ player_1_id: player_1.id, player_2_id: player_2.id }) do
+      def battle(player_a, player_b)
+        ActiveGenie::Logger.with_context({ player_a_id: player_a.id, player_b_id: player_b.id }) do
           result = ActiveGenie::Battle.call(
-            player_1.content,
-            player_2.content,
+            player_a.content,
+            player_b.content,
             @criteria,
             config: @config
           )
 
           winner, loser = case result['winner']
-                          when 'player_1' then [player_1, player_2]
-                          when 'player_2' then [player_2, player_1]
+                          when 'player_a' then [player_a, player_b]
+                          when 'player_b' then [player_b, player_a]
                           when 'draw' then [nil, nil]
                           end
 
@@ -82,9 +73,16 @@ module ActiveGenie
         end
       end
 
+      def update_players_elo(winner, loser)
+        return if winner.nil? || loser.nil?
+
+        winner.elo = calculate_new_elo(winner.elo, loser.elo, 1)
+        loser.elo = calculate_new_elo(loser.elo, winner.elo, 0)
+      end
+
       # INFO: Read more about the Elo rating system on https://en.wikipedia.org/wiki/Elo_rating_system
       def calculate_new_elo(player_rating, opponent_rating, score)
-        expected_score = 1.0 / (1.0 + 10.0**((opponent_rating - player_rating) / 400.0))
+        expected_score = 1.0 / (1.0 + (10.0**((opponent_rating - player_rating) / 400.0)))
 
         player_rating + (K * (score - expected_score)).round
       end
@@ -101,18 +99,21 @@ module ActiveGenie
         Digest::MD5.hexdigest(ranking_unique_key)
       end
 
-      def report
-        {
+      def build_report
+        report = {
           elo_round_id:,
           players_in_round: players_in_round.map(&:id),
           battles_count: matches.size,
-          duration_seconds: Time.now - @start_time,
           total_tokens: @total_tokens,
           previous_highest_elo: @previous_highest_elo,
           highest_elo:,
           highest_elo_diff: highest_elo - @previous_highest_elo,
           players_elo_diff:
         }
+
+        ActiveGenie::Logger.call({ code: :elo_round_report, **report })
+
+        report
       end
 
       def players_in_round
@@ -124,9 +125,10 @@ module ActiveGenie
       end
 
       def players_elo_diff
-        players_in_round.map do |player|
+        elo_diffs = players_in_round.map do |player|
           [player.id, player.elo - @previous_elo[player.id]]
-        end.sort_by { |_, diff| -diff }.to_h
+        end
+        elo_diffs.sort_by { |_, diff| -(diff || 0) }.to_h
       end
 
       def log_observer(log)

data/lib/active_genie/ranking/free_for_all.rb

@@ -18,23 +18,15 @@ module ActiveGenie
       end
 
       def call
-        ActiveGenie::Logger.with_context(log_context, observer: method(:log_observer)) do
-          matches.each do |player_1, player_2|
-            winner, loser = battle(player_1, player_2)
-
-            if winner.nil? || loser.nil?
-              player_1.draw!
-              player_2.draw!
-            else
-              winner.win!
-              loser.lose!
-            end
+        ActiveGenie::Logger.with_context(log_context, observer: ->(log) { log_observer(log) }) do
+          matches.each do |player_a, player_b|
+            winner, loser = battle(player_a, player_b)
+
+            update_players_score(winner, loser)
           end
         end
 
-        ActiveGenie::Logger.call({ code: :free_for_all_report, **report })
-
-        report
+        build_report
       end
 
       private
@@ -45,23 +37,23 @@ module ActiveGenie
         @players.eligible.combination(2).to_a
       end
 
-      def battle(player_1, player_2)
+      def battle(player_a, player_b)
         result = ActiveGenie::Battle.call(
-          player_1.content,
-          player_2.content,
+          player_a.content,
+          player_b.content,
           @criteria,
           config: @config
         )
 
         winner, loser = case result['winner']
-                        when 'player_1' then [player_1, player_2, result['reasoning']]
-                        when 'player_2' then [player_2, player_1, result['reasoning']]
+                        when 'player_a' then [player_a, player_b, result['reasoning']]
+                        when 'player_b' then [player_b, player_a, result['reasoning']]
                         when 'draw' then [nil, nil, result['reasoning']]
                         end
 
         ActiveGenie::Logger.call({
                                    code: :free_for_all_battle,
-                                   player_ids: [player_1.id, player_2.id],
+                                   player_ids: [player_a.id, player_b.id],
                                    winner_id: winner&.id,
                                    loser_id: loser&.id,
                                    reasoning: result['reasoning']
@@ -70,6 +62,18 @@ module ActiveGenie
         [winner, loser]
       end
 
+      def update_players_score(winner, loser)
+        return if winner.nil? || loser.nil?
+
+        if winner.nil? || loser.nil?
+          player_a.draw!
+          player_b.draw!
+        else
+          winner.win!
+          loser.lose!
+        end
+      end
+
       def log_context
         { free_for_all_id: }
       end
@@ -80,13 +84,17 @@ module ActiveGenie
         Digest::MD5.hexdigest(ranking_unique_key)
       end
 
-      def report
-        {
+      def build_report
+        report = {
           free_for_all_id:,
           battles_count: matches.size,
           duration_seconds: Time.now - @start_time,
           total_tokens: @total_tokens
         }
+
+        ActiveGenie::Logger.call({ code: :free_for_all_report, **report })
+
+        report
       end
 
       def log_observer(log)

data/lib/active_genie/ranking/player.rb

@@ -6,19 +6,51 @@ module ActiveGenie
   module Ranking
     class Player
       def initialize(params)
-        params = { content: params } if params.is_a?(String)
+        @params = params.is_a?(String) ? { content: params } : params.dup
+        @params[:content] ||= @params
+      end
+
+      def content
+        @content ||= @params[:content]
+      end
+
+      def name
+        @name ||= @params[:name] || content[0..10]
+      end
+
+      def id
+        @id ||= @params[:id] || Digest::MD5.hexdigest(content.to_s)
+      end
+
+      def score
+        @score ||= @params[:score]
+      end
+
+      def elo
+        @elo = if @params[:elo]
+                 @params[:elo]
+               elsif @score
+                 generate_elo_by_score
+               else
+                 BASE_ELO
+               end
+      end
+
+      def ffa_win_count
+        @ffa_win_count ||= @params[:ffa_win_count] || 0
+      end
+
+      def ffa_lose_count
+        @ffa_lose_count ||= @params[:ffa_lose_count] || 0
+      end
 
-        @content = params[:content] || params
-        @name = params[:name] || params[:content][0..10]
-        @id = params[:id] || Digest::MD5.hexdigest(@content)
-        @score = params[:score] || nil
-        @elo = params[:elo] || nil
-        @ffa_win_count = params[:ffa_win_count] || 0
-        @ffa_lose_count = params[:ffa_lose_count] || 0
-        @ffa_draw_count = params[:ffa_draw_count] || 0
-        @eliminated = params[:eliminated] || nil
+      def ffa_draw_count
+        @ffa_draw_count ||= @params[:ffa_draw_count] || 0
+      end
+
+      def eliminated
+        @eliminated ||= @params[:eliminated]
       end
-      attr_accessor :rank
 
       def score=(value)
         ActiveGenie::Logger.call({ code: :new_score, player_id: id, score: value }) if value != @score
@@ -28,7 +60,7 @@ module ActiveGenie
 
       def elo=(value)
         ActiveGenie::Logger.call({ code: :new_elo, player_id: id, elo: value }) if value != @elo
-        @elo = value
+        @elo = value || BASE_ELO
       end
 
       def eliminated=(value)
@@ -51,10 +83,8 @@ module ActiveGenie
         ActiveGenie::Logger.call({ code: :new_ffa_score, player_id: id, result: 'lose', ffa_score: })
       end
 
-      attr_reader :id, :content, :score, :elo, :ffa_win_count, :ffa_lose_count, :ffa_draw_count, :eliminated, :name
-
       def ffa_score
-        @ffa_win_count * 3 + @ffa_draw_count
+        (@ffa_win_count * 3) + @ffa_draw_count
       end
 
       def sort_value
@@ -67,13 +97,15 @@ module ActiveGenie
 
       def to_h
         {
-          id:, name:, content:, score:, elo:,
+          id:, name:, content:,
+
+          score:, elo:,
           ffa_win_count:, ffa_lose_count:, ffa_draw_count:,
           eliminated:, ffa_score:, sort_value:
         }
       end
 
-      def method_missing(method_name, *args, &block)
+      def method_missing(method_name, *args, &)
         if method_name == :[] && args.size == 1
           attr_name = args.first.to_sym
 
@@ -90,11 +122,13 @@ module ActiveGenie
         method_name == :[] || super
       end
 
+      BASE_ELO = 1000
+
+      private
+
       def generate_elo_by_score
         BASE_ELO + ((@score || 0) - 50)
       end
-
-      BASE_ELO = 1000
     end
   end
 end

data/lib/active_genie/ranking/players_collection.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative './player'
+require_relative 'player'
 
 module ActiveGenie
   module Ranking
@@ -11,18 +11,26 @@ module ActiveGenie
       attr_reader :players
 
       def coefficient_of_variation
-        score_list = eligible.map(&:score).compact
-        return nil if score_list.empty?
+        mean = score_mean
 
-        mean = score_list.sum.to_f / score_list.size
         return nil if mean.zero?
 
-        variance = score_list.map { |num| (num - mean)**2 }.sum / score_list.size
+        variance = all_scores.map { |num| (num - mean)**2 }.sum / all_scores.size
         standard_deviation = Math.sqrt(variance)
 
         (standard_deviation / mean) * 100
       end
 
+      def all_scores
+        eligible.map(&:score).compact
+      end
+
+      def score_mean
+        return 0 if all_scores.empty?
+
+        all_scores.sum.to_f / all_scores.size
+      end
+
       def calc_relegation_tier
         eligible[(tier_size * -1)..]
       end
@@ -44,19 +52,13 @@ module ActiveGenie
       end
 
       def sorted
-        sorted_players = @players.sort_by { |p| -p.sort_value }
-        sorted_players.each_with_index { |p, i| p.rank = i + 1 }
-        sorted_players
+        @players.sort_by { |p| -p.sort_value }
       end
 
       def to_json(*_args)
         to_h.to_json
       end
 
-      def to_h
-        sorted.map(&:to_h)
-      end
-
       def method_missing(...)
         @players.send(...)
       end
@@ -80,7 +82,9 @@ module ActiveGenie
       #   - 14 eligible, tier_size: 4
       #  4 rounds to reach top 10 with 50 players
       def tier_size
-        [[(eligible_size / 3).ceil, 10].max, eligible_size - 10].min
+        size = (eligible_size / 3).ceil
+
+        size.clamp(10, eligible_size - 10)
       end
     end
   end