Merge branch 'master' into typeHint-loadData

Author: janga1997

.travis.yml

@@ -18,6 +18,7 @@ install:
   - pip install docutils==0.12
   - pip install coverage
   - pip install coveralls
+  - pip install mypy
 script:
   # Build the documentation
   - cd docs; make html
@@ -27,6 +28,8 @@ script:
   - coverage report -m
   # Run the doctests
   - python doctests.py
+  # Run the type checker
+  - sh ./type_tests.sh
 after_success:
   - coveralls
 notifications:

README.rst

@@ -15,7 +15,7 @@
 Axelrod
 =======
 
-A library with the following principles and goals:
+A Python library with the following principles and goals:
 
 1. Enabling the reproduction of previous Iterated Prisoner's Dilemma research
    as easily as possible.
@@ -26,10 +26,24 @@ A library with the following principles and goals:
 4. Emphasizing readability along with an open and welcoming community that
    is accommodating for developers and researchers of a variety of skill levels.
 
-Currently the library contains well over 100 strategies and can perform a
+Currently the library contains well over 150 strategies including classics such
+as Tit-For-Tat (TFT) and Win-Stay-Lose-Shift (WSLS), recent variants including
+zero-determinant strategies, and a variety of novel strategies including several
+machine-learning based strategies. Many strategies are parameterized, allowing
+for infinitely-many variations. We welcome new strategies and additions from the
+literature: see `#379 <https://github.com/Axelrod-Python/Axelrod/issues/379>`_
+for a list of known strategies and sources.
+
+With these strategies the library and can perform head-to-head Matches, a
 variety of tournament types (RoundRobin, Noisy, Spatially-distributed, and
-probabilistically ending) and population dynamics while taking advantage
-of multi-core processors.
+probabilistically ending) and population dynamics including the Moran process
+on graphs, while taking advantage of multi-core processors.
+
+The library emphasizes reproducibility and validity. The current test suite
+covers more than 99% of all code in the library, with many portions covered many
+times over, including `randomly generated tests
+<https://github.com/HypothesisWorks/hypothesis-python>`_ that are created and
+run regularly.
 
 **Please contribute via pull request (or just get in touch with us).**
 

appveyor.yml

@@ -1,6 +1,7 @@
 environment:
   matrix:
     - PYTHON: "C:\\Python35"
+    - PYTHON: "C:\\Python36"
 install:
   - "%PYTHON%\\python.exe -m pip install -r requirements.txt"
 build: off

axelrod/__init__.py

@@ -4,7 +4,7 @@
 
 # The order of imports matters!
 from .version import __version__
-from .load_data_ import load_lookerup_tables, load_pso_tables, load_weights
+from .load_data_ import load_pso_tables, load_weights
 from . import graph
 from .actions import Actions, flip_action
 from .random_ import random_choice, seed

axelrod/_strategy_utils.py

@@ -2,8 +2,8 @@
 import itertools
 from functools import lru_cache
 
-from axelrod import update_history
-from axelrod import Actions
+from axelrod.player import update_history
+from axelrod.actions import Actions
 
 from axelrod.strategies.cycler import Cycler
 

axelrod/actions.py

@@ -1,6 +1,6 @@
-from typing import NewType
 
-Action = NewType('Action', str)
+# Type alias for actions.
+Action = str
 
 
 class Actions(object):

axelrod/data/lookup_tables.csv

@@ -1,7 +1,13 @@
 from collections import UserDict
 import pickle
+from typing import List, Tuple
 
-from axelrod import Player
+from .actions import Action
+from .player import Player
+
+
+CachePlayerKey = Tuple[Player, Player, int]
+CacheKey = Tuple[str, str, int]
 
 
 class DeterministicCache(UserDict):
@@ -29,7 +35,7 @@ class DeterministicCache(UserDict):
     methods to save/load the cache to/from a file.
     """
 
-    def __init__(self, file_name=None):
+    def __init__(self, file_name: str=None) -> None:
         """
         Parameters
         ----------
@@ -42,7 +48,7 @@ def __init__(self, file_name=None):
             self.load(file_name)
 
     @staticmethod
-    def _key_transform(key):
+    def _key_transform(key: CachePlayerKey) -> CacheKey:
         """
         Parameters
         ----------
@@ -51,16 +57,16 @@ def _key_transform(key):
         """
         return key[0].name, key[1].name, key[2]
 
