Substitution tests for evolvable players

Author: marcharper

axelrod/moran.py

@@ -1,8 +1,7 @@
 """Implementation of the Moran process on Graphs."""
 
-from collections import Counter
 import random
-from random import randrange
+from collections import Counter
 from typing import Callable, List, Optional, Set, Tuple
 
 import matplotlib.pyplot as plt
@@ -12,6 +11,7 @@
 from .deterministic_cache import DeterministicCache
 from .graph import Graph, complete_graph
 from .match import Match
+from .random_ import randrange
 
 
 def fitness_proportionate_selection(

axelrod/random_.py

@@ -63,12 +63,12 @@ def random_flip(action: Action, threshold: float) -> Action:
     return action
 
 
-# def randrange(a: int, b: int) -> int:
-#     """Python 2 / 3 compatible randrange. Returns a random integer uniformly
-#     between a and b (inclusive)"""
-#     c = b - a
-#     r = c * random.random()
-#     return a + int(r)
+def randrange(a: int, b: int) -> int:
+    """Python 2 / 3 compatible randrange. Returns a random integer uniformly
+    between a and b (inclusive)"""
+    c = b - a
+    r = c * random.random()
+    return a + int(r)
 
 
 def random_vector(size):

axelrod/tests/strategies/test_ann.py

@@ -6,7 +6,7 @@
 from axelrod.load_data_ import load_weights
 from axelrod.strategies.ann import split_weights
 from .test_player import TestPlayer
-from .test_evolvable_player import TestEvolvablePlayer
+from .test_evolvable_player import PartialClass, TestEvolvablePlayer
 
 
 C, D = axelrod.Action.C, axelrod.Action.D
@@ -23,43 +23,6 @@ def test_split_weights(self):
     split_weights([0] * 12, 10, 1)
 
 
-class TestEvolvableANN(unittest.TestCase):
-
-    player_class = axelrod.EvolvableANN
-
-    def test_normalized_parameters(self):
-        # Must specify at least one of cycle or cycle_length
-        self.assertRaises(
-            InsufficientParametersError,
-            self.player_class._normalize_parameters
-        )
-        self.assertRaises(
-            InsufficientParametersError,
-            self.player_class._normalize_parameters,
-            weights=nn_weights["Evolved ANN 5"][2]
-        )
-
-
-class TestEvolvableANN2(TestEvolvablePlayer):
-    name = "EvolvableANN"
-    player_class = axelrod.EvolvableANN
-    parent_class = axelrod.ANN
-    parent_kwargs = ["num_features", "num_hidden", "weights"]
-    init_parameters = {"num_features": 17, "num_hidden": 8}
-
-
-class TestEvolvableANN3(TestEvolvablePlayer):
-    name = "EvolvableANN"
-    player_class = axelrod.EvolvableANN
-    parent_class = axelrod.ANN
-    parent_kwargs = ["num_features", "num_hidden", "weights"]
-    init_parameters = {
-        "num_features": nn_weights["Evolved ANN 5"][0],
-        "num_hidden": nn_weights["Evolved ANN 5"][1],
-        "weights": nn_weights["Evolved ANN 5"][2]
-    }
-
-
 class TestEvolvedANN(TestPlayer):
 
     name = "Evolved ANN"
@@ -127,3 +90,59 @@ def test_strategy(self):
 
         actions = [(C, D), (D, D), (D, D)]
         self.versus_test(axelrod.Defector(), expected_actions=actions)
+
+
+class TestEvolvableANN(unittest.TestCase):
+
+    player_class = axelrod.EvolvableANN
+
+    def test_normalized_parameters(self):
+        # Must specify at least one of cycle or cycle_length
+        self.assertRaises(
+            InsufficientParametersError,
+            self.player_class._normalize_parameters
+        )
+        self.assertRaises(
+            InsufficientParametersError,
+            self.player_class._normalize_parameters,
+            weights=nn_weights["Evolved ANN 5"][2]
+        )
+
+
+class TestEvolvableANN2(TestEvolvablePlayer):
+    name = "EvolvableANN"
+    player_class = axelrod.EvolvableANN
+    parent_class = axelrod.ANN
+    parent_kwargs = ["num_features", "num_hidden", "weights"]
+    init_parameters = {"num_features": 17, "num_hidden": 8}
+
+
+class TestEvolvableANN3(TestEvolvablePlayer):
+    name = "EvolvableANN"
+    player_class = axelrod.EvolvableANN
+    parent_class = axelrod.ANN
+    parent_kwargs = ["num_features", "num_hidden", "weights"]
+    init_parameters = {
+        "num_features": nn_weights["Evolved ANN 5"][0],
+        "num_hidden": nn_weights["Evolved ANN 5"][1],
+        "weights": nn_weights["Evolved ANN 5"][2]
+    }
+
+
+# Substitute EvolvableANN as a regular EvolvedANN5.
+EvolvableANNPlayerWithDefault = PartialClass(
+    axelrod.EvolvableANN,
+    num_features=num_features,
+    num_hidden=num_hidden,
+    weights=weights
+)
+
+
+class EvolvableANNAsANN(TestEvolvedANN5):
+    player = EvolvableANNPlayerWithDefault
+
+    def test_equality_of_clone(self):
+        pass
+
+    def test_equality_of_pickle_clone(self):
+        pass

axelrod/tests/strategies/test_cycler.py

@@ -10,7 +10,7 @@
 from axelrod.evolvable_player import InsufficientParametersError
 
 from .test_player import TestPlayer
-from .test_evolvable_player import TestEvolvablePlayer
+from .test_evolvable_player import PartialClass, TestEvolvablePlayer
 
 C, D = Action.C, Action.D
 
@@ -216,3 +216,15 @@ class TestEvolvableCycler3(TestEvolvablePlayer):
                        "mutation_potency": 10}
 
 
