Fix some type hints

Author: marcharper

axelrod/evolvable_player.py

@@ -1,5 +1,6 @@
 from pickle import dumps, loads
 from random import randrange
+from typing import Dict, List
 from .player import Player
 
 
@@ -17,14 +18,14 @@ class EvolvablePlayer(Player):
 
     name = "EvolvablePlayer"
     parent_class = Player
-    parent_kwargs = []
+    parent_kwargs = []  # type: List[str]
 
     def overwrite_init_kwargs(self, **kwargs):
         """Use to overwrite parameters for proper cloning and testing."""
         for k, v in kwargs.items():
             self.init_kwargs[k] = v
 
-    def create_new(self, **kwargs):
+    def create_new(self, **kwargs) -> EvolvablePlayer:
         """Creates a new variant with parameters overwritten by kwargs."""
         init_kwargs = self.init_kwargs.copy()
         init_kwargs.update(kwargs)
@@ -34,22 +35,22 @@ def create_new(self, **kwargs):
     # but you must overwrite both.
 
     def serialize_parameters(self):
-        """Serialize parameters to a string for reinforcement learning."""
+        """Serialize parameters."""
         return dumps(self.init_kwargs)
 
     @classmethod
-    def deserialize_parameters(cls, serialized):
+    def deserialize_parameters(cls, serialized) -> EvolvablePlayer:
         """Deserialize parameters to a Player instance."""
         init_kwargs = loads(serialized)
         return cls(**init_kwargs)
 
     # Optional methods for evolutionary algorithms and Moran processes.
 
-    def mutate(self):
+    def mutate(self) -> EvolvablePlayer:
         """Optional method to allow Player to produce a variant (not in place)."""
         pass
 
-    def crossover(self, other):
+    def crossover(self, other) -> EvolvablePlayer:
         """Optional method to allow Player to produce variants in combination with another player. Returns a new
         Player."""
         pass
@@ -65,17 +66,17 @@ def create_vector_bounds(self):
         pass
 
 
-def copy_lists(lists):
+def copy_lists(lists: List[List]) -> List[List]:
     return list(map(list, lists))
 
 
-def crossover_lists(list1, list2):
+def crossover_lists(list1: List, list2: List) -> List:
     cross_point = randrange(len(list1))
     new_list = list(list1[:cross_point]) + list(list2[cross_point:])
     return new_list
 
 
-def crossover_dictionaries(table1, table2):
+def crossover_dictionaries(table1: Dict, table2: Dict) -> Dict:
     keys = list(table1.keys())
     cross_point = randrange(len(keys))
     new_items = [(k, table1[k]) for k in keys[:cross_point]]

axelrod/strategies/cycler.py

@@ -1,6 +1,7 @@
 import copy
 import itertools
 import random
+from typing import List, Tuple
 
 from axelrod.action import Action, actions_to_str, str_to_actions
 from axelrod.evolvable_player import EvolvablePlayer, InsufficientParametersError, crossover_lists
@@ -38,7 +39,7 @@ def __init__(self) -> None:
         self.first_three = self._get_first_three()
 
     @staticmethod
-    def _get_first_three():
+    def _get_first_three() -> List[Action]:
         return [C, D, D]
 
     def strategy(self, opponent: Player) -> Action:
