Merge pull request #1 from Axelrod-Python/Chadys-802-vk

Chadys 802 vk

Author: Chadys

axelrod/_strategy_utils.py

@@ -4,8 +4,9 @@
 
 from axelrod.player import update_history
 from axelrod.actions import Actions
+from axelrod.strategies.cooperator import Cooperator
+from axelrod.strategies.defector import Defector
 
-from axelrod.strategies.cycler import Cycler
 
 C, D = Actions.C, Actions.D
 
@@ -68,13 +69,13 @@ def calculate_scores(p1, p2, game):
 def look_ahead(player_1, player_2, game, rounds=10):
     """Looks ahead for `rounds` and selects the next strategy appropriately."""
     results = []
-
     # Simulate plays for `rounds` rounds
+    players = {C: Cooperator(), D: Defector()}
     strategies = [C, D]
     for strategy in strategies:
         # Instead of a deepcopy, create a new opponent and play out the history
         opponent_ = player_2.clone()
-        player_ = Cycler(strategy)  # Either cooperator or defector
+        player_ = players[strategy]
         for h1 in player_1.history:
             limited_simulate_play(player_, opponent_, h1)
 

axelrod/strategies/darwin.py

@@ -33,7 +33,7 @@ class Darwin(Player):
     classifier = {
         'memory_depth': float('inf'),
         'stochastic': False,
-        'inspects_source': False,
+        'inspects_source': True,  # Checks to see if opponent is using simulated matches.
         'long_run_time': False,
         'makes_use_of': set(),
         'manipulates_source': False,

axelrod/strategies/hmm.py

@@ -1,13 +1,15 @@
 from numpy.random import choice
 
-from axelrod.actions import Actions
+from axelrod.actions import Actions , Action
 from axelrod.player import Player
 from axelrod.random_ import random_choice
 
 C, D = Actions.C, Actions.D
 
+#Type Hinting has not finished yet
+#Lines 9 and 10 will be deleted
 
-def is_stochastic_matrix(m, ep=1e-8):
+def is_stochastic_matrix(m, ep=1e-8) -> bool:
     """Checks that the matrix m (a list of lists) is a stochastic matrix."""
     for i in range(len(m)):
         for j in range(len(m[i])):
@@ -29,7 +31,7 @@ class SimpleHMM(object):
     """
 
     def __init__(self, transitions_C, transitions_D, emission_probabilities,
-                 initial_state):
+                 initial_state) -> None:
         """
         Params
         ------
@@ -43,7 +45,7 @@ def __init__(self, transitions_C, transitions_D, emission_probabilities,
         self.emission_probabilities = emission_probabilities
         self.state = initial_state
 
-    def is_well_formed(self):
+    def is_well_formed(self) -> bool:
         """
         Determines if the HMM parameters are well-formed:
             - Both matrices are stochastic
@@ -61,7 +63,7 @@ def is_well_formed(self):
             return False
         return True
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         """Equality of two HMMs"""
         check = True
         for attr in ["transitions_C", "transitions_D",
@@ -70,7 +72,7 @@ def __eq__(self, other):
         return check
 
 
-    def move(self, opponent_action):
+    def move(self, opponent_action) -> Action:
         """Changes state and computes the response action.
 
         Parameters
@@ -111,7 +113,7 @@ class HMMPlayer(Player):
 
     def __init__(self, transitions_C=None, transitions_D=None,
                  emission_probabilities=None, initial_state=0,
-                 initial_action=C):
+                 initial_action=C) -> None:
         super().__init__()
         if not transitions_C:
             transitions_C = [[1]]
@@ -126,7 +128,7 @@ def __init__(self, transitions_C=None, transitions_D=None,
         self.state = self.hmm.state
         self.classifier['stochastic'] = self.is_stochastic()
 
-    def is_stochastic(self):
+    def is_stochastic(self) -> bool:
         """Determines if the player is stochastic."""
         # If the transitions matrices and emission_probabilities are all 0 or 1
         # Then the player is stochastic
@@ -138,7 +140,7 @@ def is_stochastic(self):
             return True
         return False
 
-    def strategy(self, opponent):
+    def strategy(self, opponent) -> Action:
         if len(self.history) == 0:
             return self.initial_action
         else:
@@ -148,7 +150,7 @@ def strategy(self, opponent):
             self.state = self.hmm.state
             return action
 
-    def reset(self):
+    def reset(self) -> None:
         super().reset()
         self.hmm.state = self.initial_state
         self.state = self.hmm.state
@@ -175,7 +177,7 @@ class EvolvedHMM5(HMMPlayer):
         'manipulates_state': False
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         initial_state = 3
         initial_action = C
         t_C = [[1, 0, 0, 0, 0],

axelrod/tests/strategies/test_better_and_better.py

@@ -25,9 +25,11 @@ def test_strategy(self):
 
         self.first_play_test(D, seed=3)  # C is very unlikely
         self.first_play_test(C, seed=1514)  # first seed (starting from seed=0) that cooperates on first round
-        self.versus_test(axelrod.Defector(), [(D, D), (D, D), (D, D), (D, D), (C, D), (D, D), (D, D), (D, D), (D, D)],
+        self.versus_test(axelrod.Defector(),
+                         expected_actions=[(D, D), (D, D), (D, D), (D, D), (C, D), (D, D), (D, D), (D, D), (D, D)],
                          seed=6)
-        self.versus_test(axelrod.Cooperator(), [(D, C), (D, C), (D, C), (D, C), (D, C), (D, C), (D, C), (D, C), (D, C)],
+        self.versus_test(axelrod.Cooperator(),
+                         expected_actions=[(D, C), (D, C), (D, C), (D, C), (D, C), (D, C), (D, C), (D, C), (D, C)],
                          seed=8)
         actions = []
         for index in range(200):

axelrod/tests/strategies/test_calculator.py

@@ -32,8 +32,8 @@ def test_twenty_rounds_joss_then_defects_for_cyclers(self):
         twenty_test_actions = get_joss_strategy_actions(twenty_alternator_actions, flip_indices)
 
         expected_actions = twenty_test_actions + [(D, C), (D, D), (D, C), (D, D)]
-        self.versus_test(axelrod.Alternator(), twenty_test_actions, seed=seed)
-        self.versus_test(axelrod.Alternator(), expected_actions, seed=seed)
+        self.versus_test(axelrod.Alternator(), expected_actions=twenty_test_actions, seed=seed)
+        self.versus_test(axelrod.Alternator(), expected_actions=expected_actions, seed=seed)
 
     def test_twenty_rounds_joss_then_tit_for_tat_for_non_cyclers(self):
         """Uses axelrod.strategies.axelrod_first.Joss strategy for first 20 rounds"""
@@ -48,8 +48,9 @@ def test_twenty_rounds_joss_then_tit_for_tat_for_non_cyclers(self):
 
         opponent_actions = twenty_non_cyclical_actions + subsequent_opponent_actions
         test_actions = twenty_test_actions + subsequent_test_actions
-        self.versus_test(axelrod.MockPlayer(twenty_non_cyclical_actions), twenty_test_actions, seed=seed)
-        self.versus_test(axelrod.MockPlayer(opponent_actions), test_actions, seed=seed)
+        self.versus_test(axelrod.MockPlayer(twenty_non_cyclical_actions),
+                         expected_actions=twenty_test_actions, seed=seed)
+        self.versus_test(axelrod.MockPlayer(opponent_actions), expected_actions=test_actions, seed=seed)
 
     def test_edge_case_calculator_sees_cycles_of_size_ten(self):
         seed = 3
@@ -59,7 +60,7 @@ def test_edge_case_calculator_sees_cycles_of_size_ten(self):
         ten_cycle_twenty_rounds = get_joss_strategy_actions(ten_length_cycle * 2, indices_to_flip=[16])
         opponent_actions = ten_length_cycle * 2 + [C, D, C]
         expected = ten_cycle_twenty_rounds + [(D, C), (D, D), (D, C)]
-        self.versus_test(axelrod.MockPlayer(opponent_actions), expected, seed=seed)
+        self.versus_test(axelrod.MockPlayer(opponent_actions), expected_actions=expected, seed=seed)
 
     def test_edge_case_calculator_ignores_cycles_gt_len_ten(self):
         seed = 3
@@ -71,7 +72,8 @@ def test_edge_case_calculator_ignores_cycles_gt_len_ten(self):
         self.assertEqual(detect_cycle(opponent_actions), tuple(eleven_length_cycle))
 
         uses_tit_for_tat_after_twenty_rounds = twenty_rounds + [(D, C), (C, D)]
-        self.versus_test(axelrod.MockPlayer(opponent_actions), uses_tit_for_tat_after_twenty_rounds, seed=seed)
+        self.versus_test(axelrod.MockPlayer(opponent_actions),
+                         expected_actions=uses_tit_for_tat_after_twenty_rounds, seed=seed)
 
     def attribute_equality_test(self, player, clone):
         """Overwrite the default test to check Joss instance"""

axelrod/tests/strategies/test_cooperator.py

@@ -56,15 +56,15 @@ def test_cooperates_in_first_three_rounds(self):
         against_defector = [(C, D)] * 3
         against_cooperator = [(C, C)] * 3
         against_alternator = [(C, C), (C, D), (C, C)]
-        self.versus_test(axelrod.Defector(), against_defector)
-        self.versus_test(axelrod.Cooperator(), against_cooperator)
-        self.versus_test(axelrod.Alternator(), against_alternator)
+        self.versus_test(axelrod.Defector(), expected_actions=against_defector)
+        self.versus_test(axelrod.Cooperator(), expected_actions=against_cooperator)
+        self.versus_test(axelrod.Alternator(), expected_actions=against_alternator)
 
     def test_defects_after_three_rounds_if_opponent_only_cooperated_in_max_history_depth_ten(self):
         against_cooperator = [(C, C)] * 3 + [(D, C)] * 20
-        self.versus_test(axelrod.Cooperator(), against_cooperator)
+        self.versus_test(axelrod.Cooperator(), expected_actions=against_cooperator)
 
     def test_defects_when_opponent_has_no_defections_to_history_depth_ten(self):
         opponent_actions = [D] + [C] * 10 + [D, C]
         expected_actions = [(C, D)] + [(C, C)] * 10 + [(D, D), (C, C)]
-        self.versus_test(axelrod.MockPlayer(opponent_actions), expected_actions)
+        self.versus_test(axelrod.MockPlayer(opponent_actions), expected_actions=expected_actions)

axelrod/tests/strategies/test_cycler.py

@@ -41,8 +41,8 @@ def test_strategy(self):
         against_defector = list(zip(anticycler_rounds, [D] * num_elements))
         against_cooperator = list(zip(anticycler_rounds, [C] * num_elements))
 
-        self.versus_test(axelrod.Defector(), against_defector)
-        self.versus_test(axelrod.Cooperator(), against_cooperator)
+        self.versus_test(axelrod.Defector(), expected_actions=against_defector)
+        self.versus_test(axelrod.Cooperator(), expected_actions=against_cooperator)
 
 
 class TestBasicCycler(TestPlayer):
@@ -68,7 +68,7 @@ def test_memory_depth_is_len_cycle_minus_one(self):
 
     def test_cycler_works_as_expected(self):
         expected = [(C, D), (D, D), (D, D), (C, D)] * 2
-        self.versus_test(axelrod.Defector(), expected, init_kwargs={'cycle': 'CDDC'})
+        self.versus_test(axelrod.Defector(), expected_actions=expected, init_kwargs={'cycle': 'CDDC'})
 
     def test_cycle_raises_value_error_on_bad_cycle_str(self):
         self.assertRaises(ValueError, Cycler, 'CdDC')
@@ -95,7 +95,7 @@ def test_strategy(self):
             match_len = 20
             actions_generator = _get_actions_cycle_against_cooperator(cycle_str)
             test_actions = [next(actions_generator) for _ in range(match_len)]
-            self.versus_test(axelrod.Cooperator(), test_actions)
+            self.versus_test(axelrod.Cooperator(), expected_actions=test_actions)
 
     return TestCyclerChild
 

axelrod/tests/strategies/test_darwin.py

@@ -15,29 +15,41 @@ class TestDarwin(TestPlayer):
         'stochastic': False,
         'makes_use_of': set(),
         'long_run_time': False,
-        'inspects_source': False,
+        'inspects_source': True,
         'manipulates_source': False,
         'manipulates_state': True
     }
 
+    def setUp(self):
+        """Each test starts with a fresh genome."""
+        self.player.genome = [C]
+        super(TestDarwin, self).setUp()
+
+    def test_setup(self):
+        player = self.player()
+        self.assertEqual(player.genome, [C])
+        self.assertEqual(player.history, [])
+
     def test_strategy(self):
         p1 = self.player()
-        p2 = axelrod.Cooperator()
-        self.assertEqual(p1.strategy(p2), C)  # Always cooperate first.
-        for i in range(10):
-            p1.play(p2)
-        self.assertEqual(p1.strategy(p2), C)
+        p1.reset()
+        self.versus_test(axelrod.Cooperator(), expected_actions=[(C, C)] * 5, attrs={'genome': [C] * 5})
 
-        p1 = self.player()
-        p2 = axelrod.Defector()
-        self.assertEqual(p1.strategy(p2), C)  # Always cooperate first.
-        for i in range(10):
-            p1.play(p2)
-        self.assertEqual(p1.strategy(p2), C)
+        expected_genome = [D] * 4 + [C]
+        self.versus_test(axelrod.Defector(), expected_actions=[(C, D)] * 5, attrs={'genome': expected_genome})
+
+        # uses genome
+        expected_actions = [(C, C)] + [(D, C)] * 3 + [(C, C)] * 2
+        self.versus_test(axelrod.Cooperator(), expected_actions)
+
+    def test_against_geller_and_mindreader(self):
+        self.versus_test(axelrod.GellerCooperator(), expected_actions=[(C, C)] * 2, attrs={'genome': [C, C]})
+
+        self.versus_test(axelrod.MindReader(), expected_actions=[(C, D)] * 2, attrs={'genome': [D, C]})
 
     def test_play(self):
         """valid_callers must contain at least one entry..."""
-        self.assertTrue(len(self.player.valid_callers)>0)
+        self.assertTrue(len(self.player.valid_callers) > 0)
         """...and should allow round_robin.play to call"""
         self.assertTrue("play" in self.player.valid_callers)
         self.play()
@@ -52,15 +64,23 @@ def play(self):
         # Genome contains only valid responses.
         self.assertEqual(p1.genome.count(C) + p1.genome.count(D), len(p1.genome))
 
-    def test_reset(self):
-        """Is instance correctly reset between rounds"""
+    def test_reset_only_resets_first_move_of_genome(self):
+        self.versus_test(axelrod.Defector(), expected_actions=[(C, D)] + [(D, D)] * 4)
+
         p1 = self.player()
+        self.assertEqual(p1.genome, [D, C, C, C, D])
         p1.reset()
         self.assertEqual(p1.history, [])
-        self.assertEqual(p1.genome[0], C)
+        self.assertEqual(p1.genome, [C, C, C, C, D])
 
-    def test_unique_genome(self):
-        """Ensure genome remains unique class property"""
+    def test_all_darwin_instances_share_one_genome(self):
         p1 = self.player()
         p2 = self.player()
-        self.assertTrue(p1.genome is p2.genome)
+        self.assertIs(p1.genome, p2.genome)
+
+        self.versus_test(axelrod.Defector(), expected_actions=[(C, D)] + [(D, D)] * 4)
+
+        self.assertEqual(p2.genome, [D, C, C, C, D])
+        self.assertIs(p1.genome, p2.genome)
+        p3 = self.player()
+        self.assertIs(p3.genome, p2.genome)

axelrod/tests/strategies/test_defector.py

@@ -44,9 +44,18 @@ def test_strategy(self):
         # Starts by defecting.
         self.first_play_test(D)
         self.second_play_test(D, D, D, D)
-        # Test if strategy tries to trick opponent.
-        self.responses_test([D], [C, C, C], [C, C, C])
-        self.responses_test([D], [C, C, C, D, D], [C, C, C, C, D])
-        history = [C, C, C, D, D] + [C] * 11
-        opponent_history = [C, C, C, C, D] + [D] + [C] * 10
-        self.responses_test([D], history, opponent_history)
+
+    def test_cooperates_if_opponent_history_has_C_and_last_three_are_D(self):
+        opponent_actions = [D, C] + [D] * 5
+        actions = [(D, D), (D, C)] + [(D, D)] * 3 + [(C, D)] * 2
+        self.versus_test(axelrod.MockPlayer(opponent_actions), expected_actions=actions)
+
+    def test_defects_if_opponent_never_cooperated(self):
+        opponent_actions = [D] * 7
+        actions = [(D, D)] * 7
+        self.versus_test(axelrod.MockPlayer(opponent_actions), expected_actions=actions)
+
+    def test_defects_if_opponent_last_three_are_not_D(self):
+        opponent_actions = [C] + [D] * 3 + [C, D]
+        actions = [(D, C)] + [(D, D)] * 3 + [(C, C), (D, D)]
+        self.versus_test(axelrod.MockPlayer(opponent_actions), expected_actions=actions)

axelrod/tests/strategies/test_doubler.py

@@ -24,14 +24,19 @@ def test_strategy(self):
         # Starts by cooperating
         self.first_play_test(C)
 
-        # Defects when the opponent has defected and
-        # the opponent's cooperation count
-        # is less than twice their defection count
-        self.responses_test([D], [C], [D])
-        self.responses_test([D], [D, D], [D, D])
-        self.responses_test([D], [C, D], [C, D])
-        self.responses_test([D], [C, C, D], [C, C, D])
-
-        # Cooperates otherwise
-        self.responses_test([C], [C], [C])
-        self.responses_test([C], [C, C, C, C], [C, C, C, D])
+    def test_defects_if_opponent_last_play_is_D_and_defections_gt_two_times_cooperations(self):
+        opponent_plays = [C] * 7 + [D] * 4 + [C]
+        actions = [(C, C)] * 7 + [(C, D)] * 4 + [(D, C)]
+        self.versus_test(axelrod.MockPlayer(opponent_plays), expected_actions=actions)
+
+    def test_defects_if_opponent_last_play_D_and_defections_equal_two_times_cooperations(self):
+        opponent_plays = [C] * 8 + [D] * 4 + [C]
+        actions = [(C, C)] * 8 + [(C, D)] * 4 + [(D, C)]
+        self.versus_test(axelrod.MockPlayer(opponent_plays), expected_actions=actions)
+
+    def test_cooperates_if_opponent_last_play_is_C(self):
+        opponent_first_five = [D] * 5
+        actions_first_five = [(C, D)] + [(D, D)] * 4
+        opponent_plays = opponent_first_five + [C] + [D]
+        actions = actions_first_five + [(D, C)] + [(C, D)]
+        self.versus_test(axelrod.MockPlayer(opponent_plays), expected_actions=actions)