active_genie 0.0.24 → 0.0.25

data/lib/active_genie/ranking/players_collection.rb

@@ -1,75 +1,87 @@
-require_relative './player'
-
-module ActiveGenie::Ranking
-  class PlayersCollection
-    def initialize(param_players)
-      @players = build(param_players)
-    end
-    attr_reader :players
-
-    def coefficient_of_variation
-      score_list = eligible.map(&:score).compact
-      return nil if score_list.empty?
-
-      mean = score_list.sum.to_f / score_list.size
-      return nil if mean == 0
-
-      variance = score_list.map { |num| (num - mean) ** 2 }.sum / score_list.size
-      standard_deviation = Math.sqrt(variance)
-
-      (standard_deviation / mean) * 100
-    end
-
-    def calc_relegation_tier
-      eligible[(tier_size*-1)..-1]
-    end
-
-    def calc_defender_tier
-      eligible[(tier_size*-2)...(tier_size*-1)]
-    end
-
-    def eligible
-      sorted.reject(&:eliminated)
-    end
+# frozen_string_literal: true
 
-    def eligible_size
-      @players.reject(&:eliminated).size
-    end
-
-    def elo_eligible?
-      eligible.size > 15
-    end
-
-    def sorted
-      sorted_players = @players.sort_by { |p| [-p.ffa_score, -(p.elo || 0), -(p.score || 0)] }
-      sorted_players.each_with_index { |p, i| p.rank = i + 1 }
-      sorted_players
-    end
-
-    def to_h
-      sorted.map { |p| p.to_h }
-    end
-
-    def method_missing(...)
-      @players.send(...)
-    end
-
-    private
-
-    def build(param_players)
-      param_players.map { |p| Player.new(p) }
-    end
+require_relative './player'
 
-    # Returns the number of players to battle in each round
-    # based on the eligible size, start fast and go slow until top 10
-    # Example:
-    #   - 50 eligible, tier_size: 15
-    #   - 35 eligible, tier_size: 11 
-    #   - 24 eligible, tier_size: 10
-    #   - 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
+module ActiveGenie
+  module Ranking
+    class PlayersCollection
+      def initialize(param_players)
+        @players = build(param_players)
+      end
+      attr_reader :players
+
+      def coefficient_of_variation
+        score_list = eligible.map(&:score).compact
+        return nil if score_list.empty?
+
+        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
+        standard_deviation = Math.sqrt(variance)
+
+        (standard_deviation / mean) * 100
+      end
+
+      def calc_relegation_tier
+        eligible[(tier_size * -1)..]
+      end
+
+      def calc_defender_tier
+        eligible[(tier_size * -2)...(tier_size * -1)]
+      end
+
+      def eligible
+        sorted.reject(&:eliminated)
+      end
+
+      def eligible_size
+        @players.reject(&:eliminated).size
+      end
+
+      def elo_eligible?
+        eligible.size > 15
+      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
+      end
+
+      def to_json(*_args)
+        to_h.to_json
+      end
+
+      def to_h
+        sorted.map(&:to_h)
+      end
+
+      def method_missing(...)
+        @players.send(...)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @players.respond_to?(method_name, include_private)
+      end
+
+      private
+
+      def build(param_players)
+        param_players.map { |p| Player.new(p) }
+      end
+
+      # Returns the number of players to battle in each round
+      # based on the eligible size, start fast and go slow until top 10
+      # Example:
+      #   - 50 eligible, tier_size: 15
+      #   - 35 eligible, tier_size: 11
+      #   - 24 eligible, tier_size: 10
+      #   - 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
+      end
     end
   end
-end
+end

data/lib/active_genie/ranking/ranking.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../concerns/loggable'
 require_relative './players_collection'
 require_relative './free_for_all'
@@ -27,127 +29,102 @@ require_relative './ranking_scoring'
 # @param config [Hash] Additional configuration config
 #   Example: { model: "gpt-4o", api_key: ENV['OPENAI_API_KEY'] }
 # @return [Hash] Final ranked player results
-module ActiveGenie::Ranking
-  class Ranking
-    include ActiveGenie::Concerns::Loggable
+module ActiveGenie
+  module Ranking
+    class Ranking
+      include ActiveGenie::Concerns::Loggable
 
