Merge pull request #975 from Axelrod-Python/885

meatballs · web-flow · commit 12efc3490812 · 2017-04-19T10:03:57.000+01:00
Implement an eq method for players
diff --git a/axelrod/player.py b/axelrod/player.py
@@ -3,6 +3,9 @@
 import random
 import copy
 import inspect
+import types
+import numpy as np
+import itertools
 
 from axelrod.actions import Actions, flip_action, Action
 from .game import DefaultGame
@@ -122,6 +125,57 @@ def __init__(self):
         self.state_distribution = defaultdict(int)
         self.set_match_attributes()
 
+
+    def __eq__(self, other):
+        """
+        Test if two players are equal.
+        """
+        if self.__repr__() != other.__repr__():
+            return False
+        for attribute in set(list(self.__dict__.keys()) +
+                             list(other.__dict__.keys())):
+
+            value = getattr(self, attribute, None)
+            other_value = getattr(other, attribute, None)
+
+            if isinstance(value, np.ndarray):
+                if not (np.array_equal(value, other_value)):
+                    return False
+
+            elif isinstance(value, types.GeneratorType) or \
+                 isinstance(value, itertools.cycle):
+
+                # Split the original generator so it is not touched
+                generator, original_value = itertools.tee(value)
+                other_generator, original_other_value = itertools.tee(other_value)
+
+
+                if isinstance(value, types.GeneratorType):
+                    setattr(self, attribute,
+                            (ele for ele in original_value))
+                    setattr(other, attribute,
+                            (ele for ele in original_other_value))
+                else:
+                    setattr(self, attribute,
+                            itertools.cycle(original_value))
+                    setattr(other, attribute,
+                            itertools.cycle(original_other_value))
+
+                if not (all(next(generator) == next(other_generator)
+                        for _ in range(200))):
+                    return False
+
+            # Code for a strange edge case where each strategy points at each
+            # other
+            elif (value is other and other_value is self):
+                    pass
+
+            else:
+                if value != other_value:
+                    return False
+        return True
+
+
     def receive_match_attributes(self):
         # Overwrite this function if your strategy needs
         # to make use of match_attributes such as
diff --git a/axelrod/strategies/qlearner.py b/axelrod/strategies/qlearner.py
@@ -48,8 +48,8 @@ def __init__(self) -> None:
         # for any subclasses that do not override methods using random calls.
         self.classifier['stochastic'] = True
 
-        self.prev_action = random_choice()
-        self.original_prev_action = self.prev_action
+        self.prev_action = None # type: Action
+        self.original_prev_action = None # type: Action
         self.history = [] # type: List[Action]
         self.score = 0
         self.Qs = OrderedDict({'':  OrderedDict(zip([C, D], [0, 0]))})
@@ -62,6 +62,9 @@ def receive_match_attributes(self):
 
     def strategy(self, opponent: Player) -> Action:
         """Runs a qlearn algorithm while the tournament is running."""
+        if len(self.history) == 0:
+            self.prev_action = random_choice()
+            self.original_prev_action = self.prev_action
         state = self.find_state(opponent)
         reward = self.find_reward(opponent)
         if state not in self.Qs:
@@ -118,7 +121,8 @@ def reset(self):
         self.Qs = {'': {C: 0, D: 0}}
         self.Vs = {'': 0}
         self.prev_state = ''
-        self.prev_action = self.original_prev_action
+        self.prev_action = None
+        self.original_prev_action = None
 
 
 class ArrogantQLearner(RiskyQLearner):
diff --git a/axelrod/strategies/titfortat.py b/axelrod/strategies/titfortat.py
@@ -425,7 +425,11 @@ class ContriteTitForTat(Player):
         'manipulates_source': False,
         'manipulates_state': False
     }
-    contrite = False
+
+    def __init__(self):
+        super().__init__()
+        self.contrite = False
+        self._recorded_history = []
 
     def strategy(self, opponent: Player) -> Action:
 