@@ -86,13 +87,12 @@ def __init__(self, cycle: str = "CCD") -> None:
         """
         super().__init__()
         self.cycle = cycle
-        self.cycle_iter = None
         self.set_cycle(cycle=cycle)
 
     def strategy(self, opponent: Player) -> Action:
         return next(self.cycle_iter)
 
-    def set_cycle(self, cycle):
+    def set_cycle(self, cycle: str):
         """Set or change the cycle."""
         self.cycle = cycle
         self.cycle_iter = itertools.cycle(str_to_actions(self.cycle))
@@ -123,7 +123,7 @@ def __init__(
         self.mutation_potency = mutation_potency
 
     @classmethod
-    def _normalize_parameters(cls, cycle=None, cycle_length=None):
+    def _normalize_parameters(cls, cycle=None, cycle_length=None) -> Tuple[str, int]:
         """Compute other parameters from those that may be missing, to ensure proper cloning."""
         if not cycle:
             if not cycle_length:
@@ -133,13 +133,13 @@ def _normalize_parameters(cls, cycle=None, cycle_length=None):
         return cycle, cycle_length
 
     @classmethod
-    def _generate_random_cycle(cls, cycle_length):
+    def _generate_random_cycle(cls, cycle_length: int) -> str:
         """
         Generate a sequence of random moves
         """
         return actions_to_str(random.choice(actions) for _ in range(cycle_length))
 
-    def mutate(self):
+    def mutate(self) -> EvolvablePlayer:
         """
         Basic mutation which may change any random actions in the sequence.
         """
@@ -154,7 +154,7 @@ def mutate(self):
         cycle, _ = self._normalize_parameters(cycle)
         return self.create_new(cycle=cycle)
 
-    def crossover(self, other):
+    def crossover(self, other) -> EvolvablePlayer:
         """
         Creates and returns a new Player instance with a single crossover point.
         """

axelrod/strategies/finite_state_machines.py

@@ -1,13 +1,15 @@
 import itertools
 from random import randrange
+from typing import Any, List, Sequence, Tuple, Union
 import numpy.random as random
 from numpy.random import choice
-from axelrod.action import Action, UnknownActionError
+from axelrod.action import Action
 from axelrod.evolvable_player import EvolvablePlayer, InsufficientParametersError, copy_lists
 from axelrod.player import Player
 
 C, D = Action.C, Action.D
 actions = (C, D)
+Transition = Tuple[int, Action, int, Action]
 
 
 class SimpleFSM(object):
@@ -107,7 +109,7 @@ class FSMPlayer(Player):
 
     def __init__(
         self,
-        transitions: tuple = ((1, C, 1, C), (1, D, 1, D)),
+        transitions: Tuple[Transition, ...] = ((1, C, 1, C), (1, D, 1, D)),
         initial_state: int = 1,
         initial_action: Action = C
     ) -> None:
@@ -164,38 +166,40 @@ def __init__(
             num_states=self.num_states)
 
     @classmethod
-    def normalize_transitions(cls, transitions):
-        """Translate List[List] to Tuple[Tuple]"""
+    def normalize_transitions(cls, transitions: Sequence[Sequence]) -> Tuple[Tuple[Any, ...], ...]:
+        """Translate a list of lists to a tuple of tuples."""
         normalized = []
         for t in transitions:
             normalized.append(tuple(t))
         return tuple(normalized)
 
     @classmethod
-    def _normalize_parameters(cls, transitions=None, initial_state=None, initial_action=None, num_states=None):
+    def _normalize_parameters(cls, transitions: Tuple = None, initial_state: int = None, initial_action: Action = None,
+                              num_states: int = None) -> Tuple[Tuple, int, Action, int]:
         if not ((transitions is not None) and (initial_state is not None) and (initial_action is not None)):
             if not num_states:
                 raise InsufficientParametersError("Insufficient Parameters to instantiate EvolvableFSMPlayer")
             transitions, initial_state, initial_action = cls.random_params(num_states)
         transitions = cls.normalize_transitions(transitions)
+        num_states = len(transitions) // 2
         return transitions, initial_state, initial_action, num_states
 
     @property
-    def num_states(self):
+    def num_states(self) -> int:
         return self.fsm.num_states()
 
     @classmethod
-    def random_params(cls, num_states):
+    def random_params(cls, num_states: int) -> Tuple[Tuple[Transition, ...], int, Action]:
         rows = []
         for j in range(num_states):
             for action in actions:
                 next_state = randrange(num_states)
                 next_action = choice(actions)
-                row = [j, action, next_state, next_action]
-                rows.append(tuple(row))
+                row = (j, action, next_state, next_action)
+                rows.append(row)
         initial_state = randrange(num_states)
         initial_action = choice(actions)
-        return rows, initial_state, initial_action
+        return tuple(rows), initial_state, initial_action
 
     @staticmethod
     def mutate_rows(rows, mutation_probability):

run_mypy.py

@@ -6,6 +6,7 @@
     "axelrod/action.py",
     "axelrod/deterministic_cache.py",
     "axelrod/ecosystem.py",
+    "axelrod/evolvable_player.py",
     "axelrod/fingerprint.py",
     "axelrod/game.py",
     "axelrod/load_data_.py",