active_genie 0.0.21 → 0.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9c9c17c2c02f617c53edd6177ff72e0e2da34a4faf6bbeb9f9698b3858e4b69
-  data.tar.gz: 777620b958c17c9a439fcf5b8bdb3195564005e5becd8c41955c1c255c1a6ad3
+  metadata.gz: ce95fdbe75d4d49e33eebf773847c534a52e9193ec44b3292aba0dd2dcac6fd4
+  data.tar.gz: 95130aa00f70d219ecea862d74413179a43f72a96f2a1ab22406413f246b0695
 SHA512:
-  metadata.gz: c3bee8941701e3516f48106d96165d78ea279cea1c7e5623515aed3361b5a337e191c85a3e4774a9526e3412a4b11f4c4f5d766e7f5a0e827cc74d869bd1ca54
-  data.tar.gz: a489c2f042aee21501697dfac47d0a37bd1a8bf50d990472dda2f7f8567615c3efd4422500653ac798c425a65df7bc065afaa3337f08a16305d4ef8f0b254a05
+  metadata.gz: 7c977f74b8d5603f28f823c5d6efffe5a345f4c47a6ee818edaaab57e0372769578420dd03de29bc51ac0a5f2107c7fc8365f7fbd114a5a02c146499b91e6988
+  data.tar.gz: b3b9fb9986cb24c7065b5e95528a0a6212dccc452224b017ae68ad9452eb7c944bceac9e832e089886a67d2093040418c7596847bad544b1e1c873923dd6f78c

data/VERSION

@@ -1 +1 @@
-0.0.21
+0.0.23

data/lib/active_genie/battle/basic.rb

@@ -122,8 +122,7 @@ module ActiveGenie::Battle
             description: 'Who is the winner based on the impartial judge reasoning?',
             enum: ['player_1', 'player_2']
           },
-        },
-        required: %w[player_1_sell_himself player_2_sell_himself player_1_arguments player_2_counter impartial_judge_winner_reasoning impartial_judge_winner]
+        }
       }
     }
   end

data/lib/active_genie/configuration/providers/openai_config.rb

@@ -33,21 +33,21 @@ module ActiveGenie
       # Defaults to 'gpt-4o-mini'.
       # @return [String] The lower tier model name.
       def lower_tier_model
-        @lower_tier_model || 'gpt-4.1-mini'
+        @lower_tier_model || 'gpt-4o-mini'
       end
 
       # Retrieves the model name designated for the middle tier (e.g., balanced performance).
       # Defaults to 'gpt-4o'.
       # @return [String] The middle tier model name.
       def middle_tier_model
-        @middle_tier_model || 'gpt-4.1'
+        @middle_tier_model || 'gpt-4o'
       end
 
       # Retrieves the model name designated for the upper tier (e.g., most capable).
       # Defaults to 'o1-preview'.
       # @return [String] The upper tier model name.
       def upper_tier_model
-        @upper_tier_model || 'o3-mini'
+        @upper_tier_model || 'o1-preview'
       end
     end
   end

data/lib/active_genie/ranking/README.md

@@ -40,34 +40,4 @@ The method processes the players through scoring, elimination, and ranking phase
 - Adjust initial criteria to ensure consistency
 - Adjust each player's content to ensure consistency
 - Support players with images or audio
-- Parallelize processing battles and scoring
-
-## Ranking Configuration
-
-| Config | Description | Default |
-|--------|-------------|---------|
-| `score_variation_threshold` | Threshold for eliminating players with inconsistent scores | `30` |
-
-## Ranking Callbacks
-Callbacks are optional and can be used to watch any changes in players, battles, or scoring.
-
-| Callback | Description |
-|--------|-------------|
-| `watch_players` | Callback to watch any changes in players |
-| `watch_battles` | Callback to watch any changes in battles |
-| `watch_scoring` | Callback to watch any changes in scoring |
-
-Example of callback usage:
-
-```ruby
-result = ActiveGenie::Ranking.call(
-  players,
-  criteria,
-  config: {
-    watch_players: ->(player) { puts player },
-    watch_battles: ->(battle) { puts battle },
-    watch_scoring: ->(scoring) { puts scoring }
-  }
-)
-```
-
+- Parallelize processing battles and scoring

data/lib/active_genie/ranking/elo_round.rb

@@ -76,9 +76,6 @@ module ActiveGenie::Ranking
           when 'draw' then [nil, nil]
         end
 