-    def self.call(...)
-      new(...).call
-    end
+      def self.call(...)
+        new(...).call
+      end
 
-    def initialize(param_players, criteria, reviewers: [], config: {})
-      @criteria = criteria
-      @reviewers = Array(reviewers).compact.uniq
-      @config = ActiveGenie::Configuration.to_h(config)
-      @players = PlayersCollection.new(param_players)
-      @elo_rounds_played = 0
-      @elo_round_battle_count = 0
-      @free_for_all_battle_count = 0
-      @total_tokens = 0
-      @start_time = Time.now
-    end
+      def initialize(_param_players, criteria, reviewers: [], config: {})
+        @criteria = criteria
+        @reviewers = Array(reviewers).compact.uniq
+        @config = ActiveGenie.configuration.merge(config)
+        @players = nil
+      end
 
-    def call
-      initial_log
+      def call
+        @players = create_players
 
-      set_initial_player_scores!
-      eliminate_obvious_bad_players!
+        set_initial_player_scores!
+        eliminate_obvious_bad_players!
 
-      while @players.elo_eligible?
-        elo_report = run_elo_round!
-        eliminate_relegation_players!
-        rebalance_players!(elo_report)
-      end
+        while @players.elo_eligible?
+          elo_report = run_elo_round!
+          eliminate_relegation_players!
+          rebalance_players!(elo_report)
+        end
 
-      run_free_for_all!
-      final_logs
+        run_free_for_all!
 
-      @players.sorted
-    end
+        sorted_players
+      end
 
-    private
+      private
 
-    SCORE_VARIATION_THRESHOLD = 15
-    ELIMINATION_VARIATION = 'variation_too_high'
-    ELIMINATION_RELEGATION = 'relegation_tier'
-    
-    with_logging_context :log_context, ->(log) { 
-      @total_tokens += log[:total_tokens] || 0 if log[:code] == :llm_usage
-    }
+      ELIMINATION_VARIATION = 'variation_too_high'
+      ELIMINATION_RELEGATION = 'relegation_tier'
 
-    def initial_log
-      @players.each { |p| ActiveGenie::Logger.debug({ code: :new_player, player: p.to_h }) }
-    end
+      call_with_log_context :log_context
 
-    def set_initial_player_scores!
-      RankingScoring.call(@players, @criteria, reviewers: @reviewers, config: @config)
-    end
+      def create_players
+        players = PlayersCollection.new(param_players)
+        players.each { |p| logger({ code: :new_player, player: p.to_h }) }
 
-    def eliminate_obvious_bad_players!
-      while @players.coefficient_of_variation >= SCORE_VARIATION_THRESHOLD
-        @players.eligible.last.eliminated = ELIMINATION_VARIATION
+        players
       end
-    end
 
-    def run_elo_round!
-      @elo_rounds_played += 1
-
-      elo_report = EloRound.call(@players, @criteria, config: @config)
+      def set_initial_player_scores!
+        RankingScoring.call(@players, @criteria, reviewers: @reviewers, config: @config)
+      end
 
-      @elo_round_battle_count += elo_report[:battles_count]
+      def eliminate_obvious_bad_players!
+        while @players.coefficient_of_variation >= @config.ranking.score_variation_threshold
+          @players.eligible.last.eliminated = ELIMINATION_VARIATION
+        end
+      end
 
-      elo_report
-    end
+      def run_elo_round!
+        EloRound.call(@players, @criteria, config: @config)
+      end
 
-    def eliminate_relegation_players!
-      @players.calc_relegation_tier.each { |player| player.eliminated = ELIMINATION_RELEGATION }
-    end
+      def eliminate_relegation_players!
+        @players.calc_relegation_tier.each { |player| player.eliminated = ELIMINATION_RELEGATION }
+      end
 
-    def rebalance_players!(elo_report)
-      return if elo_report[:highest_elo_diff].negative?
+      def rebalance_players!(elo_report)
+        return if elo_report[:highest_elo_diff].negative?
 
-      @players.eligible.each do |player|
-        next if elo_report[:players_in_round].include?(player.id)
+        @players.eligible.each do |player|
+          next if elo_report[:players_in_round].include?(player.id)
 
-        player.elo += elo_report[:highest_elo_diff]
+          player.elo += elo_report[:highest_elo_diff]
+        end
       end
