active_genie 0.0.24 → 0.0.25

data/lib/active_genie/ranking/elo_round.rb

@@ -1,134 +1,137 @@
-require_relative '../battle/basic'
+# frozen_string_literal: true
 
-module ActiveGenie::Ranking
-  class EloRound
-    def self.call(...)
-      new(...).call
-    end
+require_relative '../battle/generalist'
 
-    def initialize(players, criteria, config: {})
-      @players = players
-      @relegation_tier = players.calc_relegation_tier
-      @defender_tier = players.calc_defender_tier
-      @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
+module ActiveGenie
+  module Ranking
+    class EloRound
+      def self.call(...)
+        new(...).call
+      end
 
-    def call
-      ActiveGenie::Logger.with_context(log_context) do
-        save_previous_elo
-        matches.each do |player_1, player_2|
-          # TODO: battle can take a while, can be parallelized
-          winner, loser = battle(player_1, player_2)
-          next if winner.nil? || loser.nil?
+      def initialize(players, criteria, config: {})
+        @players = players
+        @relegation_tier = players.calc_relegation_tier
+        @defender_tier = players.calc_defender_tier
+        @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
 
-          winner.elo = calculate_new_elo(winner.elo, loser.elo, 1)
-          loser.elo = calculate_new_elo(loser.elo, winner.elo, 0)
+      def call
+        ActiveGenie::Logger.with_context(log_context) do
+          save_previous_elo
+          matches.each do |player_1, player_2|
+            # 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)
+          end
         end
-      end
 
-      ActiveGenie::Logger.info({ code: :elo_round_report, **report })
+        ActiveGenie::Logger.call({ code: :elo_round_report, **report })
 
-      report
-    end
+        report
+      end
 
-    private
+      private
 
-    BATTLE_PER_PLAYER = 3
-    K = 32
+      BATTLE_PER_PLAYER = 3
+      K = 32
 
-    def save_previous_elo
-      @previous_elo = @players.map { |player| [player.id, player.elo] }.to_h
-    end
+      def save_previous_elo
+        @previous_elo = @players.map { |player| [player.id, player.elo] }.to_h
+      end
 
-    def matches
-      @relegation_tier.reduce([]) do |matches, attack_player|
-        BATTLE_PER_PLAYER.times do
-          matches << [attack_player, next_defense_player].shuffle
+      def matches
+        @relegation_tier.each_with_object([]) do |attack_player, matches|
+          BATTLE_PER_PLAYER.times do
+            matches << [attack_player, next_defense_player].shuffle
+          end
         end
-        matches
       end
-    end
 
-    def next_defense_player
-      @tmp_defenders = @defender_tier.shuffle if @tmp_defenders.size.zero?
+      def next_defense_player
+        @tmp_defenders = @defender_tier.shuffle if @tmp_defenders.empty?
 
-      @tmp_defenders.pop
-    end
+        @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
-        result = ActiveGenie::Battle.basic(
-          player_1.content,
-          player_2.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 'draw' then [nil, nil]
+      def battle(player_1, player_2)
+        ActiveGenie::Logger.with_context({ player_1_id: player_1.id, player_2_id: player_2.id }) do
+          result = ActiveGenie::Battle.call(
+            player_1.content,
+            player_2.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 'draw' then [nil, nil]
+                          end
+
+          [winner, loser]
         end
-
-        [winner, loser]
       end
-    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))
-      
-      player_rating + (K * (score - expected_score)).round
-    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))
 
-    def log_context
-      { elo_round_id: }
-    end
+        player_rating + (K * (score - expected_score)).round
+      end
 
-    def elo_round_id
-      relegation_tier_ids = @relegation_tier.map(&:id).join(',')
-      defender_tier_ids = @defender_tier.map(&:id).join(',')
+      def log_context
+        { elo_round_id: }
+      end
 
-      ranking_unique_key = [relegation_tier_ids, defender_tier_ids, @criteria, @config.to_json].join('-')
-      Digest::MD5.hexdigest(ranking_unique_key)
-    end
+      def elo_round_id
+        relegation_tier_ids = @relegation_tier.map(&:id).join(',')
+        defender_tier_ids = @defender_tier.map(&:id).join(',')
 
-    def 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:,
-      }
-    end
+        ranking_unique_key = [relegation_tier_ids, defender_tier_ids, @criteria, @config.to_json].join('-')
+        Digest::MD5.hexdigest(ranking_unique_key)
+      end
 
-    def players_in_round
-      @defender_tier + @relegation_tier
-    end
+      def 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:
+        }
+      end
 
-    def highest_elo
-      players_in_round.max_by(&:elo).elo
-    end
+      def players_in_round
+        @defender_tier + @relegation_tier
+      end
 
