Merge pull request #609 from Axelrod-Python/538

Add match_attributes to match class

Author: drvinceknight

axelrod/match.py

@@ -16,35 +16,51 @@ def is_stochastic(players, noise):
 class Match(object):
 
     def __init__(self, players, turns, game=None, deterministic_cache=None,
-                 noise=0):
+                 noise=0, match_attributes=None):
         """
         Parameters
         ----------
         players : tuple
             A pair of axelrod.Player objects
         turns : integer
-                The number of turns per match
+            The number of turns per match
         game : axelrod.Game
             The game object used to score the match
         deterministic_cache : dictionary
             A cache of resulting actions for deterministic matches
         noise : float
             The probability that a player's intended action should be flipped
+        match_attributes : dict
+            Mapping attribute names to values which should be passed to players.
+            The default is to use the correct values for turns, game and noise
+            but these can be overidden if desired.
         """
         self.result = []
         self.turns = turns
         self._cache_key = (players[0].__class__, players[1].__class__, turns)
+        self.noise = noise
+
         if game is None:
             self.game = Game()
         else:
             self.game = game
-        self.noise = noise
-        self.players = list(players)
+
         if deterministic_cache is None:
             self._cache = DeterministicCache()
         else:
             self._cache = deterministic_cache
 
+        if match_attributes is None:
+            self.match_attributes = {
+                'length': self.turns,
+                'game': self.game,
+                'noise': self.noise
+            }
+        else:
+            self.match_attributes = match_attributes
+
+        self.players = list(players)
+
     @property
     def players(self):
         return self._players
@@ -54,10 +70,7 @@ def players(self, players):
         """Ensure that players are passed the match attributes"""
         newplayers = []
         for player in players:
-            player.set_match_attributes(
-                length=self.turns,
-                game=self.game,
-                noise=self.noise)
+            player.set_match_attributes(**self.match_attributes)
             newplayers.append(player)
         self._players = newplayers
 

axelrod/match_generator.py

@@ -122,7 +122,9 @@ def build_single_match_params(self):
         """
         Creates a single set of match parameters.
         """
-        return (self.sample_length(self.prob_end), self.game, None, self.noise)
+        return (
+            self.sample_length(self.prob_end), self.game, None, self.noise,
+            {'length': float('inf'), 'game': self.game, 'noise': self.noise})
 
     def sample_length(self, prob_end):
         """

axelrod/tests/unit/test_match.py

@@ -32,6 +32,19 @@ def test_init(self, turns, game):
         self.assertEqual(match.noise, 0)
         self.assertEqual(match.game.RPST(), game.RPST())
 
+    @given(turns=integers(min_value=1, max_value=200), game=games())
+    @example(turns=5, game=axelrod.DefaultGame)
+    def test_non_default_attributes(self, turns, game):
+        p1, p2 = axelrod.Cooperator(), axelrod.Cooperator()
+        match_attributes = {
+            'length': 500,
+            'game': game,
+            'noise': 0.5
+        }
+        match = axelrod.Match((p1, p2), turns, game=game, match_attributes=match_attributes)
+        self.assertEqual(match.players[0].match_attributes['length'], 500)
+        self.assertEqual(match.players[0].match_attributes['noise'], 0.5)
+
     @given(turns=integers(min_value=1, max_value=200))
     @example(turns=5)
     def test_len(self, turns):

axelrod/tests/unit/test_match_generator.py

@@ -115,6 +115,7 @@ def test_len(self):
         self.assertEqual(len(rr), len(list(rr.build_match_chunks())))
         self.assertEqual(rr.estimated_size(), len(rr) * turns * repetitions)
 
+
 class TestProbEndRoundRobin(unittest.TestCase):
 
     @classmethod
@@ -178,6 +179,7 @@ def test_build_single_match_params(self, prob_end, rm):
         self.assertIsInstance(match, axelrod.Match)
         self.assertLess(len(match), float('inf'))
         self.assertGreater(len(match), 0)
+        self.assertEqual(match.players[0].match_attributes['length'], float('inf'))
 
         # Testing with noise
         rr = axelrod.ProbEndRoundRobinMatches(
@@ -200,9 +202,8 @@ def test_build_single_match_params(self, prob_end, rm):
 
     @given(prob_end=floats(min_value=.1, max_value=1), rm=random_module())
     def test_len(self, prob_end, rm):
-        turns = 5
         repetitions = 10
-        rr = axelrod.ProbEndRoundRobinMatches(self.players, prob_end, game=None,
-                                       repetitions=repetitions)
+        rr = axelrod.ProbEndRoundRobinMatches(
+            self.players, prob_end, game=None, repetitions=repetitions)
         self.assertEqual(len(rr), len(list(rr.build_match_chunks())))
         self.assertAlmostEqual(rr.estimated_size(), len(rr) * 1. / prob_end * repetitions)