-    def __delitem__(self, key):
+    def __delitem__(self, key: CachePlayerKey):
         return super().__delitem__(self._key_transform(key))
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: CachePlayerKey) -> List[Tuple[Action, Action]]:
         return super().__getitem__(self._key_transform(key))
 
     def __contains__(self, key):
         return super().__contains__(self._key_transform(key))
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: CachePlayerKey, value):
         """Overrides the UserDict.__setitem__ method in order to validate
         the key/value and also to set the turns attribute"""
         if not self.mutable:
@@ -78,7 +84,7 @@ def __setitem__(self, key, value):
         super().__setitem__(self._key_transform(key), value)
 
     @staticmethod
-    def _is_valid_key(key):
+    def _is_valid_key(key: CachePlayerKey) -> bool:
         """Validate a proposed dictionary key.
 
         Parameters
@@ -116,7 +122,7 @@ def _is_valid_key(key):
         return True
 
     @staticmethod
-    def _is_valid_value(value):
+    def _is_valid_value(value: List) -> bool:
         """Validate a proposed dictionary value.
 
         Parameters
@@ -133,7 +139,7 @@ def _is_valid_value(value):
 
         return True
 
-    def save(self, file_name):
+    def save(self, file_name: str) -> bool:
         """Serialise the cache dictionary to a file.
 
         Parameters
@@ -145,7 +151,7 @@ def save(self, file_name):
             pickle.dump(self.data, io)
         return True
 
-    def load(self, file_name):
+    def load(self, file_name: str) -> bool:
         """Load a previously saved cache into the dictionary.
 
         Parameters

axelrod/deterministic_cache.py

@@ -1,11 +1,11 @@
+from axelrod.result_set import ResultSet
 import random
-
-
+from typing import List, Callable
 class Ecosystem(object):
     """Create an ecosystem based on the payoff matrix from an Axelrod
     tournament."""
 
-    def __init__(self, results, fitness=None, population=None):
+    def __init__(self, results: ResultSet, fitness: Callable[[float], float] =None, population: List[int] =None) -> None:
 
         self.results = results
         self.nplayers = self.results.nplayers
@@ -37,7 +37,7 @@ def __init__(self, results, fitness=None, population=None):
         else:
             self.fitness = lambda p: p
 
-    def reproduce(self, turns):
+    def reproduce(self, turns: int):
 
         for iturn in range(turns):
 
@@ -50,7 +50,7 @@ def reproduce(self, turns):
             # normal distribution based on the payoff matrix and its standard
             # deviations obtained from the iterated PD tournament run
             # previously.
-            payoffs = [0 for ip in plist]
+            payoffs = [0.0 for ip in plist]
             for ip in plist:
                 for jp in plist:
                     avg = self.payoff_matrix[ip][jp]

axelrod/ecosystem.py

@@ -1,21 +1,23 @@
-from axelrod import Actions
-from typing import Tuple
+from .actions import Action, Actions
+from typing import Tuple, Union
 
 C, D = Actions.C, Actions.D
 
+Score = Union[int, float]
+
 
 class Game(object):
     """A class to hold the game matrix and to score a game accordingly."""
 
-    def __init__(self, r: int =3, s: int=0, t: int=5, p:int=1):
+    def __init__(self, r: Score=3, s: Score=0, t: Score=5, p: Score=1) -> None:
         self.scores = {
             (C, C): (r, r),
             (D, D): (p, p),
             (C, D): (s, t),
             (D, C): (t, s),
         }
 
-    def RPST(self):
+    def RPST(self) -> Tuple[Score, Score, Score, Score]:
         """Return the values in the game matrix in the Press and Dyson
         notation."""
         R = self.scores[(C, C)][0]
@@ -24,7 +26,7 @@ def RPST(self):
         T = self.scores[(D, C)][0]
         return (R, P, S, T)
 
-    def score(self, pair) -> Tuple[int, int]:
+    def score(self, pair: Tuple[Action, Action]) -> Tuple[Score, Score]:
         """Return the appropriate score for decision pair.
 
         Returns the appropriate score (as a tuple) from the scores dictionary
@@ -33,7 +35,8 @@ def score(self, pair) -> Tuple[int, int]:
         """
         return self.scores[pair]
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "Axelrod game: (R,P,S,T) = {}".format(self.RPST())
 
+
 DefaultGame = Game()