-        @config[:runtime][:watch_battle].call({ id: "#{player_1.id}_#{player_2.id}_#{elo_round_id}", player_1:, player_2:, winner:, loser:, reasoning: result['reasoning'] }) if @config[:runtime][:watch_battle]
-        @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
-
         [winner, loser]
       end
     end

data/lib/active_genie/ranking/free_for_all.rb

@@ -26,8 +26,6 @@ module ActiveGenie::Ranking
             winner.win!
             loser.lose!
           end
-          
-          @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
         end
       end
 
@@ -58,7 +56,6 @@ module ActiveGenie::Ranking
         when 'draw' then [nil, nil, result['reasoning']]
       end
 
-      @config[:runtime][:watch_battle].call({ id: "#{player_1.id}_#{player_2.id}_#{free_for_all_id}", player_1:, player_2:, winner:, loser:, reasoning: result['reasoning'] }) if @config[:runtime][:watch_battle]
       ActiveGenie::Logger.debug({
         code: :free_for_all_battle,
         player_ids: [player_1.id, player_2.id],

data/lib/active_genie/ranking/player.rb

@@ -6,7 +6,6 @@ module ActiveGenie::Ranking
       params = { content: params } if params.is_a?(String)
 
       @content = params.dig(:content) || params
-      @name = params.dig(:name) || params.dig(:content)[0..10]
       @id = params.dig(:id) || Digest::MD5.hexdigest(@content)
       @score = params.dig(:score) || nil
       @elo = params.dig(:elo) || nil
@@ -16,8 +15,9 @@ module ActiveGenie::Ranking
       @eliminated = params.dig(:eliminated) || nil
     end
 
-    attr_reader :id, :content, :score, :elo,  :ffa_win_count,
-      :ffa_lose_count, :ffa_draw_count, :eliminated
+    attr_reader :id, :content, :score, :elo, 
+      :ffa_win_count, :ffa_lose_count, :ffa_draw_count,
+      :eliminated
     attr_accessor :rank
 
     def score=(value)
@@ -51,27 +51,15 @@ module ActiveGenie::Ranking
       ActiveGenie::Logger.debug({ code: :new_ffa_score, player_id: id, result: 'lose', ffa_score: })
     end
 
-    def name
-      @name
-    end
-
     def ffa_score
       @ffa_win_count * 3 + @ffa_draw_count
     end
 
-    def sort_value
-      (ffa_score * 1000000) + ((elo || 0) * 100) + (score || 0)
-    end
-
-    def to_json
-      to_h.to_json
-    end
-
     def to_h
       {
-        id:, name:, content:, score:, elo:,
+        id:, content:, score:, elo:,
         ffa_win_count:, ffa_lose_count:, ffa_draw_count:,
-        eliminated:, ffa_score:, sort_value:
+        eliminated:, ffa_score:
       }
     end
 

data/lib/active_genie/ranking/players_collection.rb

@@ -41,14 +41,10 @@ module ActiveGenie::Ranking
     end
 
     def sorted
-      sorted_players = @players.sort_by { |p| -p.sort_value }
+      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_json
-      to_h.to_json
-    end
 
     def to_h
       sorted.map { |p| p.to_h }

data/lib/active_genie/ranking/ranking.rb

@@ -67,7 +67,7 @@ module ActiveGenie::Ranking
 
     private
 
-    DEFAULT_SCORE_VARIATION_THRESHOLD = 30
+    SCORE_VARIATION_THRESHOLD = 15
     ELIMINATION_VARIATION = 'variation_too_high'
     ELIMINATION_RELEGATION = 'relegation_tier'
     
@@ -80,36 +80,27 @@ module ActiveGenie::Ranking
     end
 
     def set_initial_player_scores!
-      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
       RankingScoring.call(@players, @criteria, reviewers: @reviewers, config: @config)
-      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
     end
 
     def eliminate_obvious_bad_players!
-      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
-      while @players.coefficient_of_variation >= score_variation_threshold
+      while @players.coefficient_of_variation >= SCORE_VARIATION_THRESHOLD
         @players.eligible.last.eliminated = ELIMINATION_VARIATION
       end
-      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
     end
 
     def run_elo_round!
-      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
       @elo_rounds_played += 1
 
       elo_report = EloRound.call(@players, @criteria, config: @config)
 
       @elo_round_battle_count += elo_report[:battles_count]
 
-      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
       elo_report
     end
 
     def eliminate_relegation_players!
-      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
       @players.calc_relegation_tier.each { |player| player.eliminated = ELIMINATION_RELEGATION }
-      
-      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
     end
 
     def rebalance_players!(elo_report)
@@ -120,19 +111,12 @@ module ActiveGenie::Ranking
 
         player.elo += elo_report[:highest_elo_diff]
       end
-      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
     end
 
     def run_free_for_all!
-      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
       ffa_report = FreeForAll.call(@players, @criteria, config: @config)
 
       @free_for_all_battle_count += ffa_report[:battles_count]
-      @config[:runtime][:watch_players].call(@players) if @config[:runtime][:watch_players]
-    end
-
-    def score_variation_threshold
-      @config[:runtime][:score_variation_threshold] || DEFAULT_SCORE_VARIATION_THRESHOLD
     end
 
     def report

data/lib/active_genie/ranking/ranking_scoring.rb

@@ -16,27 +16,10 @@ module ActiveGenie::Ranking
     def call
       ActiveGenie::Logger.with_context(log_context) do
         @reviewers = generate_reviewers
-        
-        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)
+        players_without_score.each do |player|
+          # TODO: This can take a while, can be parallelized
+          player.score = generate_score(player)
         end
       end
     end
@@ -56,11 +39,6 @@ module ActiveGenie::Ranking
       ).values_at('final_score', 'final_reasoning')
 
       ActiveGenie::Logger.debug({ code: :new_score, player_id: player.id, score:, reasoning: })