-    end
 
-    def run_free_for_all!
-      ffa_report = FreeForAll.call(@players, @criteria, config: @config)
+      def run_free_for_all!
+        FreeForAll.call(@players, @criteria, config: @config)
+      end
 
-      @free_for_all_battle_count += ffa_report[:battles_count]
-    end
+      def sorted_players
+        players = @players.sorted
+        logger({ code: :ranking_final, players: players.map(&:to_h) })
 
-    def report
-      {
-        ranking_id: ranking_id,
-        players_count: @players.size,
-        variation_too_high: @players.select { |player| player.eliminated == ELIMINATION_VARIATION }.size,
-        elo_rounds_played: @elo_rounds_played,
-        elo_round_battle_count: @elo_round_battle_count,
-        relegation_tier: @players.select { |player| player.eliminated == ELIMINATION_RELEGATION }.size,
-        ffa_round_battle_count: @free_for_all_battle_count,
-        top3: @players.eligible[0..2].map(&:id),
-        total_tokens: @total_tokens,
-        duration_seconds: Time.now - @start_time,
-      }
-    end
-    
-    def final_logs
-      ActiveGenie::Logger.debug({ code: :ranking_final, players: @players.sorted.map(&:to_h) })
-      ActiveGenie::Logger.info({ code: :ranking, **report })
-    end
+        players.map(&:to_h)
+      end
 
-    def log_context
-      { config: @config[:log], ranking_id: }
-    end
+      def log_context
+        { ranking_id: }
+      end
 
-    def ranking_id
-      player_ids = @players.map(&:id).join(',')
-      ranking_unique_key = [player_ids, @criteria, @config.to_json].join('-')
+      def ranking_id
+        player_ids = @players.map(&:id).join(',')
+        ranking_unique_key = [player_ids, @criteria, @config.to_json].join('-')
 
-      Digest::MD5.hexdigest(ranking_unique_key)
+        Digest::MD5.hexdigest(ranking_unique_key)
+      end
     end
   end
 end

data/lib/active_genie/ranking/ranking_scoring.rb

@@ -1,71 +1,92 @@
+# frozen_string_literal: true
+
 require_relative '../scoring/recommended_reviewers'
 
-module ActiveGenie::Ranking
-  class RankingScoring
-    def self.call(...)
-      new(...).call
-    end
+module ActiveGenie
+  module Ranking
+    class RankingScoring
+      def self.call(...)
+        new(...).call
+      end
 
-    def initialize(players, criteria, reviewers: [], config: {})
-      @players = players
-      @criteria = criteria
-      @config = ActiveGenie::Configuration.to_h(config)
-      @reviewers = Array(reviewers).compact.uniq
-    end
+      def initialize(players, criteria, reviewers: [], config: {})
+        @players = players
+        @criteria = criteria
+        @config = ActiveGenie.configuration.merge(config)
+        @reviewers = Array(reviewers).compact.uniq
+      end
 
-    def call
-      ActiveGenie::Logger.with_context(log_context) do
-        @reviewers = generate_reviewers
+      def call
+        ActiveGenie::Logger.with_context(log_context) do
+          @reviewers = generate_reviewers
 
-        players_without_score.each do |player|
-          # TODO: This can take a while, can be parallelized
-          player.score = generate_score(player)
+          players_to_score = players_without_score
+          until players_to_score.empty?
+            threads = []
+            mutex = Mutex.new
+
+            # Take up to 3 players for parallel processing
+            current_batch = players_to_score.shift(3)
+
+            current_batch.each do |player|
+              threads << Thread.new(player) do |p|
+                score = generate_score(p)
+
+                mutex.synchronize do
+                  p.score = score
+                end
+              end
+            end
+
+            # Wait for all threads in this batch to complete
+            threads.each(&:join)
+          end
         end
       end
-    end
 
-    private
+      private
 
-    def players_without_score
-      @players_without_score ||= @players.select { |player| player.score.nil? }
-    end
+      def players_without_score
+        @players_without_score ||= @players.select { |player| player.score.nil? }
+      end
 
