Various updates following Nik's review

Author: marcharper

axelrod/strategies/axelrod_second.py

@@ -433,7 +433,7 @@ class SecondByGrofman(Player):
       - If its own previous move was D and the opponent has defected more than
         once in the last 8\* rounds, defect
 
-    \* The code looks at the first 7 of the last 8 rounds, ignoring the most
+    The code looks at the first 7 of the last 8 rounds, ignoring the most
     recent round.
 
     Names:
@@ -1530,7 +1530,7 @@ class SecondByWhite(Player):
     Strategy submitted to Axelrod's second tournament by Edward C White (K72R)
     and came in thirteenth in that tournament.
 
-    * Cooperate in the first ten turns
+    * Cooperate in the first ten turns.
     * If the opponent Cooperated last turn then Cooperate.
     * Otherwise Defect if and only if:
         floor(log(turn)) * opponent Defections >= turn

axelrod/strategies/calculator.py

@@ -32,7 +32,7 @@ def __init__(self) -> None:
         self.joss_instance = Joss()
         super().__init__()
 
-    def set_seed(self, seed=None):
+    def set_seed(self, seed: int = None):
         super().set_seed(seed)
         self.joss_instance.set_seed(seed)
 

axelrod/strategies/finite_state_machines.py

@@ -1,5 +1,5 @@
 import itertools