diff --git a/axelrod/tests/strategies/test_calculator.py b/axelrod/tests/strategies/test_calculator.py
@@ -81,11 +81,6 @@ def test_edge_case_calculator_ignores_cycles_gt_len_ten(self):
             axelrod.MockPlayer(actions=opponent_actions),
             expected_actions=uses_tit_for_tat_after_twenty_rounds, seed=seed)
 
-    def attribute_equality_test(self, player, clone):
-        """Overwrite the default test to check Joss instance"""
-        self.assertIsInstance(player.joss_instance, axelrod.Joss)
-        self.assertIsInstance(clone.joss_instance, axelrod.Joss)
-
     def test_get_joss_strategy_actions(self):
         opponent = [C, D, D, C, C]
 
diff --git a/axelrod/tests/strategies/test_memorytwo.py b/axelrod/tests/strategies/test_memorytwo.py
@@ -41,16 +41,3 @@ def test_strategy(self):
         # ALLD forever if all D twice
         self.responses_test([D] * 10, [C, D, D, D, D, D], [D, D, D, D, D, D])
         self.responses_test([D] * 9, [C] + [D] * 5 + [C] * 4, [D] * 6 + [C] * 4)
-
-    def attribute_equality_test(self, player, clone):
-        """Overwrite specific test to be able to test self.players"""
-        for p in [player, clone]:
-            self.assertEqual(p.play_as, "TFT")
-            self.assertEqual(p.shift_counter, 3)
-            self.assertEqual(p.alld_counter, 0)
-
-        for key, value in [("TFT", axelrod.TitForTat),
-                           ("TFTT", axelrod.TitFor2Tats),
-                           ("ALLD", axelrod.Defector)]:
-            self.assertEqual(p.players[key].history, [])
-            self.assertIsInstance(p.players[key], value)
diff --git a/axelrod/tests/strategies/test_meta.py b/axelrod/tests/strategies/test_meta.py
@@ -46,16 +46,6 @@ def classifier_test(self, expected_class_classifier=None):
                              msg="%s - Behaviour: %s != Expected Behaviour: %s" %
                                  (key, player.classifier[key], classifier[key]))
 
-    def attribute_equality_test(self, player, clone):
-        """Overwriting this specific method to check team."""
-        for p1, p2 in zip(player.team, clone.team):
-            self.assertEqual(len(p1.history), 0)
-            self.assertEqual(len(p2.history), 0)
-
-        team_player_names = [p.__repr__() for p in player.team]
-        team_clone_names = [p.__repr__() for p in clone.team]
-        self.assertEqual(team_player_names, team_clone_names)
-
     def test_repr(self):
         player = self.player()
         team_size = len(player.team)
diff --git a/axelrod/tests/strategies/test_player.py b/axelrod/tests/strategies/test_player.py
@@ -9,6 +9,8 @@
 from axelrod import DefaultGame, MockPlayer, Player, simulate_play
 from axelrod.player import get_state_distribution_from_history
 
+from hypothesis import given
+from axelrod.tests.property import strategy_lists
 
 C, D = axelrod.Actions.C, axelrod.Actions.D
 
@@ -150,6 +152,148 @@ def test_clone(self):
             self.assertEqual(len(player1.history), turns)
             self.assertEqual(player1.history, player2.history)
 