-      @config[:runtime][:watch_scoring].call({ 
-        player_id: player.id, 
-        player_name: player.content[0..10], 
-        score: player.score 
-      }) if @config[:runtime][:watch_scoring]
 
       score
     end
@@ -87,7 +65,7 @@ module ActiveGenie::Ranking
       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'
+      Digest::MD5.hexdigest(ranking_unique_key)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_genie
 version: !ruby/object:Gem::Version
-  version: 0.0.21
+  version: 0.0.23
 platform: ruby
 authors:
 - Radamés Roriz
@@ -9,21 +9,22 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: "# ActiveGenie \U0001F9DE‍♂️\n> The lodash for GenAI, stop reinventing
-  the wheel\n\nActiveGenie is a Ruby gem that provides valuable solutions powered
-  by Generative AI (GenAI) models. Just like Lodash or ActiveStorage, ActiveGenie
-  brings a set of Modules to reach real value fast and reliably.\nActiveGenie is backed
-  by a custom benchmarking system that ensures consistent quality and performance
-  across different models and providers in every release.\n\n## Features\n\n* **Data
-  Extractor:** Extract structured data from text using AI-powered analysis\n* **Scoring:**
-  Text evaluation system with detailed scoring and feedback\n* **Battle:** AI-powered
-  battle evaluation system between two players\n* **Ranking:** Multi-phase ranking
-  system for multiple options\n\n### Performance Breakdown\n\n| ActiveGenie Module
-  | Best Precision | Worst Precision | Recommended Model |\n|--------------------|-------------------|-------------------|-------------------|\n|
-  data_extractor | 100% | 86% | `gpt-4o-mini` |\n| battle | 100% | 10% | `gemini-2.0-flash-lite`
-  |\n| scoring | 69% | 61% | `claude-3-5-haiku-20241022` |\n| ranking | 100% | 0%
-  | `gemini-2.0-flash-lite` |\n\nSee the [GitHub repository](https://github.com/Roriz/active_genie)
-  for complete documentation and examples.\n"
+description: |
+  == ActiveGenie
+
+  The lodash for GenAI, stop reinventing the wheel
+
+  ActiveGenie is a Ruby gem that provides valuable solutions powered by Generative AI (GenAI) models. Just like Lodash or ActiveStorage, ActiveGenie brings a set of Modules to reach real value fast and reliably.
+  ActiveGenie is backed by a custom benchmarking system that ensures consistent quality and performance across different models and providers in every release.
+
+  == Features
+
+  * Data Extractor: (100% precision) Extract structured data from text using AI-powered analysis
+  * Scoring: (69% precision) Text evaluation system with detailed scoring and feedback
+  * Battle: (100% precision) AI-powered battle evaluation system between two players
+  * Ranking: (100% precision) Multi-phase ranking system for multiple options
+
+  See the GitHub repository at https://github.com/Roriz/active_genie for complete documentation and examples.
 email:
 - radames@roriz.dev
 executables: []