Pair the class and kwargs.

Note that in practice a user won't need to create the `PlayerInfo`
tuples. These are constructed by the `Population.__init__` when it
deconstructs the player instances passed as the `opponents` variable (a
list).

Author: drvinceknight

src/axelrod_dojo/__init__.py

@@ -1,3 +1,8 @@
 from .version import __version__
 from .archetypes.fsm import FSMParams
-from .utils import prepare_objective, Population, load_params, Params, score_for
+from .utils import (prepare_objective,
+                    Population,
+                    load_params,
+                    Params,
+                    score_for,
+                    PlayerInfo)

src/axelrod_dojo/utils.py

@@ -1,3 +1,4 @@
+from collections import namedtuple
 from functools import partial
 from itertools import repeat
 from multiprocessing import Pool, cpu_count
@@ -137,22 +138,20 @@ def params(self):
     def crossover(self, other):
         pass
 
+PlayerInfo = namedtuple('PlayerInfo', ['strategy', 'init_kwargs'])
 
-def score_params(params, objective, opponents,
-                 opponent_init_kwargs=None,
+def score_params(params, objective,
+                 opponents_information,
                  weights=None):
     """
     Return the overall mean score of a Params instance.
     """
     scores_for_all_opponents = []
     player = params.player()
 
-    if opponent_init_kwargs is None:
-        opponent_init_kwargs = [{} for _ in opponents]
-
-    for opponent_class, init_kwargs in zip(opponents, opponent_init_kwargs):
+    for strategy, init_kwargs in opponents_information:
         player.reset()
-        opponent = opponent_class(**init_kwargs)
+        opponent = strategy(**init_kwargs)
         scores_for_this_opponent = objective(player, opponent)
         mean_vs_opponent = mean(scores_for_this_opponent)
         scores_for_all_opponents.append(mean_vs_opponent)
@@ -179,11 +178,11 @@ def __init__(self, params_class, params_args, size, objective, output_filename,
         else:
             self.bottleneck = bottleneck
         if opponents is None:
-            self.opponents = axl.short_run_time_strategies
-            self.opponent_init_kwargs = None
+            self.opponents_information = [
+                    PlayerInfo(s, {}) for s in axl.short_run_time_strategies]
         else:
-            self.opponents = [p.__class__ for p in opponents]
-            self.opponent_init_kwargs = [p.init_kwargs for p in opponents]
+            self.opponents_information = [
+                    PlayerInfo(p.__class__, p.init_kwargs) for p in opponents]
         self.generation = 0
         self.params_args = params_args
         self.population = [params_class(*params_args) for _ in range(self.size)]
@@ -193,8 +192,7 @@ def score_all(self):
         starmap_params = zip(
             self.population,
             repeat(self.objective),
-            repeat(self.opponents),
-            repeat(self.opponent_init_kwargs),
+            repeat(self.opponents_information),
             repeat(self.weights))
         results = self.pool.starmap(score_params, starmap_params)
         return results

tests/unit/test_utils.py

@@ -180,66 +180,64 @@ class DummyParams(utils.Params):
     def player(self):
         return axl.Cooperator()
 
-
 class TestScoreParams(unittest.TestCase):
     def test_score(self):
         axl.seed(0)
-        opponents = axl.demo_strategies
+        opponents_information = [utils.PlayerInfo(s, {})
+                                 for s in axl.demo_strategies]
         objective = utils.prepare_objective()
         params = DummyParams()
         score = utils.score_params(params,
                                    objective=objective,
-                                   opponents=opponents)
+                                   opponents_information=opponents_information)
         expected_score = 2.0949
         self.assertEqual(score, expected_score)
 
     def test_with_init_kwargs(self):
         axl.seed(0)
-        opponents = [axl.Random]
-        opponent_init_kwargs = [{"p": 0}]  # Creating a defector
+        opponents_information = [utils.PlayerInfo(axl.Random, {"p": 0})]
         objective = utils.prepare_objective()
         params = DummyParams()
         score = utils.score_params(params,
                                    objective=objective,
-                                   opponent_init_kwargs=opponent_init_kwargs,
-                                   opponents=opponents)
+                                   opponents_information=opponents_information)
         expected_score = 0
         self.assertEqual(score, expected_score)
 
-        opponent_init_kwargs = [{"p": 1}]  # Creating a cooperator
+        opponents_information = [utils.PlayerInfo(axl.Random, {"p": 1})]
         objective = utils.prepare_objective()
         params = DummyParams()
         score = utils.score_params(params,
                                    objective=objective,
-                                   opponent_init_kwargs=opponent_init_kwargs,
-                                   opponents=opponents)
+                                   opponents_information=opponents_information)
         expected_score = 3.0
         self.assertEqual(score, expected_score)
 
     def test_score_with_weights(self):
         axl.seed(0)
-        opponents = axl.demo_strategies
+        opponents_information = [utils.PlayerInfo(s, {})
+                                 for s in axl.demo_strategies]
         objective = utils.prepare_objective()
         params = DummyParams()
         score = utils.score_params(params,
                                    objective=objective,
-                                   opponents=opponents,
+                                   opponents_information=opponents_information,
                                    # All weight on Coop
                                    weights=[1, 0, 0, 0, 0])
         expected_score = 3
         self.assertEqual(score, expected_score)
 
         score = utils.score_params(params,
                                    objective=objective,
-                                   opponents=opponents,
+                                   opponents_information=opponents_information,
                                    # Shared weight between Coop and Def
                                    weights=[2, 2, 0, 0, 0])
         expected_score = 1.5
         self.assertEqual(score, expected_score)
 
         score = utils.score_params(params,
                                    objective=objective,
-                                   opponents=opponents,
+                                   opponents_information=opponents_information,
                                    # Shared weight between Coop and Def
                                    weights=[2, -.5, 0, 0, 0])
         expected_score = 4.0