-    def players_elo_diff
-      players_in_round.map do |player|
-        [player.id, player.elo - @previous_elo[player.id]]
-      end.sort_by { |_, diff| -diff }.to_h
-    end
+      def highest_elo
+        players_in_round.max_by(&:elo).elo
+      end
 
-    def log_observer(log)
-      @total_tokens += log[:total_tokens] if log[:code] == :llm_usage
+      def players_elo_diff
+        players_in_round.map do |player|
+          [player.id, player.elo - @previous_elo[player.id]]
+        end.sort_by { |_, diff| -diff }.to_h
+      end
+
+      def log_observer(log)
+        @total_tokens += log[:total_tokens] if log[:code] == :llm_usage
+      end
     end
   end
 end

data/lib/active_genie/ranking/free_for_all.rb

@@ -1,93 +1,97 @@
-require_relative '../battle/basic'
+# frozen_string_literal: true
 
-module ActiveGenie::Ranking
-  class FreeForAll
-    def self.call(...)
-      new(...).call
-    end
+require_relative '../battle/generalist'
 
-    def initialize(players, criteria, config: {})
-      @players = players
-      @criteria = criteria
-      @config = config
-      @start_time = Time.now
-      @total_tokens = 0
-    end
+module ActiveGenie
+  module Ranking
+    class FreeForAll
+      def self.call(...)
+        new(...).call
+      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
-        end
+      def initialize(players, criteria, config: {})
+        @players = players
+        @criteria = criteria
+        @config = config
+        @start_time = Time.now
+        @total_tokens = 0
       end
 
-      ActiveGenie::Logger.info({ code: :free_for_all_report, **report })
+      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)
 
-      report
-    end
+            if winner.nil? || loser.nil?
+              player_1.draw!
+              player_2.draw!
+            else
+              winner.win!
+              loser.lose!
+            end
+          end
+        end
 
-    private
+        ActiveGenie::Logger.call({ code: :free_for_all_report, **report })
 
-    # TODO: reduce the number of matches based on transitivity.
-    #       For example, if A is better than B, and B is better than C, then battle between A and C should be auto win A
-    def matches
-      @players.eligible.combination(2).to_a
-    end
+        report
+      end
+
+      private
 
