A few minor updates following some additional review

Author: marcharper

axelrod/evolvable_player.py

@@ -35,7 +35,7 @@ def overwrite_init_kwargs(self, **kwargs):
     def create_new(self, **kwargs):
         """Creates a new variant with parameters overwritten by kwargs. This differs from
         cloning the Player because it propagates a seed forward, and is intended to be
-        used in my the mutation and crossover methods."""
+        used by the mutation and crossover methods."""
         init_kwargs = self.init_kwargs.copy()
         init_kwargs.update(kwargs)
         # Propagate seed forward for reproducibility.

axelrod/player.py

@@ -118,8 +118,7 @@ def _post_init(self):
         pass
 
     def _post_transform(self):
-        """Overwrite this function if you need to do a post-transform, post-init
-        modification."""
+        """Handles post transform tasks such as further reclassifying."""
         # Reclassify strategy post __init__, if needed.
         for (reclassifier, args, kwargs) in self._reclassifiers:
             self.classifier = reclassifier(self.classifier, *args, **kwargs)

axelrod/random_.py

@@ -84,8 +84,7 @@ def random_flip(self, action: Action, threshold: float) -> Action:
         return action
 
     def randrange(self, a: int, b: int) -> int:
-        """Python 2 / 3 compatible randrange. Returns a random integer uniformly
-        between a and b (inclusive)"""
+        """Returns a random integer uniformly between a and b: [a, b)."""
         c = b - a
         r = c * self.random()
         return a + int(r)

axelrod/strategies/finite_state_machines.py

@@ -114,7 +114,6 @@ def __init__(
         initial_state: int = 1,
         initial_action: Action = C
     ) -> None:
-        # super().__init__()
         Player.__init__(self)
         self.initial_state = initial_state
         self.initial_action = initial_action

axelrod/strategies/meta.py

@@ -104,7 +104,7 @@ def update_histories(self, coplay):
             # As a sanity check, look for at least one reclassifier, otherwise
             # this try-except clause could hide a bug.
             if len(self._reclassifiers) == 0:
-                raise TypeError("MetaClass update_histories issue, expected a transformer.")
+                raise TypeError("MetaClass update_histories issue, expected a reclassifier.")
             # Otherwise just update with C always, so at least the histories have the
             # expected length.
             for player in self.team:
@@ -223,9 +223,6 @@ class MetaWinnerEnsemble(MetaWinner):
 
     name = "Meta Winner Ensemble"
 
-    def __init__(self, team=None):
-        super().__init__(team=team)
-
     def _post_init(self):
         super()._post_init()
         team = list(t.__class__ for t in self.team)

axelrod/strategies/rand.py

@@ -44,6 +44,7 @@ def strategy(self, opponent: Player) -> Action:
         return self._random.random_choice(self.p)
 
     def _post_init(self):
+        super()._post_init()
         if self.p in [0, 1]:
             self.classifier["stochastic"] = False
         # Avoid calls to _random, if strategy is deterministic

axelrod/tests/unit/test_tournament.py

@@ -735,22 +735,25 @@ def test_write_to_csv_without_results(self):
     @settings(max_examples=5, deadline=None)
     def test_seeding_equality(self, seed):
         """Tests that a tournament with a given seed will return the
-        same results each time."""
+        same results each time. This specifically checks when running using
+        multiple cores so as to confirm that
+        https://github.com/Axelrod-Python/Axelrod/issues/1277
+        is fixed."""
         rng = axl.RandomGenerator(seed=seed)
         players = [axl.Random(rng.random()) for _ in range(8)]
         tournament1 = axl.Tournament(
             name=self.test_name,
             players=players,
             game=self.game,
-            turns=3,
+            turns=10,
             repetitions=100,
             seed=seed
         )
         tournament2 = axl.Tournament(
             name=self.test_name,
             players=players,
             game=self.game,
-            turns=3,
+            turns=10,
             repetitions=100,
             seed=seed
         )