-    def generate_score(player)
-      score, reasoning = ActiveGenie::Scoring.call(
-        player.content,
-        @criteria,
-        @reviewers,
-        config: @config
-      ).values_at('final_score', 'final_reasoning')
+      def generate_score(player)
+        score, reasoning = ActiveGenie::Scoring.call(
+          player.content,
+          @criteria,
+          @reviewers,
+          config: @config
+        ).values_at('final_score', 'final_reasoning')
 
-      ActiveGenie::Logger.debug({ code: :new_score, player_id: player.id, score:, reasoning: })
+        ActiveGenie::Logger.call({ code: :new_score, player_id: player.id, score:, reasoning: })
 
-      score
-    end
+        score
+      end
 
-    def generate_reviewers
-      return @reviewers if @reviewers.size > 0
+      def generate_reviewers
+        return @reviewers if @reviewers.size.positive?
 
-      reviewer1, reviewer2, reviewer3 = ActiveGenie::Scoring::RecommendedReviewers.call(
-        [@players.sample.content, @players.sample.content].join("\n\n"),
-        @criteria,
-        config: @config
-      ).values_at('reviewer1', 'reviewer2', 'reviewer3')
-      
-      ActiveGenie::Logger.debug({ code: :new_reviewers, reviewers: [reviewer1, reviewer2, reviewer3] })
+        reviewer1, reviewer2, reviewer3 = ActiveGenie::Scoring::RecommendedReviewers.call(
+          [@players.sample.content, @players.sample.content].join("\n\n"),
+          @criteria,
+          config: @config
+        ).values_at('reviewer1', 'reviewer2', 'reviewer3')
 
-      [reviewer1, reviewer2, reviewer3]
-    end
+        ActiveGenie::Logger.call({ code: :new_reviewers, reviewers: [reviewer1, reviewer2, reviewer3] })
 
-    def log_context
-      { ranking_scoring_id: }
-    end
+        [reviewer1, reviewer2, reviewer3]
+      end
 
-    def ranking_scoring_id
-      player_ids = players_without_score.map(&:id).join(',')
-      ranking_unique_key = [player_ids, @criteria, @config.to_json].join('-')
+      def log_context
+        { ranking_scoring_id: }
+      end
 
-      Digest::MD5.hexdigest(ranking_unique_key)
+      def ranking_scoring_id
+        player_ids = players_without_score.map(&:id).join(',')
+        ranking_unique_key = [player_ids, @criteria, @config.to_json].join('-')
+
+        "#{Digest::MD5.hexdigest(ranking_unique_key)}-scoring"
+      end
     end
   end
 end

data/lib/active_genie/ranking.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'ranking/ranking'
 
 module ActiveGenie

data/lib/active_genie/scoring/README.md

@@ -17,7 +17,7 @@ text = "The code implements a binary search algorithm with O(log n) complexity"
 criteria = "Evaluate technical accuracy and clarity"
 reviewers = ["Algorithm Expert", "Technical Writer"]
 
-result = ActiveGenie::Scoring::Basic.call(text, criteria, reviewers)
+result = ActiveGenie::Scoring.call(text, criteria, reviewers)
 # => {
 #      algorithm_expert_score: 95,
 #      algorithm_expert_reasoning: "Accurately describes binary search and its complexity",
@@ -35,7 +35,7 @@ When no reviewers are specified, the system automatically recommends appropriate
 text = "The patient shows signs of improved cardiac function"
 criteria = "Evaluate medical accuracy and clarity"
 
-result = ActiveGenie::Scoring::Basic.call(text, criteria)
+result = ActiveGenie::Scoring.call(text, criteria)
 # => {
 #      cardiologist_score: 88,
 #      cardiologist_reasoning: "Accurate assessment of cardiac improvement",
@@ -49,7 +49,7 @@ result = ActiveGenie::Scoring::Basic.call(text, criteria)
 
 ## Interface
 
-### `Basic.call(text, criteria, reviewers = [], config: {})`
+### `.call(text, criteria, reviewers = [], config: {})`
 Main interface for scoring text content.
 
 #### Parameters
@@ -73,4 +73,4 @@ Recommends appropriate reviewers based on content and criteria.
 - Supports custom weighting of reviewer scores
 - Returns detailed reasoning for each score
 
-Performance Impact: Using multiple reviewers or requesting detailed feedback may increase processing time.
+Performance Impact: Using multiple reviewers or requesting detailed feedback may increase processing time.