+# Substitute EvolvedCycler as a regular Cycler.
+EvolvableCyclerWithDefault = PartialClass(EvolvableCycler, cycle="CCD")
+
+
+class EvolvableCyclerAsCycler(TestBasicCycler):
+    player = EvolvableCyclerWithDefault
+
+    def test_equality_of_clone(self):
+        pass
+
+    def test_equality_of_pickle_clone(self):
+        pass

axelrod/tests/strategies/test_evolvable_player.py

@@ -1,3 +1,4 @@
+import functools
 import random
 import unittest
 
@@ -10,6 +11,15 @@
 C, D = Action.C, Action.D
 
 
+def PartialClass(cls, **kwargs):
+
+    class PartialedClass(cls):
+        __init__ = functools.partialmethod(
+            cls.__init__, **kwargs)
+
+    return PartialedClass
+
+
 class EvolvableTestOpponent(EvolvablePlayer):
     name = "EvolvableTestOpponent"
 

axelrod/tests/strategies/test_finite_state_machines.py

@@ -8,7 +8,7 @@
 from axelrod.strategies.finite_state_machines import EvolvableFSMPlayer, FSMPlayer, SimpleFSM
 
 from .test_player import TestPlayer
-from .test_evolvable_player import TestEvolvablePlayer
+from .test_evolvable_player import PartialClass, TestEvolvablePlayer
 
 C, D = axelrod.Action.C, axelrod.Action.D
 
@@ -1114,3 +1114,21 @@ class TestEvolvableFSMPlayer4(TestEvolvablePlayer):
         "initial_state": 1,
         "initial_action": C
     }
+
+
+# Substitute EvolvedFSMPlayer as a regular FSMPlayer.
+EvolvableFSMPlayerWithDefault = PartialClass(
+    EvolvableFSMPlayer,
+    transitions=((1, C, 1, C), (1, D, 1, D)),
+    initial_state=1,
+    initial_action=C)
+
+
+class EvolvableFSMAsFSM(TestFSMPlayer):
+    player = EvolvableFSMPlayerWithDefault
+
+    def test_equality_of_clone(self):
+        pass
+
+    def test_equality_of_pickle_clone(self):
+        pass

axelrod/tests/strategies/test_gambler.py

@@ -5,77 +5,15 @@
 import random
 import unittest
 import axelrod
+from axelrod.load_data_ import load_pso_tables
 from axelrod.strategies.lookerup import create_lookup_table_keys
 from .test_lookerup import convert_original_to_current
 from .test_player import TestPlayer
-from .test_evolvable_player import TestEvolvablePlayer
+from .test_evolvable_player import PartialClass, TestEvolvablePlayer
 
-C, D = axelrod.Action.C, axelrod.Action.D
-
-
-class TestEvolvableGambler(unittest.TestCase):
-
-    def test_receive_vector(self):
-        plays, op_plays, op_start_plays = 1, 1, 1
-        player = axelrod.EvolvableGambler(
-            parameters=(plays, op_plays, op_start_plays))
 
