Implement reproducible seeding

.github/workflows/config.yml

@@ -9,7 +9,6 @@ on:
 
 jobs:
   build:
-
     runs-on: ${{ matrix.os }}
     strategy:
       max-parallel: 4
@@ -37,7 +36,6 @@ jobs:
     - name: Run tests
       run: |
         python -m pip install coverage
-        python -m pip install hypothesis==3.2
         coverage run --source=axelrod -m unittest discover
     - name: Report coverage
       run: |
@@ -51,8 +49,8 @@ jobs:
         python run_mypy.py
     - name: Check imports are sorted
       run: |
-        python -m pip install isort
-        python -m isort --check-only
+        python -m pip install "isort==4.3.21"
+        python -m isort --check-only --recursive axelrod/.
     - name: Check that all strategies are indexed
       run: |
         python run_strategy_indexer.py

README.rst

@@ -89,9 +89,8 @@ Quick Start
 The following runs a basic tournament::
 
     >>> import axelrod as axl
-    >>> axl.seed(0)  # Set a seed
     >>> players = [s() for s in axl.demo_strategies]  # Create players
-    >>> tournament = axl.Tournament(players)  # Create a tournament
+    >>> tournament = axl.Tournament(players, seed=1)  # Create a tournament
     >>> results = tournament.play()  # Play the tournament
     >>> results.ranked_names
     ['Defector', 'Grudger', 'Tit For Tat', 'Cooperator', 'Random: 0.5']

axelrod/__init__.py

@@ -3,10 +3,18 @@
 
 # The order of imports matters!
 from axelrod.version import __version__
+from axelrod.action import Action
+from axelrod.random_ import Pdf, RandomGenerator, BulkRandomGenerator
+
+# Initialize module level Random
+# This is initially seeded by the clock / OS entropy pool
+# It is not used if user specifies seeds everywhere and should only be
+# used internally by the library and in certain tests that need to set
+# its seed.
+_module_random = RandomGenerator()
+
 from axelrod.load_data_ import load_pso_tables, load_weights
 from axelrod import graph
-from axelrod.action import Action
-from axelrod.random_ import random_choice, random_flip, seed, Pdf
 from axelrod.plot import Plot
 from axelrod.game import DefaultGame, Game
 from axelrod.history import History, LimitedHistory

axelrod/_strategy_utils.py

@@ -137,7 +137,7 @@ def _calculate_scores(p1, p2, game):
     return s1, s2
 
 
-def look_ahead(player_1, player_2, game, rounds=10):
+def look_ahead(player1, player2, game, rounds=10):
     """Returns a constant action that maximizes score by looking ahead.
 
     Parameters
@@ -160,8 +160,10 @@ def look_ahead(player_1, player_2, game, rounds=10):
     possible_strategies = {C: Cooperator(), D: Defector()}
     for action, player in possible_strategies.items():
         # Instead of a deepcopy, create a new opponent and replay the history to it.
-        opponent_ = player_2.clone()
-        for h in player_1.history:
+        opponent_ = player2.clone()
+        if opponent_.classifier["stochastic"]:
+            opponent_.set_seed(player2._seed)
+        for h in player1.history:
             _limited_simulate_play(player, opponent_, h)
 
         # Now play forward with the constant strategy.

axelrod/action.py

@@ -8,7 +8,7 @@
 
 from enum import Enum
 from functools import total_ordering
-from typing import Iterable
+from typing import Iterable, Tuple
 
 
 class UnknownActionError(ValueError):
@@ -70,7 +70,7 @@ def from_char(cls, character):
         raise UnknownActionError('Character must be "C" or "D".')
 
 
-def str_to_actions(actions: str) -> tuple:
+def str_to_actions(actions: str) -> Tuple[Action, ...]:
     """Converts a string to a tuple of actions.
 
     Parameters

axelrod/classifier.py

@@ -13,9 +13,9 @@
     Union,
 )
 
+import yaml
 from axelrod.makes_use_of import makes_use_of
 from axelrod.player import Player
-import yaml
 
 ALL_CLASSIFIERS_PATH = "data/all_classifiers.yml"
 

axelrod/data/all_classifiers.yml

@@ -961,39 +961,47 @@ Meta Hunter Aggressive:
 Meta Majority:
   inspects_source: false
   long_run_time: true
-  makes_use_of: !!set {}
+  makes_use_of: !!set
+    game: null
+    length: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
   stochastic: true
 Meta Majority Finite Memory:
   inspects_source: false
   long_run_time: true
-  makes_use_of: !!set {}
+  makes_use_of: !!set
+    game: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
   stochastic: true
 Meta Majority Long Memory:
   inspects_source: false
   long_run_time: true
-  makes_use_of: !!set {}
+  makes_use_of: !!set
+    game: null
+    length: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
   stochastic: true
 Meta Majority Memory One:
   inspects_source: false
   long_run_time: true
-  makes_use_of: !!set {}
+  makes_use_of: !!set
+    game: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
   stochastic: true
 Meta Minority:
   inspects_source: false
   long_run_time: true