+    def test_equality(self):
+        """Test the equality method for some bespoke cases"""
+        # Check repr
+        p1 = axelrod.Cooperator()
+        p2 = axelrod.Cooperator()
+        self.assertEqual(p1, p2)
+        p1.__repr__ = lambda: "John Nash"
+        self.assertNotEqual(p1, p2)
+
+        # Check attributes
+        p1 = axelrod.Cooperator()
+        p2 = axelrod.Cooperator()
+        p1.test = "29"
+        self.assertNotEqual(p1, p2)
+
+        p1 = axelrod.Cooperator()
+        p2 = axelrod.Cooperator()
+        p2.test = "29"
+        self.assertNotEqual(p1, p2)
+
+        p1.test = "29"
+        self.assertEqual(p1, p2)
+
+        # Check that attributes of both players are tested.
+        p1.another_attribute = [1, 2, 3]
+        self.assertNotEqual(p1, p2)
+        p2.another_attribute = [1, 2, 3]
+        self.assertEqual(p1, p2)
+
+        p2.another_attribute_2 = {1: 2}
+        self.assertNotEqual(p1, p2)
+        p1.another_attribute_2 = {1: 2}
+        self.assertEqual(p1, p2)
+
+    def test_equality_for_numpy_array(self):
+        """Check numpy array attribute (a special case)"""
+        p1 = axelrod.Cooperator()
+        p2 = axelrod.Cooperator()
+
+        p1.array = np.array([0, 1])
+        p2.array = np.array([0, 1])
+        self.assertEqual(p1, p2)
+
+        p2.array = np.array([1, 0])
+        self.assertNotEqual(p1, p2)
+
+    def test_equality_for_generator(self):
+        """Test equality works with generator attribute and that the generator
+        attribute is not altered during checking of equality"""
+        p1 = axelrod.Cooperator()
+        p2 = axelrod.Cooperator()
+
+        # Check that players are equal with generator
+        p1.generator = (i for i in range(10))
+        p2.generator = (i for i in range(10))
+        self.assertEqual(p1, p2)
+
+        # Check state of one generator (ensure it hasn't changed)
+        n = next(p2.generator)
+        self.assertEqual(n, 0)
+
+        # Players are no longer equal (one generator has changed)
+        self.assertNotEqual(p1, p2)
+
+        # Check that internal generator object has not been changed for either
+        # player after latest equal check.
+        self.assertEqual(list(p1.generator), list(range(10)))
+        self.assertEqual(list(p2.generator), list(range(1, 10)))
+
+        # Check that type is generator
+        self.assertIsInstance(p2.generator, types.GeneratorType)
+
+    def test_equality_for_cycle(self):
+        """Test equality works with cycle attribute and that the cycle attribute
+        is not altered during checking of equality"""
+        # Check cycle attribute (a special case)
+        p1 = axelrod.Cooperator()
+        p2 = axelrod.Cooperator()
+
+        # Check that players are equal with cycle
+        p1.cycle = itertools.cycle(range(10))
+        p2.cycle = itertools.cycle(range(10))
+        self.assertEqual(p1, p2)
+
+        # Check state of one generator (ensure it hasn't changed)
+        n = next(p2.cycle)
+        self.assertEqual(n, 0)
+
+        # Players are no longer equal (one generator has changed)
+        self.assertNotEqual(p1, p2)
+
+        # Check that internal cycle object has not been changed for either
+        # player after latest not equal check.
+        self.assertEqual(next(p1.cycle), 0)
+        self.assertEqual(next(p2.cycle), 1)
+
+        # Check that type is cycle
+        self.assertIsInstance(p2.cycle, itertools.cycle)
+
+    def test_equality_on_init(self):
+        """Test instances of all strategies are equal on init"""
+        for s in axelrod.strategies:
+            p1, p2 = s(), s()
+            # Check three times (so testing equality doesn't change anything)
+            self.assertEqual(p1, p2)
+            self.assertEqual(p1, p2)
+            self.assertEqual(p1, p2)
+
+    def test_equality_with_player_as_attributes(self):
+        """Test for a strange edge case where players have pointers to each
+        other"""
+        p1 = axelrod.Cooperator()
+        p2 = axelrod.Cooperator()
+
+        # If pointing at each other
+        p1.player = p2
+        p2.player = p1
+        self.assertEqual(p1, p2)
+
+        # Still checking other attributes.
+        p1.test_attribute = "29"
+        self.assertNotEqual(p1, p2)
+
+        # If pointing at same strategy instances
+        p1.player = axelrod.Cooperator()
+        p2.player = axelrod.Cooperator()
+        p2.test_attribute = "29"
+        self.assertEqual(p1, p2)
+
+
+        # If pointing at different strategy instances
+        p1.player = axelrod.Cooperator()
+        p2.player = axelrod.Defector()
+        self.assertNotEqual(p1, p2)
+
+        # If different strategies pointing at same strategy instances
+        p3 = axelrod.Defector()
+        p1.player = axelrod.Cooperator()
+        p3.player = axelrod.Cooperator()
+        self.assertNotEqual(p1, p3)
+
+
     def test_init_params(self):
         """Tests player correct parameters signature detection."""
         self.assertEqual(self.player.init_params(), {})