-        self.assertRaises(AttributeError, axelrod.EvolvableGambler.__getattribute__,
-                          *[player, 'vector'])
-
-        vector = [random.random() for _ in range(8)]
-        player.receive_vector(vector)
-        self.assertEqual(player.pattern, vector)
-
-    def test_vector_to_instance(self):
-        plays, op_plays, op_start_plays = 1, 1, 1
-        player = axelrod.EvolvableGambler(
-            parameters=(plays, op_plays, op_start_plays))
-
-        vector = [random.random() for _ in range(8)]
-        player.receive_vector(vector)
-        keys = create_lookup_table_keys(player_depth=plays, op_depth=op_plays,
-                                        op_openings_depth=op_start_plays)
-        action_dict = dict(zip(keys, vector))
-        self.assertEqual(player._lookup.dictionary, action_dict)
-
-    def test_create_vector_bounds(self):
-        plays, op_plays, op_start_plays = 1, 1, 1
-        player = axelrod.EvolvableGambler(
-            parameters=(plays, op_plays, op_start_plays))
-        lb, ub = player.create_vector_bounds()
-        self.assertIsInstance(lb, list)
-        self.assertIsInstance(ub, list)
-        self.assertEqual(len(lb), 8)
-        self.assertEqual(len(ub), 8)
-
-
-class TestEvolvableGambler2(TestEvolvablePlayer):
-    name = "EvolvableGambler"
-    player_class = axelrod.EvolvableGambler
-    parent_class = axelrod.Gambler
-    parent_kwargs = ["lookup_dict"]
-    init_parameters = {"parameters": (1, 1, 1),
-                       "initial_actions": (C,)}
-
-
-class TestEvolvableGambler3(TestEvolvablePlayer):
-    name = "EvolvableGambler"
-    player_class = axelrod.EvolvableGambler
-    parent_class = axelrod.Gambler
-    parent_kwargs = ["lookup_dict"]
-    init_parameters = {"parameters": (3, 2, 1),
-                       "initial_actions": (C, C, C,)}
-
-
-class TestEvolvableGambler4(TestEvolvablePlayer):
-    name = "EvolvableGambler"
-    player_class = axelrod.EvolvableGambler
-    parent_class = axelrod.Gambler
-    parent_kwargs = ["lookup_dict"]
-    init_parameters = {"parameters": (2, 2, 2),
-                       "pattern": [random.random() for _ in range(64)],
-                       "initial_actions": (C, C,)}
+tables = load_pso_tables("pso_gambler.csv", directory="data")
+C, D = axelrod.Action.C, axelrod.Action.D
 
 
 class TestGambler(TestPlayer):
@@ -553,3 +491,87 @@ def test_vs_alternator(self):
         new_seed = 1
         expected = [(C, C), (C, D), (C, C), (D, D), (D, C), (C, D), (D, C)]
         self.versus_test(axelrod.Alternator(), expected_actions=expected, seed=new_seed)
+
+
+class TestEvolvableGambler(unittest.TestCase):
+
+    def test_receive_vector(self):
+        plays, op_plays, op_start_plays = 1, 1, 1
+        player = axelrod.EvolvableGambler(
+            parameters=(plays, op_plays, op_start_plays))
+
+        self.assertRaises(AttributeError, axelrod.EvolvableGambler.__getattribute__,
+                          *[player, 'vector'])
+
+        vector = [random.random() for _ in range(8)]
+        player.receive_vector(vector)
+        self.assertEqual(player.pattern, vector)
+
+    def test_vector_to_instance(self):
+        plays, op_plays, op_start_plays = 1, 1, 1
+        player = axelrod.EvolvableGambler(
+            parameters=(plays, op_plays, op_start_plays))
+
+        vector = [random.random() for _ in range(8)]
+        player.receive_vector(vector)
+        keys = create_lookup_table_keys(player_depth=plays, op_depth=op_plays,
+                                        op_openings_depth=op_start_plays)
+        action_dict = dict(zip(keys, vector))
+        self.assertEqual(player._lookup.dictionary, action_dict)
+
+    def test_create_vector_bounds(self):
+        plays, op_plays, op_start_plays = 1, 1, 1
+        player = axelrod.EvolvableGambler(
+            parameters=(plays, op_plays, op_start_plays))
+        lb, ub = player.create_vector_bounds()
+        self.assertIsInstance(lb, list)
+        self.assertIsInstance(ub, list)
+        self.assertEqual(len(lb), 8)
+        self.assertEqual(len(ub), 8)
+
+
+class TestEvolvableGambler2(TestEvolvablePlayer):
+    name = "EvolvableGambler"
+    player_class = axelrod.EvolvableGambler
+    parent_class = axelrod.Gambler
+    parent_kwargs = ["lookup_dict"]
+    init_parameters = {"parameters": (1, 1, 1),
+                       "initial_actions": (C,)}
+
+
+class TestEvolvableGambler3(TestEvolvablePlayer):
+    name = "EvolvableGambler"
+    player_class = axelrod.EvolvableGambler
+    parent_class = axelrod.Gambler
+    parent_kwargs = ["lookup_dict"]
+    init_parameters = {"parameters": (3, 2, 1),
+                       "initial_actions": (C, C, C,)}
+
+
+class TestEvolvableGambler4(TestEvolvablePlayer):
+    name = "EvolvableGambler"
+    player_class = axelrod.EvolvableGambler
+    parent_class = axelrod.Gambler
+    parent_kwargs = ["lookup_dict"]
+    init_parameters = {"parameters": (2, 2, 2),
+                       "pattern": [random.random() for _ in range(64)],
+                       "initial_actions": (C, C,)}
+
+
+# Substitute EvolvableHMMPlayer as a regular HMMPlayer.
+EvolvableGamblerWithDefault = PartialClass(
+    axelrod.EvolvableGambler,
+    pattern=tables[("PSO Gambler 2_2_2", 2, 2, 2)],
+    parameters=(2, 2, 2),
+    initial_actions=(C,C,)
+)
+
+
+class EvolvableGamblerAsGambler(TestPSOGambler2_2_2):
+    player = EvolvableGamblerWithDefault
+
+    def test_equality_of_clone(self):
+        pass
+
+    def test_equality_of_pickle_clone(self):
+        pass