Undo or remove various commented lines

Author: marcharper

axelrod/evolvable_player.py

@@ -36,24 +36,6 @@ def create_new(self, **kwargs):
         init_kwargs.update(kwargs)
         return self.__class__(**init_kwargs)
 
-    # def clone(self):
-    #     """Clones the player without history, reapplying configuration
-    #     parameters as necessary.
-    #
-    #     We're overriding Player.clone to also propagate the seed because EvolvablePlayers
-    #     currently randomize themselves on initialization.
-    #     """
-    #
-    #     # You may be tempted to re-implement using the `copy` module
-    #     # Note that this would require a deepcopy in some cases and there may
-    #     # be significant changes required throughout the library.
-    #     # Consider overriding in special cases only if necessary
-    #     cls = self.__class__
-    #     new_player = cls(**self.init_kwargs, seed=self._seed)
-    #     new_player.match_attributes = copy.copy(self.match_attributes)
-    #     # new_player.set_seed(self._seed)
-    #     return new_player
-
     # Serialization and deserialization. You may overwrite to obtain more human readable serializations
     # but you must overwrite both.
 

axelrod/match.py

@@ -178,9 +178,9 @@ def play(self):
                 if self.reset:
                     p.reset()
                 p.set_match_attributes(**self.match_attributes)
-                # if p.classifier["stochastic"]:
                 # Generate a random seed for the player
                 # TODO: Seeds only for stochastic players
+                # if p.classifier["stochastic"]:
                 p.set_seed(self._random.random_seed_int())
             result = []
             for _ in range(turns):

axelrod/player.py

@@ -28,18 +28,6 @@ def __new__(cls, *args, **kwargs):
         """Caches arguments for Player cloning."""
         obj = super().__new__(cls)
         obj.init_kwargs = cls.init_params(*args, **kwargs)
-        # # Set up random seed from the module level random seed
-        # # in case the user doesn't specific one later.
-        # need_seed = False
-        # try:
-        #     seed = kwargs["seed"]
-        #     if seed is None:
-        #         need_seed = True
-        # except KeyError:
-        #     need_seed = True
-        # if need_seed:
-        #     seed = _module_random.randint(0, 2**32-1)
-        # obj._seed = seed
         return obj
 
     @classmethod
@@ -163,10 +151,6 @@ def strategy(self, opponent):
         """This is a placeholder strategy."""
         raise NotImplementedError()
 
-    # def play(self, opponent, noise=0):
-    #     """This pits two players against each other."""
-    #     return simultaneous_play(self, opponent, noise)
-
     def clone(self):
         """Clones the player without history, reapplying configuration
         parameters as necessary."""
@@ -190,7 +174,6 @@ def reset(self):
         """
         # This also resets the history.
         self.__init__(**self.init_kwargs)
-        # self.set_seed(self._seed)
 
     def update_history(self, play, coplay):
         self.history.append(play, coplay)

axelrod/random_.py

@@ -11,7 +11,6 @@ class RandomGenerator(object):
     Enables reproducibility of player behavior, matches,
     and tournaments."""
     def __init__(self, seed=None):
-        # self.random = random.Random()
         # _random is the internal object that generators random values
         self._random = RandomState()
         self.original_seed = seed

axelrod/tests/strategies/test_geller.py

@@ -66,9 +66,9 @@ def test_returns_foil_inspection_strategy_of_opponent(self):
 
         self.versus_test(axl.Darwin(), expected_actions=[(C, C), (C, C), (C, C)], seed=3)
 
-        # self.versus_test(
-        #     axelrod.MindReader(), expected_actions=[(D, D), (D, D), (D, D)], seed=1
-        # )
+        self.versus_test(
+            axelrod.MindReader(), expected_actions=[(D, D), (D, D), (D, D)], seed=1
+        )
 
 
 class TestGellerCooperator(TestGeller):

axelrod/tests/strategies/test_titfortat.py

@@ -708,9 +708,9 @@ class TestContriteTitForTat(TestPlayer):
     ]
 
     def test_init(self):
-        ctft = self.player()
-        self.assertFalse(ctft.contrite, False)
-        self.assertEqual(ctft._recorded_history, [])
+        player = self.player()
+        self.assertFalse(player.contrite, False)
+        self.assertEqual(player._recorded_history, [])
 
     @given(
         strategies=strategy_lists(strategies=deterministic_strategies, max_size=1),
@@ -719,10 +719,10 @@ def test_init(self):
     @settings(deadline=None)
     def test_is_tit_for_tat_with_no_noise(self, strategies, turns):
         tft = axl.TitForTat()
-        ctft = self.player()
+        player = self.player()
         opponent = strategies[0]()
         m1 = axl.Match((tft, opponent), turns)
-        m2 = axl.Match((ctft, opponent), turns)
+        m2 = axl.Match((player, opponent), turns)
         self.assertEqual(m1.play(), m2.play())
 
     def test_strategy_with_noise(self):
@@ -739,26 +739,26 @@ def test_strategy_with_noise(self):
         self.assertEqual(player._recorded_history, [C])
         self.assertEqual(opponent.history, [C])
 
-        # # After noise: is contrite
-        # ctft.play(opponent)
-        # self.assertEqual(ctft.history, [D, C])
-        # self.assertEqual(ctft._recorded_history, [C, C])
-        # self.assertEqual(opponent.history, [C, D])
-        # self.assertTrue(ctft.contrite)
-        #
-        # # Cooperates and no longer contrite
-        # ctft.play(opponent)
-        # self.assertEqual(ctft.history, [D, C, C])
-        # self.assertEqual(ctft._recorded_history, [C, C, C])
-        # self.assertEqual(opponent.history, [C, D, D])
-        # self.assertFalse(ctft.contrite)
-        #
-        # # Goes back to playing tft
-        # ctft.play(opponent)
-        # self.assertEqual(ctft.history, [D, C, C, D])
-        # self.assertEqual(ctft._recorded_history, [C, C, C, D])
-        # self.assertEqual(opponent.history, [C, D, D, D])
-        # self.assertFalse(ctft.contrite)
+        # After noise: is contrite
+        player.play(opponent)
+        self.assertEqual(player.history, [D, C])
+        self.assertEqual(player._recorded_history, [C, C])
+        self.assertEqual(opponent.history, [C, D])
+        self.assertTrue(player.contrite)
+
+        # Cooperates and no longer contrite
+        player.play(opponent)
+        self.assertEqual(player.history, [D, C, C])
+        self.assertEqual(player._recorded_history, [C, C, C])
+        self.assertEqual(opponent.history, [C, D, D])
+        self.assertFalse(player.contrite)
+
+        # Goes back to playing tft
+        player.play(opponent)
+        self.assertEqual(player.history, [D, C, C, D])
+        self.assertEqual(player._recorded_history, [C, C, C, D])
+        self.assertEqual(opponent.history, [C, D, D, D])
+        self.assertFalse(player.contrite)
 
 
 class TestAdaptiveTitForTat(TestPlayer):