@@ -285,41 +429,14 @@ def test_reset_history_and_attributes(self):
             player.play(opponent)
 
         player.reset()
-        self.assertEqual(len(player.history), 0)
-        self.assertEqual(player.cooperations, 0)
-        self.assertEqual(player.defections, 0)
-        self.assertEqual(player.state_distribution, dict())
-
-        self.attribute_equality_test(player, clone)
+        self.assertEqual(player, clone)
 
     def test_reset_clone(self):
         """Make sure history resetting with cloning works correctly, regardless
         if self.test_reset() is overwritten."""
         player = self.player()
         clone = player.clone()
-        self.attribute_equality_test(player, clone)
-
-    def attribute_equality_test(self, player, clone):
-        """A separate method to test equality of attributes. This method can be
-        overwritten in certain cases.
-
-        This method checks that all the attributes of `player` and `clone` are
-        the same which is used in the test of the cloning and the resetting.
-        """
-
-        for attribute, reset_value in player.__dict__.items():
-            original_value = getattr(clone, attribute)
-
-            if isinstance(reset_value, np.ndarray):
-                self.assertTrue(np.array_equal(reset_value, original_value),
-                                msg=attribute)
-
-            elif isinstance(reset_value, types.GeneratorType) or isinstance(reset_value, itertools.cycle):
-                for _ in range(10):
-                    self.assertEqual(next(reset_value),
-                                     next(original_value), msg=attribute)
-            else:
-                self.assertEqual(reset_value, original_value, msg=attribute)
+        self.assertEqual(player, clone)
 
     def test_clone(self):
         # Test that the cloned player produces identical play
diff --git a/axelrod/tests/strategies/test_qlearner.py b/axelrod/tests/strategies/test_qlearner.py
@@ -70,18 +70,6 @@ def test_strategy(self):
         p2 = axelrod.Cooperator()
         test_responses(self, p1, p2, [C, D, C, C, D, C, C])
 
-    def test_reset_method(self):
-        """Test the reset method."""
-        P1 = axelrod.RiskyQLearner()
-        P1.Qs = {'': {C: 0, D: -0.9}, '0.0': {C: 0, D: 0}}
-        P1.Vs = {'': 0, '0.0': 0}
-        P1.history = [C, D, D, D]
-        P1.prev_state = C
-        P1.reset()
-        self.assertEqual(P1.prev_state, '')
-        self.assertEqual(P1.Vs, {'': 0})
-        self.assertEqual(P1.Qs, {'': {C: 0, D: 0}})
-
 
 class TestArrogantQLearner(TestPlayer):
 
diff --git a/axelrod/tests/strategies/test_titfortat.py b/axelrod/tests/strategies/test_titfortat.py
diff --git a/axelrod/tests/unit/test_match_generator.py b/axelrod/tests/unit/test_match_generator.py
diff --git a/docs/tutorials/advanced/index.rst b/docs/tutorials/advanced/index.rst
diff --git a/docs/tutorials/advanced/player_equality.rst b/docs/tutorials/advanced/player_equality.rst