-  makes_use_of: !!set {}
+  makes_use_of: !!set
+    game: null
+    length: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
@@ -1011,6 +1019,7 @@ Meta Winner:
   long_run_time: true
   makes_use_of: !!set
     game: null
+    length: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
@@ -1020,6 +1029,7 @@ Meta Winner Deterministic:
   long_run_time: true
   makes_use_of: !!set
     game: null
+    length: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
@@ -1029,6 +1039,7 @@ Meta Winner Ensemble:
   long_run_time: true
   makes_use_of: !!set
     game: null
+    length: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
@@ -1047,6 +1058,7 @@ Meta Winner Long Memory:
   long_run_time: true
   makes_use_of: !!set
     game: null
+    length: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
@@ -1065,6 +1077,7 @@ Meta Winner Stochastic:
   long_run_time: true
   makes_use_of: !!set
     game: null
+    length: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
@@ -1130,40 +1143,47 @@ N Tit(s) For M Tat(s):
 NMWE Deterministic:
   inspects_source: false
   long_run_time: true
-  makes_use_of: &id001 !!set
+  makes_use_of: !!set
     game: null
+    length: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
   stochastic: true
 NMWE Finite Memory:
   inspects_source: false
   long_run_time: true
-  makes_use_of: *id001
+  makes_use_of: !!set
+    game: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
   stochastic: true
 NMWE Long Memory:
   inspects_source: false
   long_run_time: true
-  makes_use_of: *id001
+  makes_use_of: !!set
+    game: null
+    length: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
   stochastic: true
 NMWE Memory One:
   inspects_source: false
   long_run_time: true
-  makes_use_of: *id001
+  makes_use_of: !!set
+    game: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
   stochastic: true
 NMWE Stochastic:
   inspects_source: false
   long_run_time: true
-  makes_use_of: *id001
+  makes_use_of: !!set
+    game: null
+    length: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
@@ -1197,14 +1217,17 @@ Nice Meta Winner:
   long_run_time: true
   makes_use_of: !!set
     game: null
+    length: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf
   stochastic: true
 Nice Meta Winner Ensemble:
   inspects_source: false
   long_run_time: true
-  makes_use_of: *id001
+  makes_use_of: !!set
+    game: null
+    length: null
   manipulates_source: false
   manipulates_state: false
   memory_depth: .inf

axelrod/eigen.py

@@ -7,24 +7,24 @@
 
 from typing import Tuple
 
-import numpy
+import numpy as np
 
 
-def _normalise(nvec: numpy.ndarray) -> numpy.ndarray:
+def _normalise(nvec: np.ndarray) -> np.ndarray:
     """Normalises the given numpy array."""
-    with numpy.errstate(invalid="ignore"):
-        result = nvec / numpy.sqrt((nvec @ nvec))
+    with np.errstate(invalid="ignore"):
+        result = nvec / np.sqrt((nvec @ nvec))
     return result
 
 
-def _squared_error(vector_1: numpy.ndarray, vector_2: numpy.ndarray) -> float:
+def _squared_error(vector_1: np.ndarray, vector_2: np.ndarray) -> float:
     """Computes the squared error between two numpy arrays."""
     diff = vector_1 - vector_2
     s = diff @ diff
-    return numpy.sqrt(s)
+    return np.sqrt(s)
 
 
-def _power_iteration(mat: numpy.array, initial: numpy.ndarray) -> numpy.ndarray:
+def _power_iteration(mat: np.array, initial: np.ndarray) -> np.ndarray:
     """
     Generator of successive approximations.
 
@@ -33,7 +33,7 @@ def _power_iteration(mat: numpy.array, initial: numpy.ndarray) -> numpy.ndarray:
     mat: numpy.array
         The matrix to use for multiplication iteration
     initial: numpy.array, None
-        The initial state. Will be set to numpy.array([1, 1, ...]) if None
+        The initial state. Will be set to np.array([1, 1, ...]) if None
 
     Yields
     ------
@@ -42,13 +42,13 @@ def _power_iteration(mat: numpy.array, initial: numpy.ndarray) -> numpy.ndarray:
 
     vec = initial
     while True:
-        vec = _normalise(numpy.dot(mat, vec))
+        vec = _normalise(np.dot(mat, vec))
         yield vec
 
 
 def principal_eigenvector(
-    mat: numpy.array, maximum_iterations=1000, max_error=1e-3
-) -> Tuple[numpy.ndarray, float]:
+    mat: np.array, maximum_iterations=1000, max_error=1e-3
+) -> Tuple[np.ndarray, float]:
     """
     Computes the (normalised) principal eigenvector of the given matrix.
 
@@ -66,12 +66,12 @@ def principal_eigenvector(
     ndarray
         Eigenvector estimate for the input matrix
     float
-        Eigenvalue corresonding to the returned eigenvector
+        Eigenvalue corresponding to the returned eigenvector
     """
 
-    mat_ = numpy.array(mat)
+    mat_ = np.array(mat)
     size = mat_.shape[0]
-    initial = numpy.ones(size)
+    initial = np.ones(size)
 
     # Power iteration
     if not maximum_iterations: