Merge branch 'master' into typeHint7

Author: meatballs

axelrod/moran.py

@@ -1,6 +1,5 @@
 from collections import Counter
 import random
-from typing import Sequence, List, Tuple
 
 import numpy as np
 
@@ -9,7 +8,7 @@
 from .random_ import randrange
 
 
-def fitness_proportionate_selection(scores: Sequence[int]) -> int :
+def fitness_proportionate_selection(scores):
     """Randomly selects an individual proportionally to score.
 
     Parameters
@@ -31,8 +30,8 @@ def fitness_proportionate_selection(scores: Sequence[int]) -> int :
 
 
 class MoranProcess(object):
-    def __init__(self, players, turns: int=100, noise: float=0, deterministic_cache=None,
-                 mutation_rate: float=0., mode: str='bd', match_class=Match):
+    def __init__(self, players, turns=100, noise=0, deterministic_cache=None,
+                 mutation_rate=0., mode='bd', match_class=Match):
         """
         An agent based Moran process class. In each round, each player plays a
         Match with each other player. Players are assigned a fitness score by
@@ -108,7 +107,7 @@ def set_players(self):
             self.players.append(player)
         self.populations = [self.population_distribution()]
 
-    def mutate(self, index: int) -> List[str] :
+    def mutate(self, index):
         """Mutate the player at index."""
         # Choose another strategy at random from the initial population
         r = random.random()
@@ -122,7 +121,7 @@ def mutate(self, index: int) -> List[str] :
             new_player = self.players[index].clone()
         return new_player
 
-    def death(self, index: int=None) -> int:
+    def death(self, index=None):
         """Selects the player to be removed. Note that the in the birth-death
         case, the player that is reproducing may also be replaced. However in
         the death-birth case, this player will be excluded from the choices.
@@ -132,7 +131,7 @@ def death(self, index: int=None) -> int:
         i = randrange(0, len(self.players))
         return i
 
-    def birth(self, index: int=None) -> int:
+    def birth(self, index=None):
         """The birth event."""
         # Compute necessary fitnesses.
         scores = self.score_all()
@@ -148,7 +147,7 @@ def birth(self, index: int=None) -> int:
             j = fitness_proportionate_selection(scores)
         return j
 
-    def fixation_check(self) -> bool:
+    def fixation_check(self):
         """Is the population of a single type?"""
         if self.mutation_rate > 0:
             return False
@@ -191,7 +190,7 @@ def __next__(self):
         self.fixation_check()
         return self
 
-    def _matchup_indices(self) -> Tuple[str]:
+    def _matchup_indices(self):
         """Generate the matchup pairs."""
         indices = []
         N = len(self.players)
@@ -204,7 +203,7 @@ def _matchup_indices(self) -> Tuple[str]:
                 indices.append((i, j))
         return indices
 
-    def score_all(self) -> Tuple[str]:
+    def score_all(self):
         """Plays the next round of the process. Every player is paired up
         against every other player and the total scores are recorded."""
         N = len(self.players)
@@ -222,7 +221,7 @@ def score_all(self) -> Tuple[str]:
         self.score_history.append(scores)
         return scores
 
-    def population_distribution(self) -> int:
+    def population_distribution(self):
         """Returns the population distribution of the last iteration."""
         player_names = [str(player) for player in self.players]
         counter = Counter(player_names)
@@ -249,14 +248,14 @@ def play(self):
                 break
         return self.populations
 
-    def __len__(self) -> int:
+    def __len__(self):
         return len(self.populations)
 
 
 class MoranProcessGraph(MoranProcess):
     def __init__(self, players, interaction_graph, reproduction_graph=None,
-                 turns: int=100, noise: float =0, deterministic_cache=None,
-                 mutation_rate: float=0., mode: str='bd', match_class=Match):
+                 turns=100, noise=0, deterministic_cache=None,
+                 mutation_rate=0., mode='bd', match_class=Match):
         """
         An agent based Moran process class. In each round, each player plays a
         Match with each neighboring player according to the interaction graph.
@@ -321,7 +320,7 @@ def __init__(self, players, interaction_graph, reproduction_graph=None,
         self.index = dict(zip(interaction_graph.vertices(),
                               range(len(players))))
 
-    def birth(self, index: int=None) -> int:
+    def birth(self, index=None):
         """Compute the birth index."""
         scores = self.score_all()
         if index:
@@ -335,7 +334,7 @@ def birth(self, index: int=None) -> int:
             j = fitness_proportionate_selection(scores)
         return j
 
-    def death(self, index: int=None) -> int:
+    def death(self, index=None):
         """Selects the player to be removed."""
         if self.mode == "db":
             # Select a player to be replaced globally
@@ -350,7 +349,7 @@ def death(self, index: int=None) -> int:
             i = self.index[vertex]
         return i
 
-    def _matchup_indices(self) -> Tuple[str]:
+    def _matchup_indices(self):
         """Generate the matchup pairs"""
         indices = set()
         # For death-birth we only want the neighbors of the dead node
@@ -373,7 +372,7 @@ def _matchup_indices(self) -> Tuple[str]:
                 indices.add((i, j))
         return indices
 
-    def population_distribution(self) -> int:
+    def population_distribution(self):
         """Returns the population distribution of the last iteration."""
         player_names = [str(player) for player in self.players]
         counter = Counter(player_names)

axelrod/strategies/geller.py

@@ -1,6 +1,6 @@
 import inspect
 
-from axelrod.actions import Actions
+from axelrod.actions import Actions, Action
 from axelrod.player import Player
 from axelrod.random_ import random_choice
 
@@ -42,7 +42,7 @@ class Geller(Player):
         'manipulates_state': False
     }
 
-    def strategy(self, opponent):
+    def strategy(self, opponent: Player) -> Action:
         """
         Look at what the opponent will play in the next round and choose a strategy
         that gives the least jail time, which is is equivalent to playing the same

axelrod/strategies/hunter.py

@@ -1,7 +1,9 @@
-from axelrod.actions import Actions
+from axelrod.actions import Actions, Action
 from axelrod.player import Player
 from axelrod._strategy_utils import detect_cycle
 
+from typing import List, Tuple
+
 C, D = Actions.C, Actions.D
 
 
@@ -19,7 +21,7 @@ class DefectorHunter(Player):
         'manipulates_state': False
     }
 
-    def strategy(self, opponent):
+    def strategy(self, opponent: Player) -> Action:
         if len(self.history) >= 4 and len(opponent.history) == opponent.defections:
             return D
         return C
@@ -39,13 +41,13 @@ class CooperatorHunter(Player):
         'manipulates_state': False
     }
 
-    def strategy(self, opponent):
+    def strategy(self, opponent: Player) -> Action:
         if len(self.history) >= 4 and len(opponent.history) == opponent.cooperations:
             return D
         return C
 
 
-def is_alternator(history):
+def is_alternator(history: List[Action]) -> bool:
     for i in range(len(history) - 1):
         if history[i] == history[i + 1]:
             return False
@@ -66,11 +68,11 @@ class AlternatorHunter(Player):
         'manipulates_state': False
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
         self.is_alt = False
 
-    def strategy(self, opponent):
+    def strategy(self, opponent: Player) -> Action:
         if len(opponent.history) < 6:
             return C
         if len(self.history) == 6:
@@ -100,11 +102,11 @@ class CycleHunter(Player):
         'manipulates_state': False
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
-        self.cycle = None
+        self.cycle = None # type: Tuple[Action]
 
-    def strategy(self, opponent):
+    def strategy(self, opponent: Player) -> Action:
         if self.cycle:
             return D
         cycle = detect_cycle(opponent.history, min_size=3)
@@ -124,7 +126,7 @@ class EventualCycleHunter(CycleHunter):
 
     name = 'Eventual Cycle Hunter'
 
-    def strategy(self, opponent):
+    def strategy(self, opponent: Player) -> None:
         if len(opponent.history) < 10:
             return C
         if len(opponent.history) == opponent.cooperations:
@@ -153,7 +155,7 @@ class MathConstantHunter(Player):
         'manipulates_state': False
     }
 
-    def strategy(self, opponent):
+    def strategy(self, opponent: Player) -> Action:
         """
         Check whether the number of cooperations in the first and second halves
         of the history are close. The variance of the uniform distribution (1/4)
@@ -191,12 +193,12 @@ class RandomHunter(Player):
         'manipulates_state': False
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.countCC = 0
         self.countDD = 0
         super().__init__()
 
-    def strategy(self, opponent):
+    def strategy(self, opponent: Player) -> Action:
         """
         A random player is unpredictable, which means the conditional frequency
         of cooperation after cooperation, and defection after defections, should

axelrod/strategies/memorytwo.py

@@ -1,4 +1,4 @@
-from axelrod.actions import Actions
+from axelrod.actions import Actions, Action
 from axelrod.player import Player
 from .titfortat import TitForTat, TitFor2Tats
 from .defector import Defector
@@ -30,7 +30,7 @@ class MEM2(Player):
         'manipulates_state': False
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
         self.players = {
             "TFT" : TitForTat(),
@@ -41,7 +41,7 @@ def __init__(self):
         self.shift_counter = 3
         self.alld_counter = 0
 
-    def strategy(self, opponent):
+    def strategy(self, opponent: Player) -> Action:
         # Update Histories
         # Note that this assumes that TFT and TFTT do not use internal counters,
         # Rather that they examine the actual history of play

type_tests.sh

@@ -31,3 +31,6 @@ mypy --ignore-missing-imports --follow-imports skip axelrod/strategies/mindcontr
 mypy --ignore-missing-imports --follow-imports skip axelrod/strategies/mindreader.py
 mypy --ignore-missing-imports --follow-imports skip axelrod/strategies/mutual.py
 mypy --ignore-missing-imports --follow-imports skip axelrod/strategies/negation.py
+mypy --ignore-missing-imports --follow-imports skip axelrod/strategies/hunter.py
+mypy --ignore-missing-imports --follow-imports skip axelrod/strategies/geller.py
+mypy --ignore-missing-imports --follow-imports skip axelrod/strategies/memorytwo.py