Updates following Nik's initial review

Author: marcharper

axelrod/player.py

@@ -190,8 +190,8 @@ def set_seed(self, seed):
         """Set a random seed for the player's random number generator."""
         if seed is None:
             warnings.warn(
-                "Initializing player with seed from Axelrod module random number generator."
-                " Results may not be seed reproducible.")
+                "Initializing player with seed from Axelrod module random number generator. "
+                "Results may not be seed reproducible.")
             self._seed = _module_random.random_seed_int()
         else:
             self._seed = seed

axelrod/random_.py

@@ -1,21 +1,23 @@
+from typing import Optional
 import numpy as np
 from axelrod.action import Action
 from numpy.random import RandomState
 
+
 C, D = Action.C, Action.D
 
 
 class RandomGenerator(object):
     """Container around a random number generator.
     Enables reproducibility of player behavior, matches,
     and tournaments."""
-    def __init__(self, seed=None):
+    def __init__(self, seed: Optional[int] = None):
         # _random is the internal object that generators random values
         self._random = RandomState()
         self.original_seed = seed
         self.seed(seed)
 
-    def seed(self, seed_):
+    def seed(self, seed_: Optional[int] = None):
         """Sets a seed"""
         self._random.seed(seed_)
 
@@ -25,7 +27,7 @@ def random(self, *args, **kwargs):
     def randint(self, *args, **kwargs):
         return self._random.randint(*args, **kwargs)
 
-    def random_seed_int(self):
+    def random_seed_int(self) -> int:
         return self.randint(low=0, high=2**32-1, dtype="uint64")
 
     def choice(self, *args, **kwargs):
@@ -117,7 +119,7 @@ class BulkRandomGenerator(object):
     """Bulk generator of random integers for tournament seeding and
     reproducibility. Bulk generation of random values is more efficient.
     Use this class like a generator."""
-    def __init__(self, seed=None, batch_size=1000):
+    def __init__(self, seed=None, batch_size:int = 1000):
         self._random_generator = RandomState()
         self._random_generator.seed(seed)
         self._ints = None

axelrod/tests/strategies/test_worse_and_worse.py

@@ -22,13 +22,12 @@ class TestWorseAndWorse(TestPlayer):
     }
 
     def test_strategy(self):
-        """Test that the strategy gives expected behaviour."""
-        # 6 Rounds Cooperate given seed
+        # For given seed cooperates for 6 rounds and then defects for a round
         actions = [(C, C)] * 6 + [(D, C)] + [(C, C)] * 3
         self.versus_test(axl.Cooperator(), expected_actions=actions, seed=144)
 
     def test_strategy2(self):
-        # 6 Rounds Cooperate and Defect no matter opponent
+        #  Test that behaviour does not depend on opponent
         actions = [(C, D)] * 6 + [(D, D)] + [(C, D)] * 3
         self.versus_test(axl.Defector(), expected_actions=actions, seed=144)
 

docs/tutorials/getting_started/running_axelrods_first_tournament.rst

@@ -71,9 +71,10 @@ The results object contains the ranked names::
     First by Anonymous
     Random: 0.5
 
-We see that `TitForTat` does not in fact win this tournament. `TitForTat` typically does not
-win, possibly because our implementations differ from the original strategies as their code
-is not available.
+
+We see that `TitForTat` does not win. In fact `TitForTat` typically does not
+win this tournament, possibly because our implementations differ from the original
+strategies as their code is not available.
 
 We can plot the reported rank (from [Axelrod1980]_) versus the reproduced one::