-    def battle(player_1, player_2)
-      result = ActiveGenie::Battle.basic(
-        player_1.content,
-        player_2.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 'draw' then [nil, nil, result['reasoning']]
+      # TODO: reduce the number of matches based on transitivity.
+      #       For example, if A is better than B, and B is better than C, then battle between A and C should be auto win A
+      def matches
+        @players.eligible.combination(2).to_a
       end
 
-      ActiveGenie::Logger.debug({
-        code: :free_for_all_battle,
-        player_ids: [player_1.id, player_2.id],
-        winner_id: winner&.id,
-        loser_id: loser&.id,
-        reasoning: result['reasoning']
-      })
+      def battle(player_1, player_2)
+        result = ActiveGenie::Battle.call(
+          player_1.content,
+          player_2.content,
+          @criteria,
+          config: @config
+        )
 
-      [winner, loser]
-    end
+        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 'draw' then [nil, nil, result['reasoning']]
+                        end
 
-    def log_context
-      { free_for_all_id: }
-    end
+        ActiveGenie::Logger.call({
+                                   code: :free_for_all_battle,
+                                   player_ids: [player_1.id, player_2.id],
+                                   winner_id: winner&.id,
+                                   loser_id: loser&.id,
+                                   reasoning: result['reasoning']
+                                 })
 
-    def free_for_all_id
-      eligible_ids = @players.eligible.map(&:id).join(',')
-      ranking_unique_key = [eligible_ids, @criteria, @config.to_json].join('-')
-      Digest::MD5.hexdigest(ranking_unique_key)
-    end
+        [winner, loser]
+      end
 
-    def report
-      {
-        free_for_all_id:,
-        battles_count: matches.size,
-        duration_seconds: Time.now - @start_time,
-        total_tokens: @total_tokens,
-      }
-    end
+      def log_context
+        { free_for_all_id: }
+      end
 
-    def log_observer(log)
-      @total_tokens += log[:total_tokens] if log[:code] == :llm_usage
+      def free_for_all_id
+        eligible_ids = @players.eligible.map(&:id).join(',')
+        ranking_unique_key = [eligible_ids, @criteria, @config.to_json].join('-')
+        Digest::MD5.hexdigest(ranking_unique_key)
+      end
+
+      def report
+        {
+          free_for_all_id:,
+          battles_count: matches.size,
+          duration_seconds: Time.now - @start_time,
+          total_tokens: @total_tokens
+        }
+      end
+
+      def log_observer(log)
+        @total_tokens += log[:total_tokens] if log[:code] == :llm_usage
+      end
     end
   end
 end

data/lib/active_genie/ranking/player.rb

@@ -1,92 +1,100 @@
+# frozen_string_literal: true
+
 require 'digest'
 
-module ActiveGenie::Ranking
-  class Player
-    def initialize(params)
-      params = { content: params } if params.is_a?(String)
-
-      @content = params.dig(:content) || params
-      @id = params.dig(:id) || Digest::MD5.hexdigest(@content)
-      @score = params.dig(:score) || nil
-      @elo = params.dig(:elo) || nil
-      @ffa_win_count = params.dig(:ffa_win_count) || 0
-      @ffa_lose_count = params.dig(:ffa_lose_count) || 0
-      @ffa_draw_count = params.dig(:ffa_draw_count) || 0
-      @eliminated = params.dig(:eliminated) || nil
-    end
+module ActiveGenie
+  module Ranking
+    class Player
+      def initialize(params)
+        params = { content: params } if params.is_a?(String)
+
+        @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
+      end
+      attr_accessor :rank
 
-    attr_reader :id, :content, :score, :elo, 
-      :ffa_win_count, :ffa_lose_count, :ffa_draw_count,
-      :eliminated
-    attr_accessor :rank
+      def score=(value)
+        ActiveGenie::Logger.call({ code: :new_score, player_id: id, score: value }) if value != @score
+        @score = value
+        @elo = generate_elo_by_score
+      end
 
-    def score=(value)
-      ActiveGenie::Logger.debug({ code: :new_score, player_id: id, score: value }) if value != @score
-      @score = value
-      @elo = generate_elo_by_score
-    end
+      def elo=(value)
+        ActiveGenie::Logger.call({ code: :new_elo, player_id: id, elo: value }) if value != @elo
+        @elo = value
+      end
 
-    def elo=(value)
-      ActiveGenie::Logger.debug({ code: :new_elo, player_id: id, elo: value }) if value != @elo
-      @elo = value
-    end
+      def eliminated=(value)
+        ActiveGenie::Logger.call({ code: :new_eliminated, player_id: id, eliminated: value }) if value != @eliminated
+        @eliminated = value
+      end
 
-    def eliminated=(value)
-      ActiveGenie::Logger.debug({ code: :new_eliminated, player_id: id, eliminated: value }) if value != @eliminated
-      @eliminated = value
-    end
+      def draw!
+        @ffa_draw_count += 1
+        ActiveGenie::Logger.call({ code: :new_ffa_score, player_id: id, result: 'draw', ffa_score: })
+      end
 
-    def draw!
-      @ffa_draw_count += 1
-      ActiveGenie::Logger.debug({ code: :new_ffa_score, player_id: id, result: 'draw', ffa_score: })
-    end
+      def win!
+        @ffa_win_count += 1
+        ActiveGenie::Logger.call({ code: :new_ffa_score, player_id: id, result: 'win', ffa_score: })
+      end
 
-    def win!
-      @ffa_win_count += 1
-      ActiveGenie::Logger.debug({ code: :new_ffa_score, player_id: id, result: 'win', ffa_score: })
-    end
+      def lose!
+        @ffa_lose_count += 1
+        ActiveGenie::Logger.call({ code: :new_ffa_score, player_id: id, result: 'lose', ffa_score: })
+      end
 
-    def lose!
-      @ffa_lose_count += 1
-      ActiveGenie::Logger.debug({ 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
-    end
+      def ffa_score
+        @ffa_win_count * 3 + @ffa_draw_count
+      end
 
-    def to_h
-      {
-        id:, content:, score:, elo:,
-        ffa_win_count:, ffa_lose_count:, ffa_draw_count:,
-        eliminated:, ffa_score:
-      }
-    end
+      def sort_value
+        (ffa_score * 1_000_000) + ((elo || 0) * 100) + (score || 0)
+      end
+
+      def to_json(*_args)
+        to_h.to_json
+      end
+
+      def to_h
+        {
+          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)
+        if method_name == :[] && args.size == 1
+          attr_name = args.first.to_sym
 
-    def method_missing(method_name, *args, &block)
-      if method_name == :[] && args.size == 1
-        attr_name = args.first.to_sym
+          return send(attr_name) if respond_to?(attr_name)
 
-        if respond_to?(attr_name) 
-          return send(attr_name)
-        else
           return nil
+
         end
+
+        super
       end
 
-      super
-    end
+      def respond_to_missing?(method_name, include_private = false)
+        method_name == :[] || super
+      end
 
-    def respond_to_missing?(method_name, include_private = false)
-      method_name == :[] || super
-    end
+      def generate_elo_by_score
+        BASE_ELO + ((@score || 0) - 50)
+      end
 
-    def generate_elo_by_score
-      BASE_ELO + ((@score || 0) - 50)
+      BASE_ELO = 1000
     end
-
-    private
-    
-    BASE_ELO = 1000
   end
-end
+end