-from typing import Any, Dict, Sequence, Text, Tuple
+from typing import Any, Dict, List, Sequence, Text, Tuple
 
 from axelrod.action import Action
 from axelrod.evolvable_player import (
@@ -200,7 +200,7 @@ def random_params(self, num_states: int) -> Tuple[Tuple[Transition, ...], int, A
         initial_action = self._random.choice(actions)
         return tuple(rows), initial_state, initial_action
 
-    def mutate_rows(self, rows, mutation_probability):
+    def mutate_rows(self, rows: List[List], mutation_probability: float):
         rows = list(rows)
         randoms = self._random.random(len(rows))
         # Flip each value with a probability proportional to the mutation rate
@@ -239,7 +239,7 @@ def mutate(self):
             initial_action=initial_action,
         )
 
-    def crossover_rows(self, rows1, rows2):
+    def crossover_rows(self, rows1: List[List], rows2: List[List]) -> List[List]:
         num_states = len(rows1) // 2
         cross_point = 2 * self._random.randint(0, num_states)
         new_rows = copy_lists(rows1[:cross_point])

axelrod/strategies/gambler.py

@@ -89,10 +89,10 @@ def __init__(
     # The mutate and crossover methods are mostly inherited from EvolvableLookerUp, except for the following
     # modifications.
 
-    def random_value(self):
+    def random_value(self) -> float:
         return self._random.random()
 
-    def mutate_value(self, value):
+    def mutate_value(self, value: float) -> float:
         ep = self._random.uniform(-1, 1) / 4
         value += ep
         if value < 0:

axelrod/strategies/memorytwo.py

@@ -53,7 +53,7 @@ class MemoryTwoPlayer(Player):
     }
 
     def __init__(
-        self, sixteen_vector: Tuple[float, ...] = None, initial: Optional[Tuple[Action, Action]] = None
+        self, sixteen_vector: Optional[Tuple[float, ...]] = None, initial: Optional[Tuple[Action, Action]] = None
     ) -> None:
         """
         Parameters
@@ -69,14 +69,14 @@ def __init__(
         self._initial = initial
         self.set_initial_sixteen_vector(sixteen_vector)
 
-    def set_initial_sixteen_vector(self, sixteen_vector):
+    def set_initial_sixteen_vector(self, sixteen_vector: Optional[Tuple[float, ...]]):
         if sixteen_vector is None:
             sixteen_vector = tuple([1] * 16)
             warnings.warn("Memory two player is set to default, Cooperator.")
 
         self.set_sixteen_vector(sixteen_vector)
 
-    def set_sixteen_vector(self, sixteen_vector: Tuple):
+    def set_sixteen_vector(self, sixteen_vector: Tuple[float, ...]):
         if not all(0 <= p <= 1 for p in sixteen_vector):
             raise ValueError(
                 "An element in the probability vector, {}, is not "
@@ -92,7 +92,7 @@ def set_sixteen_vector(self, sixteen_vector: Tuple):
         )  # type: Dict[tuple, float]
 
     @staticmethod
-    def compute_memory_depth(sixteen_vector):
+    def compute_memory_depth(sixteen_vector: Dict[Tuple[Action, Action], float]) -> int:
         values = set(list(sixteen_vector.values()))
 
         # Memory-depth 0

axelrod/tests/property.py

@@ -153,7 +153,7 @@ def prob_end_tournaments(
     min_repetitions : integer
         The minimum number of repetitions
     max_repetitions : integer
-        The maximum number of
+        The maximum number of repetitions
     seed : integer
         Random seed
     """

axelrod/tests/strategies/test_averagecopier.py

@@ -40,7 +40,6 @@ def test_defect_if_opponent_always_defects2(self):
         self.versus_test(axl.Defector(), expected_actions=actions, seed=2)
 
     def test_random_behavior1(self):
-        # Variable behaviour based on the history and stochastic
         actions = [
             (C, C),
             (C, D),
@@ -118,17 +117,16 @@ class TestNiceAverageCopier(TestPlayer):
     }
 
     def test_cooperate_if_opponent_always_cooperates(self):
-        # Tests that if opponent has played all C then player chooses C.
+        """Tests that if opponent has played all C then player chooses C."""
         actions = [(C, C)] * 10
         self.versus_test(axl.Cooperator(), expected_actions=actions, seed=1)
 
     def test_defect_if_opponent_always_defects(self):
-        # Tests that if opponent has played all D then player chooses D.
+        """Tests that if opponent has played all D then player chooses D."""
         actions = [(C, D)] + [(D, D)] * 9
         self.versus_test(axl.Defector(), expected_actions=actions, seed=1)
 
     def test_random_behavior1(self):
-        # Variable behaviour based on the history and stochastic behaviour
         actions = [
             (C, C),
             (C, D),

axelrod/tests/strategies/test_axelrod_first.py

@@ -38,7 +38,7 @@ def test_cooperate_first_ten_rounds3(self):
 
     def test_retaliation_after_ten_rounds1(self):
         """If opponent defects at any point then the player will defect forever
-        (after 10 rounds)"""
+        (after 10 rounds)."""
         opponent = axl.MockPlayer(actions=[C] * 10 + [D])
         actions = [(C, C)] * 10 + [(C, D), (D, C)]
         self.versus_test(opponent, expected_actions=actions)

axelrod/tests/strategies/test_axelrod_second.py

@@ -22,15 +22,17 @@ class TestChampion(TestPlayer):
 
     def test_initial_rounds(self):
         # Cooperates for first 10 rounds
-        actions = [(C, D)] * 10  # Cooperate for ten rounds
+        actions = [(C, D)] * 10
         self.versus_test(axl.Defector(), expected_actions=actions)
         # Mirror partner for next phase
-        actions += [(D, D)] * 7  # Mirror opponent afterwards
+        actions += [(D, D)] * 7
         self.versus_test(axl.Defector(), expected_actions=actions)
 
     def test_cooperate_until_defect(self):
-        actions = [(C, C), (C, D)] * 5  # Cooperate for ten rounds
-        actions += [(D, C), (C, D)] * 7  # Mirror opponent afterwards
+        # Cooperates for first 10 rounds
+        actions = [(C, C), (C, D)] * 5
+        # Mirror partner for next phase
+        actions += [(D, C), (C, D)] * 7
         # Cooperate unless the opponent defected, has defected at least 40% of
         actions += [(D, C), (C, D), (C, C), (C, D)] * 3
         self.versus_test(axl.Alternator(), expected_actions=actions, seed=2)

axelrod/tests/strategies/test_cycler.py

@@ -30,7 +30,6 @@ class TestAntiCycler(TestPlayer):
     }
 
     def test_has_no_cycles(self):
-        # test_range = 100
         player = axl.AntiCycler()
         opponent = axl.Cooperator()
         match = axl.Match((player, opponent), turns=100)